Estos son algunos ejemplos de como utilizar las distintas clases I/O en Java
Utilización de la clase File
public class FilePrincipal {
public static void main(String[] args) {
/*
* se utiliza para obtener informacion sobre los ficheros y directorios
* del disco e incluso para crearlos y eliminarlos.
*/
try {
boolean isNuevo = false;
File file = new File("nuevoArchivo.txt"); // esto es solo un objeto
System.out.println(file.exists()); // busca la existencia de un archivo real
isNuevo = file.createNewFile(); // tal vez crea el archivo
System.out.println(isNuevo); // lo pudo crear?
System.out.println(file.exists()); // verifica nuevamente
//coriendolo nuevamente el resultado cambia.
} catch (IOException ex) { }
/**
* createNewFile: Crea el fichero cuyo nombre se ha indicado
* en el constructor.Devuelve true si se ha podido crar el archivo
* y false si ya existia y por lo tanto no lo ha podido crear.
*
* mkdir: crea el directorio cuyo nombre ha sido especificado en el
* contructor. Si el directorio no exitia y se ha podido crear, el
* método devolvera true de lo contrario el resultado sera false.
*
* Metodos importante para el objecto File:
* boolean canRead(). Indica si se puede o no leer del archivo.
* boolean canWrite(). Indica si se puede o no escribir en el archivo.
* boolean isFile(). Indica si existe o no el archivo o directorio indicado
* en la ruta.
* boolean isDirectory(). Indica si el objecto File hace referencia o no a
* un directorio.
* String getName(). Devuelve el nombre del fichero sin el path(ruta).
* Strubg getAbsolutePath(). Devuelve el path absoluto completo.
*/
}
}
Utilización de la clase File( eliminar y renombrar archivos)
public class FileDeleteRenamePrincipal {
/**
* Explicacion del método:
* boolean detele(). Retorna true si se pudo eliminar y false en caso
* contrario. Si es un directorio solo podra ser
* eliminado si esta vacio.
* boolean renameTo(File nuevo). Retorna true si se pudo cambiar el
* nombre del fichero y false en caso contrario.En el
* caso de un directorio, no es necesario que este vacio
* para poderlo renombrar.
*/
public static void main(String[] args) {
try {
File file = new File("nuevoArchivo.txt");
file.createNewFile();
File file2 = new File("nuevoNombre.txt");
System.out.println(file.renameTo(file2));
System.out.println(file2.delete()); //lo elimina?.
} catch (IOException ex) { }
}
}
Utilización de la clase FileWriter y PrintWriter( eliminar y renombrar archivos)
public class WriterPrintPrincipal {
public static void main(String[] args) {
try {
//se debe indicar el archivo, y el segundo parametro indica si los
//datos se van a sobreescribir o a se agregan al final.
FileWriter writer = new FileWriter("miArchivoEscritura.txt", true);
PrintWriter out = new PrintWriter(writer);
//array de nombres
String [] nombres = {"matias","genaro","juan","pedro"};
for(int i=0; i
out.println(nombres[i]);
}
out.flush();
out.close();
} catch (IOException ex) { }
}
}
Utilización de las clases FileReader y BufferReader
public class ReaderPrincipal {
public static void main(String[] args) {
try {
//File file = new File("miArchivoEscritura.txt");
//FileReader fReader = new FileReader(file);
FileReader fileReader = new FileReader("miArchivoEscritura.txt");
BufferedReader bf = new BufferedReader(fileReader);
String valor;
while((valor=bf.readLine())!=null){
System.out.println(valor);
}
} catch (FileNotFoundException ex) {
} catch (IOException ex) {}
}
}
Utilización de las clases FileOutputStream y DataOutputStream
/**
*
* FileOutStream
*
* Este objecto es equivalente al FileWriter utilizado en la
* estritura de cadenas de caracteres,Como en el caso de este, se puede crear un
* objecto FileOutputStream que permita añadir informacion al fichero o sobreescribirla
* haciendo usos de los constructores:
* FileOutputStream(File fichero,boolean append)
* FileOutputStream(String path,boolean append)
* La clase FileOutputStream es una subclase de OutputStream, la cual representa
* un stream o flujo de salida para la escritura de bytes.
*
* DataOutputStream
*
* A partir del objeto FileOutputStream se puede crear un objeto
* DataInputStream para realizar la escritura de los datos. El constructor utilizado
* sería:
* DataOutputStream(OutputStream)
* La clase DataOutputStream proporciona metodos para escribir datos en un fichero
* en cada uno de los ocho tipos primitivos de java. Estos metodos tienen el
* formato void writeXxx(xxx dato) siendo xxx el nombre del tipo primitivo Java.
*
*
*/
public class FileDataOutputStreamPrincipal {
public static void main(String[] args) {
FileOutputStream fileOutputStream = null;
DataOutputStream data = null;
try {
fileOutputStream = new FileOutputStream("datosPrimitivos.mbd",true);
data = new DataOutputStream(fileOutputStream);
long[] datosLong = new long[]{23,34,56,78,72,78};
for(int i=0; i
data.writeLong(datosLong[i]);
}
data.close();
} catch (FileNotFoundException ex) {
}catch (IOException ex) {}
}
}
Utilización de las clases FileInputStream y DataInputStream
/**
* FileInputStream
*
* Es el equivalente al FileReader utilizado en la lectura de caracteres. Se puede
* crear un objeto de esta clase a partir de un objecto File o de la cadena
* que representa la ruta del fichero. Esta clase es una subclase de InputStream
* que, al igual que OutputStream esta orientada al tratamiento de bytes.En este
* caso, a la lectura de bytes.
*
* DateInputStream
*
* A partir del objecto FileInputStream se puede crear un DataInputStream para
* realizar la lectura de los datos. Esta clase dispone de los metodos xxx
* readXxx() para recuperar los datos almacenados en el tipo indicado, siendo xxx
* el nombre del tipo primitivo.
*
*/
public class FileDataInputStreamPrincipal {
public static void main(String[] args) {
try {
FileInputStream fileInput = new FileInputStream("datosPrimitivos.mbd");
DataInputStream dataInput = new DataInputStream(fileInput);
for(;;)
System.out.println(dataInput.readLong());
} catch (FileNotFoundException ex) {
System.out.println("ERROR " + ex.toString());
} catch(EOFException e){
System.out.println("ERROR " + e.toString());
} catch(IOException i){
System.out.println("ERROR " + i.toString());
}
}
}
Utilizacion de la interfaz Serializable
Clase Persona utilizada:
public class Persona implements Serializable {
private String nombre;
private int edad;
public Persona(String n,int e){
nombre = n;
edad = e;
}
/**
* @return the nombre
*/
public String getNombre() {
return nombre;
}
/**
* @param nombre the nombre to set
*/
public void setNombre(String nombre) {
this.nombre = nombre;
}
/**
* @return the edad
*/
public int getEdad() {
return edad;
}
/**
* @param edad the edad to set
*/
public void setEdad(int edad) {
this.edad = edad;
}
}
Onput
/**
* Serializable
* Para que un objeto puede ser almancenado en disco, es necesario que la clase
* a la que pertenece sea serializable. Esta caracteristica la poseen todas
* aquellas clases que implementan la interfaz java.io.Serializable. La interfaz
* Serializable no contiene ningun metodo, basta con que una clase la implemente
* para que sus objectos puedan ser serializados por la maquina virtual y por
* lo tanto almacenados en disco.
*
* ObjectOutputStream
* La escritura de objetos en disco se realiza a traves de ObjecOutputStream.
* Para crear un objeto de esta clase es necesario disponer del FileOutputStream
* asociado al fichero donde se va a realizar la escritura. Una vez creado el
* objeto, la clase dispone del metodo writeObject(Object obj) para realizar la
* escritura del objeto en el disco.
*
*/
public class SerializableOutputPrincipal {
public static void main(String[] args){
FileOutputStream fs = null;
try {
fs = new FileOutputStream("datosPersona.obj");
ObjectOutputStream os = new ObjectOutputStream(fs);
os.writeObject(new Persona("juan",30));
fs.close();
} catch (FileNotFoundException ex) {
} catch(IOException e){}
}
}
Input
/**
* ObjectInputStream
* La clase ObjectInputStream dispone del metodo Object readObject() para devolver
* los objetos almacenados en el fichero.El constructor de esta clase requiere
* un objeto FileInputStream asociado al fichero de donde se leera los datos.
* @author fede
*/
public class SerializableInputPrincipal {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
try{
FileInputStream fs = new FileInputStream("datosPersona.obj");
ObjectInputStream os = new ObjectInputStream(fs);
Persona p = (Persona)os.readObject();
System.out.println("Nombre " + p.getNombre());
System.out.println("Edad " + p.getEdad());
}catch(Exception ex){
System.out.println("ERROR: " + ex.toString());
}
}
}
No hay comentarios:
Publicar un comentario