1.

Ficheros en modo Texto

1. 1 Leer. ¿Qué necesito?

FileReader BufferedReader

1. Encuentra el fichero 1. Almacena el contenido

2. Lo abre para lectura del fichero linea a línea
2. Soporta sincronización
1. Ficheros en modo Texto
1. 2 Leer. ¿Cómo lo hago?

Paso 1. Creo un objeto FileReader pasándole Paso 2. Creo un objeto BufferedReader pasándole
la ruta al fichero que queremos leer el objeto FileReader anterior del paso 1

BufferedReader
FileReader
(No me importa de aquí en adelante) Sí me importa. yo, programador, leo del buffer, el resto no me importa

Paso 3. Llamo al método readLine() del objeto BufferedReader anterior

tantas veces como líneas haya en el fichero.
1. Ficheros en modo Texto
1. 3 Leer. Un ejemplo

public static void leerArchivoTexto(String rutaAlFichero) {

FileReader fw;
try {
fw = new FileReader(rutaAlFichero);
BufferedReader br = new BufferedReader(fw);
String lectura = ""; Trato el string leido
do {
lectura = br.readLine();
System.out.println("Leido: " + lectura);
}
while(lectura!=null);

fw.close();
} catch (IOException e) {
System.out.println(e.toString());
}
}
2. Ficheros en modo Texto
2. 1 Escribir. ¿Qué necesito?

FileWriter BufferedWriter

1. Encuentra el fichero. 1. Almacena todos mis datos

Si no lo encuentra, lo 2. Soporta sincronización
crea.
2. Lo abre para escritura
2. Ficheros en modo Texto
2. 2 Escribir. ¿Cómo lo hago?

Paso 1. Creo un objeto FileWriter pasándole Paso 2. Creo un objeto BufferedWriter pasándole
la ruta al fichero que queremos escribir / crear el objeto FileWriter anterior del paso 1

BufferedWriter
FileWriter

Paso 3. Llamo al método write(loQueQuieroEscribir) del objeto BufferedWriter anterior

tantas veces como datos quiera escribir en el fichero.
2. Ficheros en modo Texto
2. 3 Escribir. Un ejemplo

public static void guardarArchivoTexto(String rutaAlFichero, String contenidoAGuardar) {

FileWriter fw;
try {
fw = new FileWriter(rutaAlFichero);
BufferedWriter bw = new BufferedWriter(fw);
bw.write(contenidoAGuardar);
bw.flush(); // Vital
fw.close();
} catch (IOException e) {
System.out.println(e.toString());
}
}
3. Ficheros en modo Binario
3. 1 Escribir. ¿Qué necesito?

FileOutputStream DataOutputStream
1. Encuentra el fichero. 1. Almacena algunos datos
Si no lo encuentra, lo 2. NO Soporta sincronización
crea. 3. La estructura del fichero la eliges tú
2. Lo abre para escritura ¿Seguro que lo harás bien?
¿Seguro que siempre lo haces igual?
3. Ficheros en modo Binario
3. 1 Leer. ¿Qué necesito?

FileInputStream DataInputStream
1. Encuentra el fichero 1. Almacena algunos datos
2. Lo abre para lectura 2. NO Soporta sincronización
3. Hay que conocer la estructura
del archivo para leer -.-!
3. Ficheros en modo Binario
3. 2 Leer. ¿Cómo lo hago?

Paso 3. Llamo al método readX Paso 2. Creo un objeto

del objeto DataInputStream Paso 1. Creo un objeto DataInputStream pasándole
del paso anterior FileInputStream pasándole el objeto FileInputStream
la ruta del fichero a leer del paso anterior

01000001
01110000
01110010 Escribe en
Escribe en

01110101
“Aprobar”
01100101
01100010
01100001 FileInputStream DataInputStream
01110011

readInt();
readFloat();
readX() = readChars();
readChar();
readBoolean();
3. Ficheros en modo Binario
3. 2 Escribir. ¿Cómo lo hago?
Paso 2. Creo un objeto
DataOutputStream pasándole
el objeto FileInputStream
del paso anterior
Paso 3. Llamo al método writeX(valor)
del objeto DataOutpuStream
Paso 1. Creo un objeto creado en el paso anterior
FileOutputStream pasándole
la ruta del fichero a escribir

01000001
01110000
01110010
Escribe en 01110101
Escribe en 01100101
write(”Aprobar”);
01100010
01100001
DataOutputStream FileOutputStream 01110011

writeInt(3);
writeFloat(3.14);
writeX() = writeChars(”Aprobar”);
writeChar(’A’);
writeBoolean(true);
3. Ficheros en modo Binario
3. 2 Leer. Un ejemplo
public static void leerArchivoBinario(String rutaAlFichero) {
try {
FileInputStream fis = new FileInputStream(rutaAlFichero);
DataInputStream dis = new DataInputStream(fis);
String linea = "";
String contenidoTotal = "";
while ((linea = dis.readLine()) != null) {
contenidoTotal += linea;
System.out.println(linea);
}
dis.close();
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
3. Ficheros en modo Binario
3. 2 Escribir. Un ejemplo

public static void guardarArchivoBinario(String rutaAlFichero) {

try {
FileOutputStream fis = new FileOutputStream(rutaAlFichero);
DataOutputStream dis = new DataOutputStream(fis);
for(char i = 'A'; i < 'F'; i++){
dis.writeChar(i);
}
dis.close();
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
5. Clases Serializables
5. 1 Escribir. ¿Qué necesito?

NADA
5. Clases Serializables
5. 2 Escribir. ¿Cómo lo hago?

Paso 1. Implementa la intefaz Serializable

Paso 2. Reemplaza tu DataOutputStream por ObjectOutputStream y writeX por writeObject

5. Clases Serializables
5. 3 Escribir. Un ejemplo

try {
FileOutputStream fos = new FileOutputStream("data/salidaObjetos.dat");
ObjectOutputStream out = new ObjectOutputStream(fos);
Aminoacido lisina = new Aminoacido("C5H9NO", "Valine");

// Method for serialization of object

out.writeObject(lisina);
out.close();
fos.close();
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
4. Clases Serializables
4. 1 Leer. ¿Qué necesito?

NADA
4. Clases Serializables
4. 2 Leer. ¿Cómo lo hago?

Paso 1. Implementa la intefaz Serializable

Paso 2. Reemplaza tu DataInputStream por ObjectputStream y readX por readObject

4. Clases Serializables
4. 3 Leer. Un ejemplo

try {
FileInputStream fis = new FileInputStream("data/salidaObjetos.dat");
ObjectInputStream oit= new ObjectInputStream(fis);

Aminoacido lisina = new Aminoacido("", "");

lisina = (Aminoacido) oit.readObject();
oit.close();
fis.close();
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
6. Archivos. Directorios
6. 1 ¿Qué es un archivo? ¿Qué es un directorio?

Un archivo es un conjunto de bytes que tienen una organización

conocida por el Sistema Operativo y que sirve para almacenar datos.

Un directorio es un conjunto de bytes que tienen una organización

conocida por el Sistema Operativo y que sirve para almacenar datos.

¿Bromeas?

En absoluto. Es lo mismo la diferencia está en los datos que almacena.

El directorio contiene los datos sobre los archivos, y los archivos contienen
cualquier tipo de dato que no sea los de otros archivos.
6. Archivos. Directorios
6. 2 ¿Y qué hago yo con esto?

No
En cualquier lenguaje de programación NO existe diferencia conceptual entre fichero y
directorio. En Java, existe la clase File , que nos permite averiguar si un File contiene
información de verdad (archivo) o sobre otro archivo (directorio).

Los métodos más destacados son:

f.isFile() : devuelve true si el fichero contiene información de verdad (archivo)

f.isDirectory(): devuelve true si el fichero contiene información de otro archivo.
f.canRead(): devuelve true si tienes permiso de lectura
f.canWrite(): devuelve true si tienes permiso de escritura
f.exists(): devuelve true si existe el fichero en {RAM,Disco}
f.length(): devuelve el número de bytes del fichero