public class Persistencia<T> {

public static ArrayList<String> leerArchivoTexto (String ruta) throws IOException

{
File miArchivo = new File(ruta);
FileReader miFileReader = new FileReader(miArchivo);
BufferedReader miBufferReader = new BufferedReader(miFileReader);
String linea;
ArrayList<String> misLineas=new ArrayList<>();
while((linea=miBufferReader.readLine())!=null)
{
misLineas.add(linea);
}

miBufferReader.close();
miFileReader.close();
return misLineas;
}

public static void escribirArchivo (String nombre,

ArrayList <String> miTexto, boolean adicionar ) throws IOException
{
File miArchivo = new File(nombre);
FileWriter miFileWriter = new FileWriter(miArchivo,adicionar);
BufferedWriter miBufferWriter = new BufferedWriter(miFileWriter);
for(String linea: miTexto)
{
miBufferWriter.write(linea+"\n");
}
miBufferWriter.close();
miFileWriter.close();
}

/**
* Permite serializar un archivo
* @param data El objeto del mundo a serializar
* @param nombreArchivo Es la ruta del archivo
* @throws IOException Se produce cuando hay un error de entrada salida
* @throws RuntimeException En caso de error en tiempo de ejecución
*/
public void serialize(T data, String nombreArchivo)throws IOException,RuntimeException
{
FileOutputStream fos = null;
ObjectOutputStream oos = null;
fos = new FileOutputStream(nombreArchivo);
oos = new ObjectOutputStream(fos);
oos.writeObject(data);
oos.close();
fos.close();
}
/**
* Permite deserializar un archivo
* @param nombreArchivo Es el nombre del archivo
* @return El dato serializado
* @throws Exception
* @throws IOException
* @throws RuntimeException
*/
public T deserialize(String nombreArchivo) throws Exception,
IOException,RuntimeException {
T data = null;
FileInputStream fis = new FileInputStream(nombreArchivo);
ObjectInputStream ois = new ObjectInputStream(fis);
data = (T) ois.readObject();
ois.close();
fis.close();
return data;
}

}
 LABORATORIO DE SERIALIZACIÓN

1. Consulte en internet:

Qué es Generics.
Responda en no más de dos líneas.

Cree una nueva clase llamada Persistencia. La clase se encuentra al inicio del documento
Copie y pegue la clase Persistencia que se presenta a continuación. La idea es guardar la
información del mundo sin importar su tipo. Es decir, se hace un método para serializar y
deserializar que acepta cualquier tipo de datos.

2. Cree una aplicación, por ejemplo para una empresa Empresa. En la empresa hay empleados. La
empresa debe permitir calcular el salario promedio de la empresa, el empleado con más sueldo.

3. Agregue a cada clase del paquete mundo “implements Serializable”

5. Modifique la VentanaPrincipal para que implemente la interface WindowListener

public class VentanaPrincipal extends JFrame implements WindowListener

{

Se pretende que cuando la ventana se cierre se almacene el archivo, para lo cual debe modificarse
el método windowClosing

public void windowClosing(WindowEvent arg0) {

guardarArchivo();
System.exit(0);

El método guardar archivo se presenta a continuación:

public void guardarArchivo()
{
try{
Persistencia<Empresa> serMiEmpresa = new Persistencia();
serMiEmpresa.serialize(rutaArchivo, miEmpresa);
}
catch(Exception e)
{ //Aquí poner un mensaje de Error.
};
}

Observe cómo se le reservó memoria a Persistencia, para ello revise la clase

Persistencia, para qué sirve la T

Recuerde declarar dentro de la ventana el siguiente atributo:

private static String rutaArchivo="src/archivo.dat";
La anterior será la ruta en donde quedará guardado nuestro archivo.

6. Agregue el siguiente método en la clase VentanaPrincipal

public void inicializar()
{
miEmpresa=new Empresa();
File fOrig;
fOrig = new File(rutaArchivo );
//Si el archivo no existe
if(!fOrig.exists ( ))
{
Persistencia<Empresa> serMiEmpresa = new Persistencia();
serMiEmpresa.serialize(rutaArchivo, miEmpresa);
}
else
{
//Si el archive existe se deserializa
Persistencia<Empresa> deserMiEmpresa = new Persistencia ();
Empresa newData = deserMiEmpresa.deserialize(rutaArchivo);
miEmpresa=newData;
}
}

7. El método inicializar debe ser la primera línea que se invoque en el constructor de la

VentanaPrincipal
8. Identifique los sitios estratégicos en donde debe invocar el método guardarArchivo.
Tenga en cuenta que hasta ahora solo se almacena cuando se presiona la X para salir de la
ventanaPrincipal.