package archivosaleatorios;
// Importamos las clases del paquete [Link]
// donde encontramos la clase RandomAccessFile
import [Link].*;
import [Link].*;
public class ArchivosAleatorios {
public static void main(String[] args) {
/*Si a la hora de pedir los datos devuelve true, es que los datos
se han introducido de forma correcta.*/
if(pedirDatos()){
/*El try catch en programación se utiliza para manejar fragmentos de
código que
son propensos a fallar, como puede ser: recibir un valor nulo, convertir un
tipo de dato a otro o en este caso, la lectura de un archivo.
Al leer un archivo que está almacenado en la memoria del dispositivo (interna o
externa), se genera un flujo de bits (físicamente corriente) desde dicha memoria
a la memoria RAM. Ese flujo puede verse interrumpido por diferentes razones, lo
que causaría que la tarea falle y que el programa se detenga. El try catch lo
que hace es asegurarse que aunque la tarea que se esté ejecutando falle, el
programa se siga ejecutando y no se detenga.
Si el código que está dentro del try falla, se ejecuta el catch y el programa se
sigue ejecutando. Dentro del try se debe de colocar el código que es propenso a
fallar y dentro del catch el código a ejecutarse si el try falla, como puede ser
un mensaje de error.
El try catch se debe utilizar cuando se tenga un fragmento de código que es
propenso a fallar, que se sabe que por una u otra razón puede fallar. Como por
ejemplo la conversión de un tipo de dato a otro:
*/
// Si los datos son correctos, intentamos...
try {
escribirEnArchivoAleatorio();
// Escribimos en el archivo.
//escribirEnArchivoAleatorio(nuevaPersona);
} catch (Exception e) {
[Link]("No se ha podido registrar la persona.");
}
}
/* Si se quiere leer el archivo,
solo debemos llamarlo desde este método, de la siguiente manera*/
leerArchivoAleatorio();
}
// Creamos una variable para leer los datos que se piden por teclado
private static Scanner lectura = new Scanner([Link]);
/* Variables para almacenar los datos de cada persona que se introduce
por teclado. El sexo será 'M' para masculino y 'F' para femenino. Además
los datos, tendrán una longitud fija máxima*/
private static String idPersona=""; // Almacena un id unico de la persona
private static int id=0; // 4 bytes
private static String dniPersona=""; // 9 por 2 bytes = 18 bytes
private static String nombrePersona=""; // 20 por 2 bytes = 40 bytes
private static String apellidoPersona=""; // 20 por 2 bytes = 40 bytes
private static String edadPersona=""; // Contendrá la edad en texto.
private static int edadEntera=0; // 4 bytes
private static char sexoPersona='M'; // 1 caracter x 2 bytes = 2 bytes
// Almacena los bytes que ocupa un registro como máximo.
private static int longitudRegistro =110;
// Variable objeto de tipo Persona que almacena un nuevo objeto Persona.
private static Persona nuevaPersona = new Persona();
// Creamos una variable objeto de tipo RandomAccessFile.
private static RandomAccessFile archivo=null;
/* Variables necesarias para serializar los objetos de tipo Persona
Varaibles para poder escribir en el fichero*/
private static byte []array=null;
private static ByteArrayOutputStream escribir=null;
private static ObjectOutputStream salida=null;
// Variables para poder leer el fichero
private static ByteArrayInputStream leer=null;
private static ObjectInputStream entrada = null;
// Metodo que pide los datos de la persona por teclado.
private static boolean pedirDatos(){
// Pedimos al usuario cada uno de los datos de la persona
do{
[Link]("Introduce el ID de la persona. Este ID "
+ "debe ser mayor que cero: ");
idPersona=[Link]();
// Intentamos pasarlo a número
try {
id=[Link](idPersona);
} catch (NumberFormatException e) {
[Link]("Debes introducir un ID mayor que cero");
}
}while([Link]() || id<=0);
do{
[Link]("Introduce el DNI de la persona: ");
dniPersona=[Link]();
}while([Link]() || [Link]() !=9);
do{
[Link]("Introduce el nombre de la persona: ");
nombrePersona=[Link]();
}while([Link]() || [Link]()>20);
do{
[Link]("Introduce un apellido de la persona: ");
apellidoPersona=[Link]();
}while([Link]() || [Link]()>20);
do{
[Link]("Introduce la edad de la persona: ");
edadPersona=[Link]();
try {
edadEntera=[Link](edadPersona);
} catch (NumberFormatException e) {
[Link]("Debes introducir un número entero");
}
}while([Link]() || edadEntera<=0);
do{
[Link]("Introduce el sexo de la persona. 'M' para "
+ "masculino o 'F' para femenino. (Sin las comillas): ");
sexoPersona=[Link]().charAt(0);
}while(sexoPersona !='M' && sexoPersona !='F');
// Pasamos los datos al objeto Persona
[Link](id);
[Link](dniPersona);
[Link](nombrePersona);
[Link](apellidoPersona);
[Link](edadEntera);
[Link](sexoPersona);
// Devolvemos true
return true;
}
/* Método para escribir en un archivo de acceso aleatorio con la clase
RandomAccessFile.*/
private static void escribirEnArchivoAleatorio(){
try {
/* Creamos o abrimos un nuevo archivo. En este caso:
El primer parámetro hace referencia a la ruta del archivo.
El segundo parametro es el siguiente:
- r - read. Solo lectura.
- rw - read/wirte. Lectura y escritura */
archivo = new RandomAccessFile("src/Registrar_personas.txt", "rw");
// Ponemos el puntero al final del archivo
[Link]([Link]());
// Serializamos el objeto Persona
// Lo convertimos en una secuencia de bytees.
escribir= new ByteArrayOutputStream();
salida = new ObjectOutputStream(escribir);
[Link]([Link]());
// Cerramos el objeto.
[Link]();
// obtenemos los bytes del libro serializado
array = [Link]();
// Escribimos los bytes en el archivo.
[Link](array);
// Cerramos el archivo
[Link]();
} catch (Exception e) {
[Link]("No se puede escribir en el archivo"
+ [Link]());
}
}
// Metodo para leer el archivo de acceso aleatorio
private static void leerArchivoAleatorio(){
try {
/* Creamos o abrimos un nuevo archivo. Este archivo lo crearemos
dentro de la carpeta src de nuestro proyecto. Además debemos tener
en cuenta que el constructor de la clase RandomAccessFile recibe
2 parámetros:
El primero hace referencia a la ruta del archivo.
El segundo hace referencia al modo de apertura del archivo:
- r - read. Solo lectura.
- rw - read/wirte. Lectura y escritura */
archivo = new RandomAccessFile("src/Registrar_personas.txt", "r");
// Nos posicionamos al principio del fichero
[Link](0);
// Almacenamos los bytes del fichero en un array de bytes
array = new byte[(int)[Link]()];
// Leemos todos los bytes del fichero
[Link](array);
// Convertimos ese array de bytes en un objeto.
leer = new ByteArrayInputStream(array);
entrada = new ObjectInputStream(leer);
/* Hacemos una conversion de lo que lee el ObjectInputStream
a un objeto de tipo Persona y lo almacenamos
en la variable objeto nuevaPersona*/
nuevaPersona=(Persona) [Link]();
[Link](nuevaPersona);
// Cerramos el objeto ObjectInputStream
[Link]();
} catch (Exception e) {
[Link]("No se puede leer el archivo"
+ [Link]());
}
}
