Several methods of accessing program status - Java IO application talks

File I / O: Files → Serialization

★ File stream file operation is the simplest and most exclusive way, we said that the file operation is not just a "naked" way through FileInputStream / FileOutputStream to write data directly to the local file (like I used to write A mine-mine game Javamine is to save a state of the situation, which is compared to the "underlying". Main class and methods and description

FILEINPUTSTREAM.READ () // Read Data FileReader.Read () // from a local file (text) data fileoutputstream.write () // saves binary data to local files FileWriter.Write ) / / Save character data to local files

★ XML and the above simple I / O mode, XML look much "high-grade", so that it is a standard for data exchange. Take the DOM way, it cares about constructing a document tree in memory, and the data is saved on a node (which can be a leaf node, or the attribute of the label node), the construction of the next one Write an external file, but we only need to know the location of the file, do not know how I / O operation, the XML operation method may also practice more people, so only list related methods, for beginners Learn about. The main package is

Javax.xml.parsers

,

Org.w3c.dom

,

Javax.xml.transform

. Main class and methods and description

DocumentBuilderFactory.newDocumentBuilder (). Parse () // parse an external XML file, get a DOM Document object tree DocumentBuilderFactory.newInstance (). NewDocumentBuilder (). NewDocument () // initialize a DOM tree Document.getDocumentElement () .appendchild () / / Add a sub-node Document.createTextNode () / / generated a string node.getChildNodes () // Node Node Node Node.GetIldNodes () .removechild () / / Delete a node node Document.GtelementsByTagName () finds all the tag nodes of all specified names Document.getElementById () // find a label node that specifies the name, if there are multiple conformity, Then return to a certain one, usually the first element.gettribute () // Value of a value of a label Element.setttribute () // Set a value of a label Element.RemoveAttribute () / / Delete a property of a label TransformerFactory.NewInstance (). NewTransformer (). Transform () // Write a DOM tree into an external XML file

★ Serialization uses basic file read and write mode access data, if we only save the same type of data, you can save it with the same format. For example, when saving a disc in my javamine, you need to save every checkered Coordinates, whether there is mine, whether it is open, etc., these information is combined into a "composite type"; the opposite, if there are multiple different types of data, then we either break down into several parts, with the same type (such as string) Save, either we need to add logic that resolves different types of data formats in the program, which is very inconvenient. So we expect to handle data with a higher level of "high" level, programmers should resolve data as little time and code, in fact, serialization operations provide us with such a way. Serialization, you may have access, it can write objects in a particular coding format or from external byte stream (ie ObjectInputStream

/

ObjectOutputStream

Read. Serialized an object is very simple, just implement the serializable interface, or even use it for it to add any way:

Public class myserial imports java.io.serializable {// ...}

But there is a condition: that is, you have to serialize, each attribute must be "sequentially". This sentence is a bit 拗, in fact, all basic types (which are int, char, boolean, "can be sequentially", and you can look at the JDK documentation, will find that many classes have already implemented serializable (ie It is already "sequential"), so these types of objects and basic data types can be directly used as internal properties that you need sequence. What should I do if I have encountered an attribute of "sequentialization"? Sorry, the class of this property also needs to implement the Serializable interface in advance, so that all attributes are "sequentially". Main class and methods and description

ObjectOutputStream.writeObject () // sequence an object to external byte stream ObjectInputStream.readObject () // read and restructively object from external byte stream

From the actual application, "serializable" interface does not define any way, as if it is just a tag (or a keyword like Java), once the virtual machine sees this "tag", it will try to call itself A predefined serialization mechanism unless you also define a private readObject () or WriteObject () method while implementing the Serializable interface. This is very strange. But if you are not willing to let the system use the default way to serialize, you must define the two methods mentioned above:

public class MySerial implements java.io.Serializable {private void writeObject (java.io.ObjectOutputStream out) throws IOException {// ...} private void readObject (java.io.ObjectInputStream in) throws IOException, ClassNotFoundException {// .. } // ...}

For example, you can call the default serialization method ObjectOutputStream in the writeObject () above WriteObject ().

DEFAULTWRITEOBJECT (); if you don't want to sequence some sensitive properties and information, you can also call the ObjectOutputStream.WriteObject () method to explicitly specify those properties that require sequencement. With regard to user customized serialization, we will mention later. ★ The serialization above the bean is just a basic application. After you sequence the object to the external file, open the file with notepad, you can only guess this is about this class from some readable characters. Document, this requires you to be familiar with the byte encoding method of serialization file, which will be more painful (in

"Core Java 2" first volume

The relevant coding method is mentioned. If you are interested, you can check the references), in some cases, we may need to be serialized with better readability. On the other hand, as a core concept of Java components

Javabeans

"From JDK 1.4," long-term persistence "(long-term persistence) is also required in its specification. Open

JDK documentation

,

Java.beans package

There is a famous ""

ENCODER

"The class, this is a practical class that can serialize the bean. The two main classes related to it have

XMLCODER

with

XMLDecoder

Obviously, this is a tool for saving and reading Bean with an XML file format. Their usage is also very simple, and it is similar to ObjectOutputStream / ObjectInputStream / ObjectInputStream. Main class and methods and description

Xmlencoder.writeObject () // Sequence an object to external byte stream Xmldecoder.ReadObject () // read and restructively object from external byte stream

If a bean is in the following format:

Public class mybean {INT I; char [] C; string s; //... (Get and SET operation omitted) ...}

Then, the XML file serialized through XMlecoder has such a form: