domingo, 19 de octubre de 2014

Java - I/O Fundamentals: Streams - Files

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