Standardformat
Die Codekopie lautet wie folgt:
öffentliche Klasse Myclass implementiert serialisierbar {
...}
Serialisierung:
Die Codekopie lautet wie folgt:
ObjectOutputStream output = new ObjectOutputStream (neuer FileOutputStream (AusgabePath));
output.writeObject (myObject);
Deserialisierung:
Die Codekopie lautet wie folgt:
ObjectInputStream input = new ObjectInputStream (neuer FileInputStream (inputPath));
return (myclass) input.ReadObject ();
JSON -Format
Verwenden Sie das Jackson -Paket. Jackson ist ein sehr effizientes Java JSON -Paket. Weitere Dokumentationen und Downloads finden Sie auf der offiziellen Website.
Serialisierung
Die Codekopie lautet wie folgt:
ObjectMapper Mapper = new ObjectMapper ();
Mapper.WriteValue (neue Datei (Ausgabespath), MyObject);
Deserialisierung:
Die Codekopie lautet wie folgt:
return mapper.readValue (neue Datei (OutputPath), myclass.class);
Komplette Testcode
Die Codekopie lautet wie folgt:
Import Java.io.file;
import Java.io.FileInputStream;
importieren java.io.fileoutputStream;
importieren java.io.ioException;
importieren java.io.objectinputStream;
importieren java.io.objectoutputStream;
importieren java.io.serializable;
Import Java.util.ArrayList;
import com.fasterxml.jackson.core.jsongenerationException;
com.fasterxml.jackson.core.jsonParseException;
import com.fasterxml.jackson.databind.jsonmapPingexception;
import com.fasterxml.jackson.databind.objectmapper;
Der öffentliche Klassenzoo implementiert serialisierbar {
private statische endgültige lange Serialversionuid = 1L;
private static ObjectMapper Mapper = new ObjectMapper ();
öffentliches statisches int maxanimalcount;
Public ArrayList <String> Tiere;
public zoo () {
tiere = new ArrayList <string> ();
}
public static void setmax (int max) {
maxanimalcount = max;
}
/**
* Fügen Sie ein Tier zu Tieren hinzu.
* @param AnimalName
*/
public void addanimal (String AnimalName) {
if (tiere.size () <maxanimalcount)
Tiere.Add (AnimalName);
}
@Override
public String toString () {
return "zoo: /n tiere:" + tiere.tostring () +
"/n MaxanimalCount:" + maxanimalcount + "/n";
}
/**
* Ausgabe Standard -Serialisierung in Datei bei Logpath.
* @param logpath
*/
public void serializetolog (String logpath) {
ObjectOutputStream Output = NULL;
versuchen
{
output = new ObjectoutputStream (
neuer FileOutputStream (logpath));
output.writeObject (this);
} catch (Ausnahme e) {
E. printstacktrace ();
} Endlich {
versuchen {
output.close ();
} catch (ioException e) {
E. printstacktrace ();
}
}
}
/**
* Ausgabe der JSON -Serialisierung (mit Jackson) bei LogPath.
* @param logpath
*/
public void serializejsontolog (String logpath) {
versuchen {
Mapper.WriteValue (neue Datei (logpath), dies);
} catch (jsongenerationException e) {
E. printstacktrace ();
} catch (jsonmapPingexception e) {
E. printstacktrace ();
} catch (ioException e) {
E. printstacktrace ();
}
}
/**
* Standard -Deserialize einer Zoo -Instanz aus der Datei bei Logpath.
* @param logpath
* @Return Deserialisierte Zoo -Instanz
*/
public static Zoo DeserializeFromLog (String Logpath) {
ObjectInputStream input = null;
versuchen
{
Eingabe = neuer ObjektInputStream (
neuer FileInputStream (logpath));
return (zoo) input.ReadObject ();
} catch (Ausnahme e) {
E. printstacktrace ();
} Endlich {
versuchen {
input.close ();
} catch (ioException e) {
E. printstacktrace ();
}
}
null zurückkehren;
}
/**
* JSON Deserialize eine Zoo -Instanz aus der Datei bei Logpath.
* @param logpath
* @return JSON Deserialisierte Zoo -Instanz
*/
öffentliches statisches Zoo DeserializejsonFromLog (String LogPath) {
versuchen {
return mapper.readValue (neue Datei (logpath), zoo.class);
} catch (jsonParseException e) {
E. printstacktrace ();
} catch (jsonmapPingexception e) {
E. printstacktrace ();
} catch (ioException e) {
E. printstacktrace ();
}
null zurückkehren;
}
}
Klasse zooserializetest {
public static void main (String [] args) {
Zoo Zoo1 = neuer Zoo ();
Zoo.SetMax (100);
zoo1.addanimal ("Hamster");
zoo1.addanimal ("Schaf");
Zoo1.Serializetolog ("zoo1.log");
Zoo Zoo2 = neuer Zoo ();
Zoo.Setmax (200);
Zoo2.addanimal ("Tiger");
Zoo2.Serializetolog ("zoo2.log");
Zoo.SetMax (300);
// Deserialisierung
Zoo1 = Zoo.DeserializeFromLog ("zoo1.log");
Zoo2 = Zoo.DeserializeFromLog ("zoo2.log");
System.out.println ("zoo1: /n" + zoo1);
System.out.println ("Zoo2: /n" + Zoo2);
// Serialisierung nach JSON
zoo1.serializejsontolog ("zoo1.json");
zoo1 = zoo.deserializejsonfromlog ("zoo1.json");
System.out.println ("Zoo1 von json: /n" + zoo1);
}
}