Formato padrão
A cópia do código é a seguinte:
classe pública MyClass implementa serializável {
...}
Serialização:
A cópia do código é a seguinte:
ObjectOutputStream output = new ObjectOutputStream (new FileOutputStream (outputPath));
output.WriteObject (MyObject);
Deserialização:
A cópia do código é a seguinte:
ObjectInputStream input = new ObjectInputStream (new FileInputStream (inputPath);
return (myclass) input.readObject ();
JSON FORMAT
Use o pacote Jackson. Jackson é um pacote Java JSON muito eficiente. Consulte o site oficial para documentação e downloads.
Serialização
A cópia do código é a seguinte:
ObjectMapper Mapper = new ObjectMapper ();
mapper.WriteValue (novo arquivo (outputPath), myObject);
Deserialização:
A cópia do código é a seguinte:
return mapper.readValue (novo arquivo (outputPath), myclass.class);
Código de teste completo
A cópia do código é a seguinte:
importar java.io.file;
importar java.io.fileInputStream;
importar java.io.fileOutputStream;
importar java.io.ioException;
importar java.io.ObjectInputStream;
importar java.io.ObjectOutputStream;
importar java.io.serializable;
importar java.util.arraylist;
importar com.fasterxml.jackson.core.jsongenorationException;
importar com.fasterxml.jackson.core.jsonparseException;
importar com.fasterxml.jackson.databind.jsonmappingException;
importar com.fasterxml.jackson.databind.objectmapper;
A classe pública Zoo implementa serializável {
private estático final serialversionUid = 1L;
Mapper estático de objeto estático privado = new objectMapper ();
public static int maxanimalCount;
Animais de Arraylist <String> do Arraylist;
public zoo () {
animais = novo ArrayList <String> ();
}
public static void Setmax (int max) {
maxanimalCount = max;
}
/**
* Adicione um animal de animais a animais.
* @param animalName
*/
public void addanimal (string animalname) {
if (animais.size () <maxanimalCount)
Animal.Add (AnimalName);
}
@Override
public string tostring () {
Retornar "Zoo: /N Animais:" + Animal.ToString () +
"/n maxanimalCount:" + maxanimalCount + "/n";
}
/**
* Saída de serialização padrão para arquivo no LOGPath.
* @param LogPath
*/
public void Serializetolog (String LogPath) {
ObjectOutputStream Output = NULL;
tentar
{
output = new ObjectOutputStream (
novo FileOutputStream (LogPath));
output.WriteObject (this);
} catch (Exceção e) {
E.PrintStackTrace ();
} finalmente {
tentar {
output.Close ();
} catch (ioexception e) {
E.PrintStackTrace ();
}
}
}
/**
* Saída de serialização JSON (usando Jackson) para arquivar no LogPath.
* @param LogPath
*/
public void serializejSontolog (String LogPath) {
tentar {
mapper.WriteValue (novo arquivo (LogPath), este);
} Catch (JsongeneationException e) {
E.PrintStackTrace ();
} catch (jsonmappingException e) {
E.PrintStackTrace ();
} catch (ioexception e) {
E.PrintStackTrace ();
}
}
/**
* Deserialize padrão uma instância do zoológico do arquivo no LogPath.
* @param LogPath
* @return
*/
public static zoo desserializefromlog (string logpath) {
ObjectInputStream input = null;
tentar
{
input = new ObjectInputStream (
new FileInputStream (LogPath));
return (zoo) input.readObject ();
} catch (Exceção e) {
E.PrintStackTrace ();
} finalmente {
tentar {
input.Close ();
} catch (ioexception e) {
E.PrintStackTrace ();
}
}
retornar nulo;
}
/**
* JSON Desserialize uma instância do zoológico do arquivo no LogPath.
* @param LogPath
* @return json instância do zoológico desserializada
*/
zoo estático público desesterializejsonfromlog (string logPath) {
tentar {
return mapper.readValue (novo arquivo (LogPath), zoo.class);
} catch (jsonparseException e) {
E.PrintStackTrace ();
} catch (jsonmappingException e) {
E.PrintStackTrace ();
} catch (ioexception e) {
E.PrintStackTrace ();
}
retornar nulo;
}
}
classe ZooserializeTest {
public static void main (string [] args) {
Zoo zoo1 = new zoo ();
Zoo.setMax (100);
zoo1.addanimal ("hamster");
zoo1.addanimal ("ovelha");
zoo1.Serializetolog ("zoo1.log");
Zoo zoo2 = new zoo ();
Zoo.setMax (200);
zoo2.addanimal ("tigre");
Zoo2.Serializetolog ("Zoo2.Log");
Zoo.setMax (300);
// Deserialização
zoo1 = zoo.DeserializeFromlog ("zoo1.log");
zoo2 = zoo.DeserializeFromlog ("zoo2.log");
System.out.println ("Zoo1: /n" + zoo1);
System.out.println ("zoo2: /n" + zoo2);
// serializa para JSON
zoo1.SerializejSontolog ("zoo1.json");
zoo1 = zoo.DeseriejsonFromlog ("zoo1.json");
System.out.println ("ZOO1 de JSON: /n" + zoo1);
}
}