domingo, 6 de septiembre de 2009

Eliminar una línea de un archivo de texto

Este ejemplo muestra cómo eliminar una línea de un archivo. 
El removeLineFromFile método toma dos parámetros, el primer parámetro es el archivo a quitar de y el segundo parámetro es el contenido de la línea de quitar. 
Un tempfile se crea y por escrito a, excepto por el contenido que coincide con el segundo parámetro. 
De esta manera los archivos de gran tamaño puede ser manejado sin exigir tanta cantidad de memoria interna. 
El archivo original se elimina y el archivo temporario se cambia el nombre al nombre del archivo original. 


Por ejemplo, el archivo test.txt se encuentra en el directorio actual y contiene tres líneas, y vamos a eliminar la segunda línea "bbbbb".
aaaaa
bbbbb
ccccc
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.File;
import java.io.FileWriter;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.PrintWriter;

public class FileUtil {


  public void removeLineFromFile(String file, String lineToRemove) {

  try {

  File inFile = new File(file);
   
  if (!inFile.isFile()) {
  System.out.println("Parameter is not an existing file");
  return;
  }
   
  //Construct the new file that will later be renamed to the original filename. 
  File tempFile = new File(inFile.getAbsolutePath() + ".tmp");
   
  BufferedReader br = new BufferedReader(new FileReader(file));
  PrintWriter pw = new PrintWriter(new FileWriter(tempFile));
   
  String line = null;

  //Read from the original file and write to the new 
  //unless content matches data to be removed.
  while ((line = br.readLine()) != null) {
   
  if (!line.trim().equals(lineToRemove)) {

  pw.println(line);
  pw.flush();
  }
  }
  pw.close();
  br.close();
   
  //Delete the original file
  if (!inFile.delete()) {
  System.out.println("Could not delete file");
  return;
  } 
   
  //Rename the new file to the filename the original file had.
  if (!tempFile.renameTo(inFile))
  System.out.println("Could not rename file");
   
  }
  catch (FileNotFoundException ex) {
  ex.printStackTrace();
  }
  catch (IOException ex) {
  ex.printStackTrace();
  }
  }

  public static void main(String[] args) {
  FileUtil util = new FileUtil();
  util.removeLineFromFile("test.txt", "bbbbb");
  }
}


 El archivo test.txt ahora se ve así:
aaaaa
ccccc


sábado, 5 de septiembre de 2009

I/O Leer y escribir(Stream)

I/O: Leer y Escribir

Frecuentemente los programas necesitan traer información desde una fuente externa o enviar información a un fuente externa. La información pueder estár en cualquier parte, en un fichero, en disco, en algún lugar de la red, en memoria o en otro programa. También puede ser de cualquier tipo: objetos, caracteres, imágenes o sonidos. 

Para traer la información, un programa abre un stream sobre una fuente de información (un fichero, memoria, un socket) y lee la información serialmente, de esta forma: 


Similarmente, un programa puede enviar información a un destino externo abriendo un stream sobre un destino y escribiendo la información serialmente, de esta forma: 


No importa de donde venga o donde vaya la información y tampoco importa el tipo de los datos que están siendo leídos o escritos, los algoritmos para leer y escribir son casi siempre los mismos. Leer

abrir un stream mientras haya información  leer información cerrar el stream

Escribir

abrir un stream mientras haya información  escribir información cerrar el stream



El paquete java.io contiene una colección de clases stream que soportan estos algoritmos para leer y escribir. Estas clases están divididas en dos árboles basándose en los tipos de datos (caracteres o bytes) sobre los que opera. 


Sin embargo, algunas veces es más conveniente agrupar las clases basándose en su propósito en vez en los tipos de datos que lee o escribe. Así, podemos agrupar los streams dependiendo de si leen u escriben lados en las "profundidades" o procesan la inormación que está siendo leída o escrita. 

 Introducción a los Streams I/O

Esta sección describe todos los tipos de streams y muestra las clases del paquete java.io que los implementan de acuerdo a la división del árbol de clases. 

Luego, como mucha gente piensa en términos de lo que quieren hacer en vez de lo que están haciendo, proporcionamos dos secciones que nos muestran cómo usar los streams seleccionados basándonos en su propósito. 
Usar los Streams Sink 
Usar los Streams de Procesamiento 
 Serialización de Objetos

Dos de los streams de bytes, ObjectInputStream y ObjectOutputStream, son streams especializados que nos permiten leer y escribir objetos. 

Leer y escribir objetos es un proceso que se conoce como serialización de objetos. La serialización de objetos tiene muchos usos, incluyeno la invocación remota de métodos (RMI). 

Además de los streams de objetos, java.io tiene otras clases e interfaces que definen el API de las clases de ayuda que realizan serialización para sus ejemplares. 
 Trabajar con Ficheros de Acceso Aleatorio

Los streams de caracteres y de bytes son streams de acceso secuencial. Por el contrario, RandomAccessFile nos permite acceder aleatoriamente a los contenidos de un fichero. 

Esta sección nos habla sobre cómo suar los ficheros de acceso aleatorio. También proporciona una sección especial que muestra como escribir filtros para objetos que implementan los interfaces DataInput y DataOutput. 

Los filtros implementados de esta forma son más flexibles que los filtros de streams regulares porque pueden usarse sobre ficheros de acceso aleatorio y algunos ficheros secuenciales.