Tema 6. Lectura y Escritura de La Información

TEM
A
Tema 6. Lectura y escritura de la información
Autoría: Cristian Catalán

Informática. Programación I
Tema 6: Lectura y escritura de la información
¿Qué aprenderás?
• Utilizar los Stream y Buffers para leer y escribir información desde periférico.
• Crear, eliminar y renombrar archivos.
• Modificar el contenido de un archivo de texto.
• Crear carpetas y modificar su contenido.
¿Sabías que…?
• Los sistemas de ficheros se encargan de definir como almacenar e identificar los

ficheros en disco.
• Los sistemas de ficheros los podemos agrupar según el tipo de datos y el tipo de
almacenamiento en:
§ De disco: FAT, NTFS, EXT2/3, UDF..
§ De bases datos: BFS, WinFS ,--
§ De transacciones: ReiserFS, Ext3, …
§ De red: NFS, SMB, AFS, ..
§ Otros: Procfs, Devfs…
1. Características de los Arrays en Java
Para trabajar con archivos es imprescindible utilizar estructuras de datos que permitan
almacenar distintos valores. Anteriormente ya vimos para tal fin las estructuras Arrays.
A continuación haremos un repaso de las Arrays a modo de recordatorio.
Un Array es una estructura que permite almacenar un número fijo de distintos valores de
un mismo tipo. El número de valores que contiene una Array será su “longitud” y no es un
valor alterable.
A cada valor le asociaremos un identificador numérico empezando por 0.
Un array se puede representar gráficamente como un conjunto de celdas, cada una con su
valor y su dirección. El siguiente ejemplo representa una Array que almacena 4 nombres:
0 1 2 3
1.1 . Declarar un array
Podemos declarar una variable del tipo Array con la sintaxis: TipoDato[] nombreVariable;
Por ejemplo, vamos a crear una Array para contener Strings:
String[] miPrimerArrayDeStrings;
Una vez declarada la variable la inicializamos indicándole el número de elementos que
contendrá con la sintaxis: nombreVariable = new TipoDato[ longitudArray ];
Por ejemplo, vamos a indicar que el array pueda contener 5 strings:
miPrimerArrayDeStrings = new String [5];
Podemos combinar los dos ejemplos anterior en una única línea:
String[] miPrimerArrayDeStrings = new String[5] ;
Los valores que contiene un array serán inicializados cuando le indiquemos su longitud con
un valor que dependerá del tipo de variable:
• variables numéricas con un 0
• objetos a null
• variables booleanas a false
• variables del tipo char a ‘\u0000’).
2
Podemos indicar los valores de un array cuando la declaramos con la sintaxis:

TipoDato[] nombreArray={primerValor, segundoValor, tercerValor, ….. } ;
Por ejemplo, si queremos crear un array formado por los nombres “Elena” y “Jose”
escribiremos:
String[] nombres = {“Elena”, “Jose”};
En el caso anterior, la longitud del array se va a corresponder con el número de elementos
que declaremos entre las llaves { }. El array anterior lo podríamos representar como:
0 1
1.2 . Acceder a los valores de un Array
Accedemos a una posición del array con: nombreArray[posicion]

Asignamos un nuevo valor a una posición con: nombreArray[posición] = nuevoValor;
Obtenemos el valor de una posición con: variable = nombreArray[posicion];
Podemos utilizar un bucle para recorrer y acceder a todos los elementos de un array
teniendo presente que accedemos a la longitud de un array con la sintaxis:
nombreDelArray.length;
En el siguiente ejemplo se utiliza un bucle para obtener y mostrar por consola los valores:
“Kim”, “John” y “Cris”.
3
public class EjemploArrays {

public static void main(String[] args) {
String [] nombres; //declaramos la variable nombres como un array de Strings
nombres = new String[3]; //inicializamos el array con una longitud de 3
nombres[0]="Kim"; //modificamos el 1r elemento para que su valor sea Kim

nombres[1]="John"; //modificamos el 2o elemento para que su valor sea John
nombres[2]="Cris"; //modificamos el 3r elemento para que su valor sea John
int longitudArray = nombres.length; //guardamos la longitud en una variable
for(int k=0;k<longitudArray;k++){ //recorremos el array

String nombre = nombres[k]; //obtenemos el valor en la posición k
System.out.println(nombre); //en cada iteración de bucle imprimirá un valor
}
}
}
Cuando recorramos un array podemos utilizar también una estructura for loop para
recorrer un array. En ésta estructura definiremos una variable que irá obteniendo los
distintos valores de un array.
La sintaxis es: for( TipoDatoArray variable : arrayQueRecorremos){ … }
Así el ejemplo anterior nos quedaría:
public class EjemploArrays {

public static void main(String[] args) {
String [] nombres;
nombres = new String[4];
//rellenamos el array
nombres[0]="Kim";
nombres[1]="John";
nombres[2]="Cris";
//recorremos el array con un for loop
for (String nombre : nombres) {
System.out.println(nombre);
}
}
}
Ahora que hemos visto como recorrer un array para mostrar su información, vamos a ver
cómo puede el usuario establecer la longitud del array y rellenarla mediante un bucle.
4
1.3 . Uso de arrays en funciones
Cuando queramos pasar una Array como parámetro tendremos que indicar que el tipo de
parámetro que va a recibir una función va a ser del tipo array. Para ello utilizaremos la
sintaxis:
public static tipoRetorno nombreFuncion( tipoValorArray[] nombreArray){ …. }
Cuando queramos indicar que una función va a retornar una Array que contendrá un cierto
tipo de valores utilizaremos la sintaxis:
public static tipoValorArray[] nombreFuncion() { …..}
En el siguiente ejemplo podemos observar como la función generaOtroArray() clona el

array que recibe como parámetro para modificar su contenido sin alterar el array original y
retornando el nuevo array modificado. Al ejecutarlo veremos cómo números y otroArray
efectivamente son arrays distintos mostrando por consola el siguiente texto:
valores del array: 3,2,8,
valores del array: 33,2,8
iguales: false
2. Concepto y tipo de acceso
Hasta ahora cada vez que hemos ejecutado un programa éste se ha ejecutado desde cero.
Pero si quisiéremos poder ejecutar un programa recuperando los valores de la última vez
que se ha ejecutado necesitaríamos almacenar estos valores en estructuras de datos
persistentes como un fichero o una base de datos.
Un fichero o archivo es una secuencia de bytes almacenada en la memoria persistente de
la computadora e identificada y gestionada por un sistema de ficheros formando una
entidad lógica.
Cada fichero tiene asociado un nombre que ha de ser único dentro del directorio en el que
se crea. Eso convierte la ruta hacia el directorio en el identificador inequívoco del fichero.
El tamaño y contenido de un fichero puede variar en cualquier momento. El sistema de
ficheros del sistema operativo será el encargado de controlar en todo momento quien
tiene acceso al fichero evitando que dos programas lo puedan modificar en el mismo
instante. Cada vez que queramos modificar o leer un fichero tendremos que pedir permiso
al sistema de ficheros.
5
En función de cómo queramos acceder a un fichero para leer o modificarlo vamos a poder
diferenciar dos métodos de acceso:
• Acceso secuencial: accedemos a los valores contenidos en el fichero como si fuera
un archivo de texto, empezando por la primera palabra hasta que encontremos el
valor que queremos y decidamos detener la lectura. Es un método cuya rapidez
dependerá de lo pronto o tarde que encuentre la información.
• Acceso directo: accedemos directamente a la posición del contenido que quiero
modificar. Éste acceso es más rápido pero implica conocer exactamente la posición
en donde quiero leer/modificar un dato.
Aunque podríamos modificar manualmente cada 0 y 1 que componen el contenido de un

fichero, utilizaremos funcionalidades Java para leer y escribir texto formateado.
3. Gestión de archivos y carpetas con File
Para trabajar con ficheros utilizaremos variables del tipo File. Estas variables nos van a
permitir gestionar toda la información relativa a ficheros y carpetas a partir de la ruta de
acceso al archivo o carpeta. Las funciones de File relativas al tratamiento de carpetas no
funcionarán si la variable hace referencia a un archivo y evidentemente las funciones
relativas al tratamiento de archivos no funcionarán si la variable File hace referencia a una
carpeta.
Para crear una nueva variable del tipo File utilizaremos la sintaxis:
File nombreVariableFile = new File (“ruta al archivo o carpeta”);
Para utilizar alguna de sus funciones asociadas utilizaremos la sintaxis:
nombreVariableFile.nombreFuncion();
Algunas de las funciones más importantes que va a tener una variable File son:
• .isDirectory(); Retorna true o false según la variable haga referencia a un
directorio o no.
• .isFile(); Retorna true o false según la variable haga referencia a un archivo o no.
• .exists(); retorna true o false según haga referencia a un archivo o directorio que
exista o no.
• .canRead(); retorna true o false según tengamos o no permisos de lectura.
• .canWrite(); retorna true o false según tengamos o no permisos de escritura.
• .length(); retorna un valor long con la longitud del archivo.
6
• .getName(); retorna una String el nombre del fichero o carpeta.

• .getParent() retorna el nombre de la carpeta padre que contiene el fichero o
carpeta.
• .getPath(): retorna la ruta relativa del archivo.
• .mkdir(); crea una carpeta en la ruta indicada en la variable File siempre que no
exista previamente. Retorna true si se ha podido crear y false en caso contrario.
• .createNewFile(); crea un archivo en blanco en la ruta definida en la variable File
siempre que no exista previamente. Retorna true o false según si se ha podido
crear o no.
• .renameTo(File); la variable File desde la que se llama la función se le asigna el
nombre de la variable File pasada como parámetro. Las dos variables han de
apuntar a la misma carpeta. Retorna true o false según si se ha podido renombrar
o no.
• .delete(); borra el archivo o carpeta referenciados en la variable File. Retorna true
o false según se haya o no podido eliminar el archivo o carpeta.
• .list(); retorna un array de Strings con el nombre de los ficheros contenidos en la
carpeta referenciada en la variable File. Es posible pasar un filtro como parámetro
para obtener solo un tipo de ficheros.
• listFiles(); retorna un array de variables del tipo File que hacen referencia a los
ficheros y directorios contenidos dentro de la carpeta referenciada en la variable
File.
4. Elementos básicos en la escritura y lectura de información
Java clasifica la escritura y lectura de datos entre aquellas operaciones que se dan entre las
propias variables del programa y aquellas operaciones con elementos externos al
programa, los que llamaremos periféricos. Un periférico va a poder ser el teclado, la
pantalla, un fichero, una impresora, un scanner etc… y siempre que trabajemos leyendo o
escribiendo datos contra un periférico utilizaremos dos grandes grupos de variables: los
Streams y los Buffers.
Cuando creemos una variable del tipo Stream le vamos a tener que vincular un periférico.
A través de esta variable podremos escribir o leer bytes con el periférico.
Como nosotros no estamos acostumbrados a trabajar con bytes, a cada Stream que
creemos le asociaremos un Buffer que nos permitirá comunicarnos con el Stream a través
de Strings en vez de bytes.
Ya veremos que de variables tipo Stream y Buffer encontraremos un gran variedad
dependiendo del tipo de periférico con el que queramos conectar, del tipo de acceso y si
vamos a realizar operaciones de lectura y escritura.
7
Por cierto, la gran mayoría de variables del tipo Stream y Buffers las encontraremos en el
package: java.io . El nombre java.io hace referencia a operaciones de Input/Output
(lectura/Escritura). Así que deberemos importar la librería con: import java.io.*;
5. Escritura secuencial a ficheros
Para la escritura secuencial sobre un fichero utilizaremos el siguiente tipo de variables:

• File : para gestionar la información del fichero. Al crear la variable del tipo File le
vincularemos la ruta al fichero con la sintaxis:
File variableFile = new File(ruta_al_documento);
• FileWriter: como variable del tipo Stream para conectar y escribir sobre el fichero.
Al crear la variable le vincularemos el fichero con la sintaxis:
FileWriter variableFileWriter = new FileWriter(variableFile);
FileWriter también admite como parámetro la ruta al documento:
FileWriter variableFileWriter = new FileWriter (ruta_al_documento);
• BufferedWriter: como variable del tipo Buffer a la que escribiremos Strings para
que se los pase a FileWriter. Al crear la variable le vincularemos el stream
FileWritter con la sintaxis:
BufferedWriter variableBuffer = new BufferedWriter(variableFileWriter);
Una vez creadas las variables necesarias utilizaremos las funciones de la variableBuffer
para escribir, vaciar y cerrar la comunicación con el fichero. La sintaxis será la siguiente:
• variableBuffer.write(“texto a escribir”); : para escribir un texto en el fichero.
• variableBuffer.flush(); : para escribir todo aquello que pudiera haber quedado
pendiente en el buffer y vaciarlo.
• variableBuffer.close(); : para finalizar la comunicación con el fichero.
8
En el siguiente código se muestra un ejemplo en el que se accede a un documento con la

ruta “d:\ejemplo.txt” para escribir el texto “Nuevo texto” y finalmente cerrar la conexión:
import java.io.*;
public class EjemploEscrituraFichero {
public static void main(String[] args) throws IOException {

String ruta_al_documento="d:/ejemplo.txt";
File document = new File(ruta_al_documento); //información sobre el fichero
FileWriter fw = new FileWriter(document); //Stream conectado al fichero a escribir.
BufferedWriter bw = new BufferedWriter(fw); //Buffer que almacena datos hacia el stream
bw.write("Nuevo texto"); //guarda los datos en el buffer
bw.flush(); //envia los datos que queden al buffer
bw.close(); //se liberan los recursos asignados al outputStream
}
}
En el siguiente diagrama podemos ver representados los distintos elementos que

intervienen en la escritura secuencial sobre un fichero. BufferedWriter recibe Strings del
programa y escribe ésas strings divididas en bytes (carácter a carácter) en el archivo
destino:
Diagrama que representa los elementos necesarios para escribir en un archivo secuencialmente
¡Atención! Cada vez que abramos el archivo para escribir en él se borrarán todos los datos
contenidos. Si queremos añadir contenido tendremos que leer el contenido, guardarlo en
una String, modificar la String y escribirla como el contenido del nuevo archivo.
9
6. Lectura secuencial de ficheros
Para la lectura secuencial de un archivo utilizaremos el siguiente tipo de variables:

• File : para gestionar la información del archivo. Al crear la variable del tipo File le
vincularemos la ruta al archivo con la sintaxis:
File variableFile = new File(ruta_al_documento);
• FileReader: será el Stream que conectará con archivo para poder leer su contenido
byte a byte. Al crear la variable le vincularemos el archivo con la sintaxis:
FileReader variableFileReader = new FileReader(variableFile);
FileReader también admite como parámetro la ruta al documento:
FileReader variableFileReader = new FileReader(ruta_al_documento);
• BufferedReader: lo vincularemos con FileReader y nos va a permitir leer el
contenido del archivo línea a línea. Al crear la variable le vincularemos el stream
FileReader con la sintaxis:
BufferedReader variableBuffer = new BufferedReader (variableFileReader);
Una vez creadas las variables necesarias utilizaremos las funciones de la variableBuffer
para leer una línea y cuando queramos cerrar la comunicación con el archivo. La sintaxis
será la siguiente:
• variableBuffer.readLine(); : para leer una línea del archivo (hasta encontrar un salo
de línea).
• variableBuffer.close(); : para finalizar la comunicación con el archivo.
En el siguiente código se muestra un ejemplo en el que se accede a un documento con la

ruta “d:\ejemplo.txt” para escribir el texto “Nuevo texto” y finalmente cerrar la conexión:
import java.io.*;

String ruta_al_documento="d:/ejemplo.txt";
File document = new File(ruta_al_documento); //información sobre el fichero
FileReader fr = new FileReader(document); //Stream conectado al fichero a leer.

BufferedReader br = new BufferedReader(fr); //Buffer que almacena datos del stream
String linea = br.readLine(); //leemos una línea del documento
br.close(); //cerramos el buffer
System.out.println(linea); //mostramos por consola el texto leído }

}
10
En el siguiente diagrama podemos ver representados los distintos elementos que

intervienen en la lectura secuencial de un fichero. BufferedReader recibe caracteres del
Stream y retorna Strings cada vez que se le llama a readLine():
Diagrama que representa los elementos necesarios para leer los valores de un archivo secuencialmente
¡Atención! Cada vez que ejecutemos br.readLine() obtendremos una string con el siguiente
contenido almacenado en el archivo hasta encontrar un salto de línea. Si mi archivo
contiene 3 líneas cada vez que ejecute br.readLine() me retornará una línea, la cuarta vez
me retornará un null porque ya no hay más texto dentro del archivo.
Teniendo presente que obtendremos un null cuando ya no queden más datos en un
archivo, podemos crear un bucle para mostrar todo el contenido de un archivo ejecutando
en cada iteración un br.readLine() hasta obtener null;
El siguiente ejemplo muestra una posible solución para mostrar todo el contenido de un
array utilizando un bucle for.
for( String linea=br.readLine(); linea != null; linea=br.readLine() ){
System.out.println(linea); //mostramos por consola el texto leído
11
7. Valores del sistema para trabajar con archivos
Como Java es un lenguaje que puede funcionar en distintos sistemas operativos tenemos
que diseñar nuestros programas para que funcionen independientemente de la plataforma
en la que se ejecuten. Al trabajar con archivos tendremos que tener presente que cada
sistema operativo puede tener un sistema de archivos muy distinto, con separadores de
carpeta y unidades propias.
Vamos a ver ahora algunos aspectos que tenemos que tener presente para garantizar la
interoperabilidad de nuestro programa.
7.1 . Rutas de archivos relativas vs absolutas
En los ejemplos anteriores hemos accedido a un archivo ubicado en “D:\ejemplo.txt”, pero

¿qué ocurre si el ordenador que ejecuta el código no dispone de unidad D? Efectivamente
se mostraría un error al no poder acceder a la ubicación.
Éste tipo de direcciones en las que se indica todo el path completo las llamaremos “rutas
absolutas” y las evitaremos utilizar a toda costa en la programación. En vez de ello
utilizaremos “rutas relativas”, que serán rutas en donde como programadores solo
indicaremos la ubicación del archivo respecto a nuestro programa y la ubicación del
programa se lo preguntaremos al Sistema Operativo.
Para conocer la ruta absoluta a nuestro proyecto utilizaremos la función
getProperty(“user.dir”); de System.
La siguiente línea guarda en rutaProyecto la ruta hasta nuestro proyecto:
String rutaProyecto = System.getProperty("user.dir");
7.2 . Separadores en las rutas según el sistema operativo
Cada sistema operativo va a poder utilizar un carácter para separar las carpetas al
especificar una ruta. Así por ejemplo en Windows la ruta a un archivo ubicado en la
carpeta ejemplo podría ser: ejemplo\nombreArchivo.txt. Mientras en Unix sería:
ejemplo/nombrArchivo.txt.
Para conocer qué carácter utiliza el sistema operativo que ejecuta mi programa para
separar las carpetas en una ruta utilizaremos la propiedad separator de File.
La siguiente línea guarda en separador el carácter utilizado para separar carpetas:
String separador = File.separator
12
7.3 . Saltos de línea
Cuando queramos insertar un salto de línea en un archivo de texto llano deberemos

utilizar una combinación de caracteres especiales que pueden depender también del
sistema operativo.
Para conocer qué String utiliza el sistema operativo que ejecuta mi programa para indicar
un salto de línea separator utilizaremos la función getProperty(“line.separator”); de
System.
La siguiente línea guarda en saltoLinea la string utilizada para insertar un salto de línea:
String saltoLinea = System.getProperty(“line.separator”);
En el siguiente ejemplo podemos ver cómo utilizar correctamente los valores del sistema
para trabajar con archivos:
Vídeo: Trabajar_con_archivos: Modificación y lectura de un archivo utilizando los valores del sistema
13
8. Acceso directo a ficheros
Hasta ahora hemos visto como acceder a ficheros de forma secuencial. Al acceder
directamente a un fichero su contenido va a ser tratado como un array de chars al que
tendremos asociado una variable del tipo RandomAccessFile que contendrá una variable
apuntando a una posición de ese array. Cada vez que queramos leer o escribir en el
archivo deberemos apuntar a una posición en concreto y luego o bien leer o escribir un
carácter.
Cuando nos refiramos al “puntero” de RandomAccessFile nos estaremos refiriendo a esa
variable que va a apuntar a una dirección en concreto.
El siguiente esquema ilustra cómo un fichero de texto es transformado en un array de

bytes (cada byte contiene una variable char).
En Java vamos a poder acceder a de forma directa al contenido de un fichero utilizando

una variable del tipo RadomAccessFile. La sintaxis va a ser:
RandomAccessFile variable = new RandomAccessFile(“ruta archivo”,”modoAcceso”);
El modo de acceso es una string que puede tener dos valores:
• “r” indicando que queremos acceder al archivo solo para leer su contenido.
• “rw” indicando que queremos acceder al archivo para leer y modificar su contenido.
Las principales funciones que RandomAccessFile nos ofrece para trabajar con archivos son
las siguientes:
• .seek(numero); sitúa el puntero en la posición indicada por el número. La primera
posición es la 0.
• .readByte(); retorna el byte en el que se ha situado el puntero.
• .writeBytes(“texto”); se sustituyen los bytes siguientes a la posición en donde esté el
punto por cada carácter del texto pasado como String. Automáticamente se
incrementa la longitud del archivo si es necesario.
• .readLine(); avanza el puntero hasta el primer salto de línea o fin de fichero y retorna
una string con todos los caracteres leídos.
• .length(); retorna la longitud del fichero.
• .getFilePointer(); retorna la posición actual del puntero.
14
El siguiente ejemplo utiliza el RandomAcessFile para modificar el contenido de las dos

primeras líneas del documento y añadir un nuevo texto al final de todo.
String sep = File.separator;

String saltoLinea = System.getProperty("line.separator");
String rutaDocumento = rutaProyecto + sep + "ejemplo.txt";

RandomAccessFile raf = new RandomAccessFile(rutaDocumento, "rw");
String text = "primera linea" +saltoLinea+ "segunda línea";
raf.writeBytes(text); //escribir texto al inicio del archivo
raf.seek(raf.length()); //añadir informacion al final del archivo

raf.writeBytes(saltoLinea+" nueva línea añadida");
//como leer todo un archivo
raf.seek(0); //mover el puntero a la posición 0 del archivo
while (raf.getFilePointer() < raf.length()) { //recorremos todo el archivo línea a línea
System.out.println(raf.readLine()); //Leer una línea
}
raf.close(); //Tancamos el fichero
15
Recursos y enlaces
• File, documentación oficial:
https://docs.oracle.com/javase/10/docs/api/java/io/File.html
• RandomAccessFile, documentación oficial :

https://docs.oracle.com/javase/10/docs/api/java/io/RandomAccessFile.html
• BufferedReader , documentación oficial:

https://docs.oracle.com/javase/10/docs/api/java/io/BufferedReader.html
• FileReader, documentación oficial:

https://docs.oracle.com/javase/10/docs/api/?java/io/FileReader.html
16
• FileWriter, documentación oficial:

https://docs.oracle.com/javase/10/docs/api/java/io/FileWriter.html
• BufferedWriter, documentación oficial:

https://docs.oracle.com/javase/10/docs/api/java/io/BufferedWriter.html
Conceptos clave
• i/o: input / output hace referencia a los periféricos de entrada y salida de datos.
• Periférico de entrada o salida: dispositivos asociados con un ordenador que ofrecen o
muestran algún tipo de datos
• File: tipo de variable que permite gestionar información sobre carpetas y documentos.
• Acceso directo: acceso a una información conociendo su posición de memoria
• Acceso secuencial: acceso a una información leyendo toda la memoria hasta encontrar
el dato buscado
17
Test de auto evaluación
¿Qué tipo de variable nos permite gestionar información sobre una carpeta?
a) Directory
b) Buffer
c) System
d) File
¿Qué tipo de dato contiene la función .close()?.

a) Buffer
b) Stream
c) File
d) Directory
¿Qué función nos permite situar el puntero en una posición de un archivo con un acceso
directo?
a) .go()
b) .point()
c) .seek()
d) .read()
Ponlo en práctica
Actividad 1
Crea un programa que pida tres frases distintas al usuario, las guarde en un archivo de
nombre “ejemplo.txt”. Finalmente ha de leer y mostrar por consola el contenido de
“ejemplo.txt”.
18
SOLUCIONARIOS
Test de auto evaluación
¿Qué tipo de variable nos permite gestionar información sobre una carpeta?
a) Directory
b) Buffer
c) System
d) File
¿Qué tipo de dato contiene la función .close()?.

e) Buffer
f) Stream
g) File
h) Directory
¿Qué función nos permite situar el puntero en una posición de un archivo con un acceso
directo?
i) .go()
j) .point()
k) .seek()
l) .read()
19
Ponlo en práctica
Actividad 1
Crea un programa que pida tres frases distintas al usuario, las guarde en un archivo de
nombre “ejemplo.txt”. Finalmente ha de leer y mostrar por consola el contenido de
“ejemplo.txt”.
Solución:
import java.io.*;

String textoIntroducido;
String sep = File.separator;
String saltoLinea = System.getProperty("line.separator");
String rutaDocumento = rutaProyecto + sep + "ejemplo.txt";
File document = new File(rutaDocumento); //información sobre el fichero
FileWriter fw = new FileWriter(document); //Stream conectado al fichero a escribir.

BufferedWriter bwFile = new BufferedWriter(fw); //Buffer que almacena datos hacia
el stream
//buffer para conectar con la entrada de datos a través de teclado

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
System.out.println("Escribe la 1a línea");
textoIntroducido = br.readLine(); //leemos valor por teclado
bwFile.write(textoIntroducido + saltoLinea); //guarda los datos en el buffer con un
salto de linea
textoIntroducido = br.readLine();
bwFile.write(textoIntroducido + saltoLinea);
20
textoIntroducido = br.readLine();
bwFile.write(textoIntroducido + saltoLinea);
bwFile.flush(); //envía los datos que queden al buffer

bwFile.close(); //se liberan los recursos asignados al outputStream
//leemos el archivo
FileReader fr = new FileReader(document); //Stream conectado al fichero a leer.
BufferedReader brFile = new BufferedReader(fr); //Buffer que almacena datos del
stream
for (String linea = brFile.readLine(); linea != null; linea = brFile.readLine()) {
System.out.println(linea); //mostramos por consola el texto leído
}
brFile.close(); //cerramos el buffer
}
}
21

Tema 6. Lectura y Escritura de La Información

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Tema 6. Lectura y Escritura de La Información

Cargado por

Copyright:

Formatos disponibles

TEM

Autoría: Cristian Catalán

Tema 6: Lectura y escritura de la información

• Los sistemas de ficheros se encargan de definir como almacenar e identificar los

1. Características de los Arrays en Java

1.1 . Declarar un array

Podemos indicar los valores de un array cuando la declaramos con la sintaxis:

1.2 . Acceder a los valores de un Array

Accedemos a una posición del array con: nombreArray[posicion]

public class EjemploArrays {

nombres[0]="Kim"; //modificamos el 1r elemento para que su valor sea Kim

int longitudArray = nombres.length; //guardamos la longitud en una variable

for(int k=0;k<longitudArray;k++){ //recorremos el array

Así el ejemplo anterior nos quedaría:

public class EjemploArrays {

1.3 . Uso de arrays en funciones

En el siguiente ejemplo podemos observar como la función generaOtroArray() clona el

2. Concepto y tipo de acceso

Aunque podríamos modificar manualmente cada 0 y 1 que componen el contenido de un

3. Gestión de archivos y carpetas con File

• .getName(); retorna una String el nombre del fichero o carpeta.

4. Elementos básicos en la escritura y lectura de información

5. Escritura secuencial a ficheros

Para la escritura secuencial sobre un fichero utilizaremos el siguiente tipo de variables:

En el siguiente código se muestra un ejemplo en el que se accede a un documento con la

public class EjemploEscrituraFichero {

public static void main(String[] args) throws IOException {

En el siguiente diagrama podemos ver representados los distintos elementos que

6. Lectura secuencial de ficheros

Para la lectura secuencial de un archivo utilizaremos el siguiente tipo de variables:

En el siguiente código se muestra un ejemplo en el que se accede a un documento con la

public class EjemploEscrituraFichero {

public static void main(String[] args) throws IOException {

FileReader fr = new FileReader(document); //Stream conectado al fichero a leer.

System.out.println(linea); //mostramos por consola el texto leído }

En el siguiente diagrama podemos ver representados los distintos elementos que

for( String linea=br.readLine(); linea != null; linea=br.readLine() ){

System.out.println(linea); //mostramos por consola el texto leído

7. Valores del sistema para trabajar con archivos

7.1 . Rutas de archivos relativas vs absolutas

En los ejemplos anteriores hemos accedido a un archivo ubicado en “D:\ejemplo.txt”, pero

7.2 . Separadores en las rutas según el sistema operativo

7.3 . Saltos de línea

Cuando queramos insertar un salto de línea en un archivo de texto llano deberemos

8. Acceso directo a ficheros

El siguiente esquema ilustra cómo un fichero de texto es transformado en un array de

En Java vamos a poder acceder a de forma directa al contenido de un fichero utilizando

El siguiente ejemplo utiliza el RandomAcessFile para modificar el contenido de las dos

String sep = File.separator;

String rutaDocumento = rutaProyecto + sep + "ejemplo.txt";

raf.seek(raf.length()); //añadir informacion al final del archivo

• RandomAccessFile, documentación oficial :

• BufferedReader , documentación oficial:

• FileReader, documentación oficial:

• FileWriter, documentación oficial:

• BufferedWriter, documentación oficial:

Test de auto evaluación

¿Qué tipo de dato contiene la función .close()?.

Test de auto evaluación

¿Qué tipo de dato contiene la función .close()?.

public class EjemploEscrituraFichero {

public static void main(String[] args) throws IOException {

String rutaDocumento = rutaProyecto + sep + "ejemplo.txt";