Muy a menudo necesitamos almacenar cierta cantidad de datos de forma más o menos

permanente. La memoria del ordenador es volátil, y lo que es peor, escasa y cara. De modo que
cuando tenemos que guardar nuestros datos durante cierto tiempo tenemos que recurrir a sistemas
de almacenamiento más económicos, aunque sea a costa de que sean más lentos. Durante la historia
de los ordenadores se han usado varios métodos distintos para el almacenamiento de datos. Al
principio se recurrió a cintas de papel perforadas, después a tarjetas perforadas. Hasta aquí, todos los
sistemas de almacenamiento externo eran secuenciales, es decir, no permitían acceder al punto
exacto donde se guardaba la información sin antes haber partido desde el principio y sin haber leído
toda la información, hasta el punto donde se encontrase la que estábamos buscando. Con las cintas
magnéticas empezó lo que con el tiempo sería el acceso aleatorio a los datos.

Ya hemos comentado que el acceso a los ficheros es lento, y lo es mucho, comparado con el
acceso a memoria. Es por eso que, generalmente, no se accede a ficheros externos cada vez que se
realiza una operación de lectura o escritura. En su lugar, se mantiene una copia de una parte del
fichero en la memoria, se realizan las operaciones de lectura/escritura que sea posible dentro de esa
zona, y cuando sea necesario, porque alguna operación acceda a posiciones fuera de la zona
almacenada, se vuelca esa zona al fichero y se lee otro tramo del fichero en memoria. A estas zonas se
le llaman buffers, y mejoran sensiblemente el acceso a los ficheros en lo que respecta a la velocidad.
En el caso ideal, el tamaño del buffer es mayor o igual que el del fichero, y todas las operaciones de
lectura y escritura del fichero se realizan en memoria, de modo que sólo es necesario hacer una
lectura del fichero y, si se ha modificado, una escritura. Para establecer una secuencia o un canal a
través del cual podemos escribir datos en un archivo o leer datos de un archivo, se utilizan objetos de
secuencia, las clases que se utilizan para crear estos objetos se heredan especialmente de las clases
principales InputStream y OutputStream.

Hay varias clases en Java que implementan métodos para leer y escribir archivos, y que lo hacen
en niveles muy bajos, que son bytes, y en niveles más altos, como caracteres, cadenas e incluso
objetos. En este caso, veremos clases que implementan métodos para leer y escribir a nivel de
personaje. Esta clase le permite escribir secuencias de caracteres, es decir, una cadena tiene varios
constructores, pero dejo los 2 más utilizados. La clase de bufferedwriter puede escribir archivos de
manera segura usando FileWriter, pero puede ser muy costoso. Por ejemplo, si desea escribir 10 líneas
de texto, con FileWriter necesita hacer 10 accesos al disco, uno para cada línea, porque el búfer es
más pequeño. Esto se resuelve utilizando BufferedWriter, ya que guarda todo el texto que desea
escribir en el búfer intermedio y lo envía a un archivo desde allí, en lugar de hacer 10 accesos de disco
para cada línea.

Es necesario crear un objeto de tipo Archivo tener más control, por ejemplo, para averiguar si
existe un archivo. Para abrir una secuencia para esto, debe crear un objeto de tipo FileReader para
leer o FileWriter para escribir y transferir el objeto de archivo. Con las clases BufferedWriter y
BufferedReader, se crea un búfer intermedio en el que se transfieren los objetos de la secuencia
principal. Leer o escribir en un archivo. Cierre la secuencia, primero el búfer intermedio y luego la
secuencia principal. Concluyendo en el lenguaje Java y otros lenguajes orientados a objetos, se suele
decir, "Todo es un archivo", debido a como trabajan estos. Archivos, en ocasiones puede referirse a las
librerías, pero creo prudente hacer diferencias, una librería es una utilidad para el lenguaje en que
programamos, mientras que un archivo es una utilidad mas cercana a nosotros (en lo posible,
desarrollado por nosotros).
 República Bolivariana de Venezuela
Ministerio del Poder Popular para la Educación
Instituto Politécnico Universitario “Santiago Mariño”
Extensión Maturín

PROGRAMACIÓN NO NUMÉRICA II

Profesor: Autor:
Ing. Carlos Ramos TSU. Rafael Rojas 21.350.587

Maturín, agosto de 2019

public class Estudiante {
private String cedula;
private String nombres;
private String apellidos;
//constructor vacio
public Estudiante() {
}
//getters y setters
public String getCedula() {
return cedula;
}
public void setCedula(String cedula) {
this.cedula = cedula;
}
public String getNombres() {
return nombres;
}
public void setNombres(String nombres) {
this.nombres = nombres;
}
public String getApellidos() {
return apellidos;
}
public void setApellidos(String apellidos) {
this.apellidos = apellidos;
}
}
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Scanner;
public class OperacionArchivo{
//crea el archivo en disco, recibe como parámetro la lista de estudiantes
public static void crearArchivo(ArrayList<Estudiante> lista) {
FileWriter flwriter = null;
try {
//crea el flujo para escribir en el archivo
 flwriter = new FileWriter("/home/zero/archivo.txt");
//crea un buffer o flujo intermedio antes de escribir directamente en el archivo
BufferedWriter bfwriter = new BufferedWriter(flwriter);
for (Estudiante estudiante : lista) {
//escribe los datos en el archivo
bfwriter.write( estudiante.getCedula() + "," +
estudiante.getNombres() + "," +
estudiante.getApellidos()+ "\n");
}
//cierra el buffer intermedio
bfwriter.close();
System.out.println("Archivo creado satisfactoriamente..");

} catch (IOException e) {
e.printStackTrace();
} finally {
if (flwriter != null) {
try {//cierra el flujo principal
flwriter.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}

//crea el archivo en disco, retorna la lista de estudiantes

public static ArrayList leerArchivo() {
// crea el flujo para leer desde el archivo
File file = new File("/home/zero/estudiantes.txt");
ArrayList <Estudiante> listaEstudiantes= new ArrayList<Estudiante>();
Scanner scanner;
try {
//se pasa el flujo al objeto scanner
scanner = new Scanner(file);
while (scanner.hasNextLine()) {
// el objeto scanner lee linea a linea desde el archivo
String linea = scanner.nextLine();
Scanner delimitar = new Scanner(linea);
//se usa una expresión regular
 //que valida que antes o despues de una coma (,) exista cualquier cosa
//parte la cadena recibida cada vez que encuentre una coma

delimitar.useDelimiter("\\s*,\\s*");
Estudiante e= new Estudiante();
e.setCedula(delimitar.next());
e.setNombres(delimitar.next());
e.setApellidos(delimitar.next());
listaEstudiantes.add(e);
}
//se cierra el ojeto scanner
scanner.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
}
return listaEstudiantes;
}

//añadir más estudiantes al archivo

public static void aniadirArchivo(ArrayList<Estudiante> lista) {
FileWriter flwriter = null;
try {//además de la ruta del archivo recibe un parámetro de tipo boolean, que le
indican que se va añadir más registros
flwriter = new FileWriter("/home/zero/estudiantes.txt", true);
BufferedWriter bfwriter = new BufferedWriter(flwriter);
for (Estudiante estudiante : lista) {
//escribe los datos en el archivo
bfwriter.write( estudiante.getCedula() + "," +
estudiante.getNombres() + "," +
estudiante.getApellidos() + "," + "\n");
}
bfwriter.close();
System.out.println("Archivo modificado satisfactoriamente..");
} catch (IOException e) {
e.printStackTrace();
} finally {
if (flwriter != null) {
try {
flwriter.close();
} catch (IOException e) {
 e.printStackTrace();
}
}
}
}
}
import java.util.ArrayList;
public class TestArchivo {
public static void main(String[] args) {
// estructura Array List para guardar los objetos estudiantes
ArrayList<Estudiante> listaEstudiantes = new ArrayList<>();
// estudiante 1
Estudiante estudiante1 = new Estudiante();
estudiante1.setCedula("587");
estudiante1.setNombres("Rafael");
estudiante1.setApellidos("Rojas");
// añade un estudiante a la lista
listaEstudiantes.add(estudiante1);
// estudiante 2
Estudiante estudiante2 = new Estudiante();
estudiante2.setCedula("309");
estudiante2.setNombres("Chris");
estudiante2.setApellidos("Vivas");
// añade un estudiante a la lista
listaEstudiantes.add(estudiante2);
//añade un estudiante más al archivo
OperacionArchivo.aniadirArchivo(nuevaLista);
// lista para recibir los objetos estudiantes desde el archivo
ArrayList<Estudiante> listaLeida = new ArrayList<>();
// asignar a la lista los objetos
listaLeida = OperacionArchivo.leerArchivo();
for (Estudiante estudiante : listaLeida) {
System.out.println( estudiante.getCedula() + " " +
estudiante.getNombres() + " " +
estudiante.getApellidos()
);
}
}
}