Archivos de Texto: Vocales y Consonantes

Diseñar un programa que solicite desde el teclado el nombre del archivo de texto cuyo contenido debera procesar de la siguiente manera:crear un archivo de texto con todas las vocales que contenga y crear un archivo de texto con todas las consonantes que contenga. exhibir los archivos resultantes.

import java.io.*;

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

        FileReader lee=null;
        FileOutputStream escribe=null;
        
        try
        {
            lee=new FileReader("texto.txt");
            int dato= lee.read();
            
            while(dato!=-1)
            {
                System.out.print((char)dato);
                dato=lee.read();
                
                // Devuelve una copia de esta cadena con todos los caracteres en mayúsculas convertidos en minúsculas.
                if((Character.toLowerCase(dato)=='a') || (Character.toLowerCase(dato)=='e') || (Character.toLowerCase(dato)=='i') || (Character.toLowerCase(dato)=='o') || (Character.toLowerCase(dato)=='u'))
                {
                    escribe = new FileOutputStream("vocales.txt",true);
                    DataOutputStream din = new DataOutputStream(escribe);
                    din.writeChar(dato);
                }
                else
                {
                    escribe = new FileOutputStream("consonantes.txt",true);
                    DataOutputStream din = new DataOutputStream(escribe);
                    din.writeChar(dato);
                }
            }
            lee.close();
            escribe.close();
        }
        finally
        {
            System.out.println("\n\nArchivos Creados...");
        }
        
        System.out.println("Exibiendo archivo vocales.txt\n");
        FileReader vocales = null;
        try
        {
            vocales = new FileReader("vocales.txt");
            int dato2 = 0;
            while(dato2 != -1)
            {
                dato2 = vocales.read();
                System.out.print((char)dato2);
            }
            vocales.close();
        }
        finally
        {
            System.out.println("\n\nArchivo leido.");
        }
        
        System.out.println("Exibiendo archivo consonantes.txt.\n");
        FileReader consonantes = null;
        try
        {
            consonantes = new FileReader("consonantes.txt");
            int dato3 = 0;
            while(dato3 != -1)
            {
                dato3 = consonantes.read();
                System.out.print((char)dato3);
            }
            consonantes.close();
        }catch(IOException e){}
        finally
        {
            System.out.println("\n\nArchivo leido.\nfin");
        }
    }
}

Output:
PrUeBa dE TexTO

Archivos Creados...
Exibiendo archivo vocales.txt

U e a E e O

Archivo leido.
Exibiendo archivo consonantes.txt.

r B d T x T

Archivo leido.
fin

Desde un Archivo Binario de objetos obtener un Archivo de Texto

Desde un archivo Binario de objetos obtener un archivo de texto con el siguiente formato: nombre\n edad\n sexo\n y exhibir el archivo de texto.

import java.io.ObjectInputStream;
import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.DataOutputStream;
import java.io.DataInputStream;
import java.io.IOException;
import java.io.EOFException;
import java.io.Serializable;

class Persona implements Serializable
{
 String nomb;
 int ed;
 char sexo;
}

public class Bin_Text {

    public static void main(String[] args) throws IOException, ClassNotFoundException {
        
        ObjectInputStream lee=null;
        
        String nomb="";
        int ed=0;
        char sexo =0;
        
        try
        {
         lee=new ObjectInputStream(new BufferedInputStream(new FileInputStream("persona.bin")));
         FileOutputStream e = new FileOutputStream("NuevoArchivo.txt");
         DataOutputStream escribe = new DataOutputStream(e);

         for (int i=0;i < 5 ; i++)
         {
             nomb=lee.readUTF();
             ed=lee.readInt();
             sexo=lee.readChar();
             
             escribe.writeUTF(nomb);
             escribe.writeInt(ed);
             escribe.writeChar(sexo);
             
         }escribe.close();
        }
        finally
        {
            System.out.println("Archivo creado...");
            lee.close();
        }
        
        System.out.println("Leyendo archivo creado...");
        System.out.println("\n   Nombre\t\tEdad\tSexo");
        DataInputStream lee2 =null;
        try
        {
            lee2 =new DataInputStream(new BufferedInputStream(new FileInputStream("NuevoArchivo.txt")));
            while(true)
            {
                nomb=lee2.readUTF();
                ed=lee2.readInt();
                sexo=lee2.readChar();
                System.out.printf("%s\t%d\t%c\n",nomb,ed,sexo);
            }
        }
        catch (EOFException e)
        {
            System.out.println("\nSe alcanzo el fin del archivo...");
        }
        finally
        {
            lee2.close();
        }
    }
}

Output:
Archivo creado...
Leyendo archivo creado...

     Nombre                      Edad Sexo
0  Jose Manuel Sanchez  23    M
1  Jose Manuel Sanchez 23  M
2  Jose Manuel Sanchez 23  M
3  Jose Manuel Sanchez 23  M
4  Jose Manuel Sanchez 23  M

Se alcanzo el fin del archivo...

Procesamiento de Archivos en Java

• Java considera a cada archivo como un flujo secuencial de bytes.
• Los flujos que reciben y envían bytes a archivos se conocen como flujos basados en Bytes, almacenan datos en formato Binario. (Archivos Binarios).
• Los flujos que reciben y envían caracteres de los archivos se conocen como flujos basados en caracteres, almacenan datos como una secuencia de caracteres. (archivos de texto):

Paquete java.io  <=== procesamiento de archivos

Stream de Bytes(InputStream y OutputStream)

• Diseñados para operar a nivel de byte.
• Hay dispositivos que solo pueden trabajar a este nivel.

Stream de caracteres (Reader y Writer)

• Diseñados para optimizar las operaciones con cadenas de caracteres
• Soporta codificaciones UNICODE-16
• Cualquier archivo de texto puede ser directamente accedido a través de este tipo de Stream.

Clases:
FileInputStream:     Para la entrada basada en bytes desde un archivo.
FileOutputStream:  Para la salida basada en bytes hacia un archivo.
FileReader:             Para la entrada basada en caracteres desde un archivo.
FileWriter:              Para la salida basada en caracteres hacia un archivo.
BufferedReader:    Para leer archivos de texto plano.
PrintWriter:            Se utiliza para escribir en ficheros de texto.