El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Flujos de Archivos

Siguiente ►
►

En este tema, aprenderemos sobre los flujos de archivos en Java, que son fundamentales para la lectura y escritura de datos en archivos. Los flujos de archivos permiten manejar la entrada y salida de datos de manera eficiente y son una parte esencial de la programación en Java.

Conceptos Clave

  1. Flujos de Entrada y Salida: Los flujos de entrada (Input Streams) se utilizan para leer datos de una fuente, mientras que los flujos de salida (Output Streams) se utilizan para escribir datos a un destino.
  2. Clases Principales:
    • FileInputStream y FileOutputStream: Para leer y escribir bytes desde y hacia archivos.
    • BufferedInputStream y BufferedOutputStream: Para mejorar la eficiencia de lectura y escritura mediante el uso de un búfer.
    • DataInputStream y DataOutputStream: Para leer y escribir datos primitivos de Java de manera portátil.
    • ObjectInputStream y ObjectOutputStream: Para leer y escribir objetos.

Flujos de Entrada y Salida de Bytes

FileInputStream y FileOutputStream

Estas clases se utilizan para leer y escribir bytes desde y hacia archivos.

Ejemplo de FileInputStream

import java.io.FileInputStream;
import java.io.IOException;

public class FileInputStreamExample {
    public static void main(String[] args) {
        try (FileInputStream fis = new FileInputStream("example.txt")) {
            int content;
            while ((content = fis.read()) != -1) {
                System.out.print((char) content);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Explicación:

  • FileInputStream se abre para leer el archivo "example.txt".
  • Se lee el contenido del archivo byte por byte hasta el final del archivo (-1).
  • Cada byte se convierte en un carácter y se imprime en la consola.

Ejemplo de FileOutputStream

import java.io.FileOutputStream;
import java.io.IOException;

public class FileOutputStreamExample {
    public static void main(String[] args) {
        String data = "Hello, World!";
        try (FileOutputStream fos = new FileOutputStream("example.txt")) {
            fos.write(data.getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Explicación:

  • FileOutputStream se abre para escribir en el archivo "example.txt".
  • La cadena "Hello, World!" se convierte en un arreglo de bytes y se escribe en el archivo.

BufferedInputStream y BufferedOutputStream

Estas clases mejoran la eficiencia de lectura y escritura mediante el uso de un búfer.

Ejemplo de BufferedInputStream

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;

public class BufferedInputStreamExample {
    public static void main(String[] args) {
        try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream("example.txt"))) {
            int content;
            while ((content = bis.read()) != -1) {
                System.out.print((char) content);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Explicación:

  • BufferedInputStream se utiliza para leer el archivo "example.txt" con un búfer.
  • La lectura se realiza de manera más eficiente que con FileInputStream solo.

Ejemplo de BufferedOutputStream

import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class BufferedOutputStreamExample {
    public static void main(String[] args) {
        String data = "Hello, Buffered World!";
        try (BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("example.txt"))) {
            bos.write(data.getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Explicación:

  • BufferedOutputStream se utiliza para escribir en el archivo "example.txt" con un búfer.
  • La escritura se realiza de manera más eficiente que con FileOutputStream solo.

Flujos de Entrada y Salida de Datos Primitivos

DataInputStream y DataOutputStream

Estas clases se utilizan para leer y escribir datos primitivos de Java de manera portátil.

Ejemplo de DataOutputStream

import java.io.DataOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class DataOutputStreamExample {
    public static void main(String[] args) {
        try (DataOutputStream dos = new DataOutputStream(new FileOutputStream("data.bin"))) {
            dos.writeInt(123);
            dos.writeDouble(45.67);
            dos.writeBoolean(true);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Explicación:

  • DataOutputStream se utiliza para escribir datos primitivos en el archivo "data.bin".
  • Se escriben un entero, un doble y un booleano en el archivo.

Ejemplo de DataInputStream

import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;

public class DataInputStreamExample {
    public static void main(String[] args) {
        try (DataInputStream dis = new DataInputStream(new FileInputStream("data.bin"))) {
            int intValue = dis.readInt();
            double doubleValue = dis.readDouble();
            boolean booleanValue = dis.readBoolean();
            System.out.println("Int: " + intValue);
            System.out.println("Double: " + doubleValue);
            System.out.println("Boolean: " + booleanValue);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Explicación:

  • DataInputStream se utiliza para leer datos primitivos del archivo "data.bin".
  • Se leen un entero, un doble y un booleano del archivo y se imprimen en la consola.

Flujos de Entrada y Salida de Objetos

ObjectInputStream y ObjectOutputStream

Estas clases se utilizan para leer y escribir objetos.

Ejemplo de ObjectOutputStream

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.Serializable;

class Person implements Serializable {
    private static final long serialVersionUID = 1L;
    String name;
    int age;

    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

public class ObjectOutputStreamExample {
    public static void main(String[] args) {
        Person person = new Person("John Doe", 30);
        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person.ser"))) {
            oos.writeObject(person);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Explicación:

  • ObjectOutputStream se utiliza para escribir un objeto Person en el archivo "person.ser".
  • La clase Person implementa Serializable para permitir la serialización.

Ejemplo de ObjectInputStream

import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;

public class ObjectInputStreamExample {
    public static void main(String[] args) {
        try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("person.ser"))) {
            Person person = (Person) ois.readObject();
            System.out.println("Name: " + person.name);
            System.out.println("Age: " + person.age);
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

Explicación:

  • ObjectInputStream se utiliza para leer un objeto Person del archivo "person.ser".
  • El objeto se deserializa y se imprimen sus atributos.

Ejercicios Prácticos

Ejercicio 1: Leer y Escribir un Archivo de Texto

Instrucciones:

  1. Escribe un programa que lea el contenido de un archivo de texto llamado "input.txt".
  2. Escribe el contenido leído en un nuevo archivo llamado "output.txt".

Solución:

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileCopyExample {
    public static void main(String[] args) {
        try (FileInputStream fis = new FileInputStream("input.txt");
             FileOutputStream fos = new FileOutputStream("output.txt")) {
            int content;
            while ((content = fis.read()) != -1) {
                fos.write(content);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Ejercicio 2: Serializar y Deserializar un Objeto

Instrucciones:

  1. Crea una clase Student que implemente Serializable con atributos name y grade.
  2. Escribe un programa que serialice un objeto Student en un archivo llamado "student.ser".
  3. Escribe otro programa que deserialice el objeto Student del archivo "student.ser" y muestre sus atributos.

Solución:

import java.io.FileOutputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.ObjectInputStream;
import java.io.Serializable;

class Student implements Serializable {
    private static final long serialVersionUID = 1L;
    String name;
    int grade;

    Student(String name, int grade) {
        this.name = name;
        this.grade = grade;
    }
}

public class SerializeStudent {
    public static void main(String[] args) {
        Student student = new Student("Alice", 90);
        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("student.ser"))) {
            oos.writeObject(student);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

public class DeserializeStudent {
    public static void main(String[] args) {
        try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("student.ser"))) {
            Student student = (Student) ois.readObject();
            System.out.println("Name: " + student.name);
            System.out.println("Grade: " + student.grade);
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

Conclusión

En esta sección, hemos aprendido sobre los flujos de archivos en Java, incluyendo cómo leer y escribir bytes, datos primitivos y objetos. Estos conceptos son fundamentales para manejar la entrada y salida de datos en aplicaciones Java. En la próxima sección, exploraremos el uso de BufferedReader y BufferedWriter para mejorar la eficiencia de la lectura y escritura de archivos de texto.

◄ Anterior
◄
Siguiente ►
►

Curso de Programación en Java

Módulo 1: Introducción a Java

Módulo 2: Flujo de Control

Módulo 3: Programación Orientada a Objetos

Módulo 4: Programación Orientada a Objetos Avanzada

Módulo 5: Estructuras de Datos y Colecciones

Módulo 6: Manejo de Excepciones

Módulo 7: Entrada/Salida de Archivos

Módulo 8: Multihilo y Concurrencia

Módulo 9: Redes

Módulo 10: Temas Avanzados

Módulo 11: Frameworks y Librerías de Java

Módulo 12: Construcción de Aplicaciones del Mundo Real

El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados