Operadores en Java

Operadores Aritméticos: Los habituales

Suma + .
Resta - .
Multiplicación * .
División / .
Resto de la División % .

• ! Negacion Logica
• + Suma o Concatenacion de cadenas
• -    resta

• < menor que
• <= menor o igual que
• > mayor que
• >= mayor o igual que
• == es igual a
• != no es igual a

• & AND a nivel de bit
• AND logico booleano

• ^ OR excluyente a nivel de bits
• OR excluyente lógico booleano

• | OR incluyente a nivel de bits
• OR incluyente lógico booleano

• && AND condicional
• || OR condicional
• ?: condicional

• = asignación
• +=        asignación, suma
• -= asignación, resta
• *= asignación, multiplicación
• /= asignación, división
• %= asignación, residuo
• &= asignación, AND a nivel de bits
• ^= asignación, OR excluyente a nivel de bits
• |= asignación, OR incluyente a nivel de bits
• <<=      asignación, desplazamiento a la izquierda a nivel de bits
• >>= asignación, desplazamiento a la derecha a nivel de bits con signo
• >>>= asignación, desplazamiento a la derecha a nivel de bits sin signo

Contar palabras que contiene un Archivo de Texto

Diseñar un programa que solicite desde el teclado el nombre del archivo de texto el cual deberá contar todas las palabras que contiene el archivo.

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.Scanner;

class Cont_Palabras
{
    public static void main(String [] arg)
    {
        Scanner teclado = new Scanner(System.in);
        System.out.print("Escribe el nombre del archivo de texto: ");
        String archivo = teclado.next();
        
        try 
        {            
            BufferedReader lee = new BufferedReader(new FileReader(archivo));
            
            String linea;
            int i, a = 0;            
            while((linea = lee.readLine()) != null)
            {
                System.out.println(linea);
                for(i=0; i < linea.length(); i++)
                {
                    if(i==0)
                    {
                        if(linea.charAt(i)!=' ')
                            a++;
                    }
                    else
                    {
                        if(linea.charAt(i-1)==' ')
                            if(linea.charAt(i)!=' ')
                                a++;
                    }
                }
            }
            System.out.println("\nEL archivo contiene "+a+" palabras");
            lee.close();
        }
        catch(IOException a)
        {
            System.out.println(a);
        }
    }
}

Output:

Escribe el nombre del archivo de texto: vida.txt
Cuando me hallaba en clase de geometría me decían que solo había tres dimensiones y siempre lo acepte. Estaban equivocados. Hay mas. Nuestro mundo, en el que ahora vivimos, es tridimensional, pero el próximo no lo es. Por eso es tan difícil contárselo.

EL archivo contiene 43 palabras

Comparar dos Archivos Binarios byte por byte

Diseñar una aplicacion que solicite desde teclado el nombre de dos archivo binarios y cuyo contenidos deberá comparar byte por byte.

import java.io.DataInputStream;
import java.io.IOException;
import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.util.Scanner;

public class Compara_BytexByte
{
    public static void main(String[] args) throws IOException
    {
        Scanner teclado = new Scanner(System.in);
        System.out.print("Escribe el primer archivo binario a comparar: ");
        String bin1 = teclado.next();
        System.out.print("Escribe el segundo archivo binario a comparar: ");
        String bin2 = teclado.next();

        try 
        {
            DataInputStream x = new DataInputStream(new BufferedInputStream(new FileInputStream(bin1)));
            DataInputStream y = new DataInputStream(new BufferedInputStream(new FileInputStream(bin2)));            
            
            int dato1=0, dato2=0;
            int cont1=0, cont2=0;            
            while(dato1 !=-1 || dato2 != -1)
            {
              dato1=x.read();
              dato2=y.read();              
              if(dato1!=-1)
              {  
                  cont1++;  
              }  
              if(dato2!=-1)
              {
                  cont2++;
              }
            }
            System.out.println("\nEl primer archivo binario tiene "+cont1+" Bytes");  
            System.out.println("El segundo archivo binario tiene "+cont2+" Bytes");
            if(cont1 == cont2)
            {
                System.out.println("Los archivos comparardos son iguales");
            }
            else
            {
                System.out.println("Los archivos comparados son diferentes");
            }
            x.close();
            y.close();
        }catch(IOException e)
        {
            System.out.println("Error:");
        }
    }
}

Output:
Escribe el primer archivo binario a comparar: databin.bin
Escribe el segundo archivo binario a comparar: datos.bin

El primer archivo binario tiene 120 Bytes
El segundo archivo binario tiene 118 Bytes
Los archivos comparados son diferentes

Exhibir la linea mas larga del contenido de un Archivo de Texto

Diseñar una aplicación de consola en Java, el cual solicite desde el teclado un archivo de texto del cual deberá de exhibir solo la linea de mayor magnitud y el total de caracteres que contiene la linea.

import java.io.FileReader;
import java.io.IOException;
import java.io.BufferedReader;
import java.util.Scanner;

public class Linea_Mayor
{
    public static void main(String[] args) throws IOException
    {
        Scanner teclado = new Scanner(System.in);
        System.out.print("Escribe el archivo de texto a procesar: ");
        String archivo = teclado.next();
        try 
        {
            BufferedReader lee1 =new BufferedReader(new FileReader(archivo));
            
            String linea = "", maslarga = "";
            System.out.println("Comprobando archivo...");
            int i = 0;
            while((linea = lee1.readLine())!=null)
            {
                i++;
                System.out.println(linea);
                if (linea.length() > maslarga.length())
                {
                    maslarga = linea;
                }
            }
            System.out.println("\nEl Archivo tiene "+i+" Lineas");
            System.out.println("La linea mas larga es:\n" + maslarga);
            System.out.println("Y tiene " + maslarga.length() + " caracteres");
            lee1.close();
        }catch(IOException e)
        {
            System.out.println("Ha ocurrido un error:");
        }
        finally
        {
          System.out.println("fin...");
        }
    }
}

Output:

Escribe el archivo de texto a procesar: texto.txt

Comprobando archivo...

El que esta al final del camino,

Conoce el principio y conoce el final,

El que esta al principio, solo ha

Andado unos pocos pasos, el resto le

Es desconocido.

El Archivo tiene 5 Lineas

La linea mas larga es:

Conoce el principio y conoce el final,

Y tiene 38 caracteres

fin...

Comparar dos Archivos de Texto linea por linea

Diseñar una aplicación en java que solicite desde el teclado, el nombre de dos archivo de texto y cuyo contenidos deberá comparar linea por linea.

import java.io.FileReader;
import java.io.IOException;
import java.io.BufferedReader;
import java.util.Scanner;

public class Compara_LineaxLinea
{
    public static void main(String[] args) throws IOException
    {
        Scanner teclado = new Scanner(System.in);
        System.out.print("Escribe el primer archivo de texto a comparar: ");
        String archivo1 = teclado.next();
        System.out.print("Escribe el segundo archivo de texto a comparar: ");
        String archivo2 = teclado.next();
        
        try 
        {           
            BufferedReader lee1 =new BufferedReader(new FileReader(archivo1));
            BufferedReader lee2 =new BufferedReader(new FileReader(archivo2));
            
            String linea1="", linea2 = "";
            System.out.println("Comparando Archivos...");
            int cont1=0, cont2=0;
            
            while(linea1!=null || linea2!=null)
            {
              linea1=lee1.readLine();
              linea2=lee2.readLine();
              
              if(linea1!=null)
              {
                  cont1++;  
              }  
              if(linea2!=null)
              {
                  cont2++;
              }
            }
            System.out.println("Fin de comparacion de los archivos...\n");  
            System.out.println("El primer archivo tiene "+cont1+" Lineas");  
            System.out.println("El segundo archivo tiene "+cont2+" Lineas");
            if(cont1 == cont2)
            {
                System.out.println("Los archivos comparardos son iguales");
            }
            else
            {
                System.out.println("Los archivos comparados son diferentes");
            }
            lee1.close();
            lee2.close();
        }catch(IOException e)
        {
            System.out.println("Ha ocurrido un error:");
        }
        finally
        {
          System.out.println("fin...");
        }
    }
}

Output:
Escribe el primer archivo de texto a comparar: aprobados.txt
Escribe el segundo archivo de texto a comparar: reprobados.txt
Comparando Archivos...
Fin de comparacion de los archivos...

El primer archivo tiene 6 Lineas
El segundo archivo tiene 4 Lineas
Los archivos comparados son diferentes
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...

Caracteres y Cadenas

Un programa puede contener literales de carácter. Una literal de carácter es un valor entero represen-tado como un carácter entre comillas simples. Por ejemplo, ‘z’representa el valor entero de z, y ‘\n’representa el valor entero de una nueva línea. El valor de una literal de carácter es el valor entero del carácter en el conjunto de caracteres Unicode.

Cadena:
Cadena es una secuencia de caracteres que se trata como una sola unidad. Una cadena puede incluir letras, dígitos y varios caracteres especiales, tales como +, -, *, Una cadena es un objeto de la clase String.

Las literales de cadena(que se almacenan en memoria como objetos String) se escriben como una secuencia de caracteres entre comillas dobles, como en:

“Juan E. Pérez”
“Calle Zapata 949”
“Monterrey, Nuevo León” 
“(201) 565-12112” 

Una cadena puede asignarse a una referencia String. La declaración

String color = “azul”;

inicializa la variable String de nombre color para que haga referencia a un objeto String que contiene
la cadena “azul”.

Clase String
La clase Stringse utiliza para representar cadenas en Java.

El método charAt de String devuelve el carácter ubicado en una posición específica en el objeto String. El método charAt recibe un argumento entero que se utiliza como el índice, y devuelve el carácter en esa posición. Al igual que los arreglos, se considera que el primer elemento de un objeto Stringestá en la posición 0.

Método equalsde Strin
El método equals(un método de la clase Object, sobrescrito en String) prueba la igualdad entre dos objetos (es decir, que las cadenas contenidas en los dos objetos sean idénticas). El método devuelve true si el contenido de los objetos es igual y false en caso contrario.

Método equalsIgnoreCasede String
Si va a ordenar objetos String, puede comparar si son iguales con el método equalsIgnoreCase, el cual  ignora si las letras en cada objeto Stringson mayúsculas o minúsculas al realizar la comparación. Por lo tanto, la cadena “hola”y la cadena “HOLA”se consideran iguales.

si ya existe, insertarlo al final del Arreglo

Introducir elementos de un arreglo y al final agregar un nuevo elemento, si el elemento ya existe en el arreglo insertarlo al final.

import javax.swing.JOptionPane;
import javax.swing.JTextArea;

public class ExamenProgramacion_II
{
    public static void main (String args[])
    {
        int arreglo[];
        int introducido, elemento, NuevoNumero, posicion;
        String entrada, entrada2, entrada3, entrada4;
        
        JTextArea areaSalida = new JTextArea();
        areaSalida.setText("#############################\n");
        areaSalida.append("                      Java Tips\n");
        areaSalida.append("#############################\n\n");
        
        entrada = JOptionPane.showInputDialog("Introduce el tamaño del Arreglo");
        introducido = Integer.parseInt(entrada);
        arreglo = new int [introducido];
        
        areaSalida.append("El tamaño del Arreglo es de:\n " + entrada);
        areaSalida.append("\n\nElementos Originales del Arreglo\n");
        for (elemento = 0; elemento < introducido; elemento++)
        {
            entrada2 = JOptionPane.showInputDialog("Introduce el elemento " + (elemento + 1) + " para el Arreglo");
            arreglo[elemento] = Integer.parseInt(entrada2);
            areaSalida.append("  " + arreglo[elemento] + ",");
        }
        
        entrada3 = JOptionPane.showInputDialog("Introduce el Nuevo Elemento");
        NuevoNumero = Integer.parseInt(entrada3);
        
        entrada4 = JOptionPane.showInputDialog("Introduce la Posicion del Elemento en el Arreglo");
        posicion = Integer.parseInt(entrada4);
        
        areaSalida.append("\n\nArreglo con el Elemento Insertado\n");
        if( NuevoNumero !=  arreglo[posicion] )
        {
            arreglo[posicion] = NuevoNumero;
            for (elemento = 0; elemento < introducido; elemento++)
            {
                areaSalida.append("  " + arreglo[elemento] + ",");
            }
        }
        else
        {
            JOptionPane.showMessageDialog(null, "El elemento ya existe en el Arreglo, se insertara al final");
            for (elemento = 0; elemento < introducido; elemento++)
            {
                areaSalida.append("  " + arreglo[elemento] + ",");
            }
            areaSalida.append("  " + arreglo[posicion] + ",");
        }
        
        JOptionPane.showMessageDialog( null, areaSalida, "Java Tips", JOptionPane.INFORMATION_MESSAGE);  
    }    
}

Output:
 

Imprimir los elementos de un Arreglo en Orden Inverso

import javax.swing.JOptionPane;
import javax.swing.JTextArea;

public class Orden_Inverso
{
    public static void main ( String args[] )
    {
        int arreglo1[];     // Declaramos arreglo1[]
        int introducido;    // Variable que controla el tamaño del arreglo
        int elemento;       // Varibale que nos servira para contar
        // Creamos dos variables String para la entrada de datos
        String entrada1, entrada2;
       
        // Creamos un objeto JTextArea con nombre areaSalida
        JTextArea areaSalida = new JTextArea();
        // Colocamos texto con setText
        areaSalida.setText( "                     Arreglo Unidimensional\n");
       
        // Pedimos al usuario que introduzca el tamaña del Arreglo
        entrada1 = JOptionPane.showInputDialog( "Introduce el Tamaño del Arreglo ");
        // Convertimos la entrada del usuario en valor int
        introducido = Integer.parseInt( entrada1 );
        // Creamos el arreglo1 con elementos del valor de "introducido"
        arreglo1 = new int [ introducido ];
       
        // Concatenamos el texto y mostramos en pantalla
        areaSalida.append("\nEl tamaño del Arreglo es de:\n  " + entrada1 );
        areaSalida.append("\nElementos del Arreglo A introducidos son: \n");
       
        // Ciclo que controla el numero de pasadas del valor "introducido"
        for(elemento = 0; elemento &lt; introducido; elemento++)
        {
            // En cada pasada se pedira al usuario que introduzca los elementos del arreglo
            entrada2 = JOptionPane.showInputDialog(  "Introduce el elemento " + ( elemento + 1 ) + " para el Arreglo" );
            // En cada pasada los elementos se iran convirtiendo a int y colando en arreglo1
            arreglo1[ elemento ] = Integer.parseInt( entrada2 );
            // En cada pasada se iran mostrando en pantalla los elementos introducidos
            areaSalida.append("  " + arreglo1[ elemento ] + ",");
        }
       
        // Creamos una variable temp y lo inicializamos, tambien una variable inicio y fin     
        int temp = 0, inicio, fin;       
        // Ciclo que controla y mueve los elementos del arreglo1 en orden inverso
        for(inicio = 0, fin = arreglo1.length-1; inicio &lt; fin; inicio++, fin--)
        {
            temp = arreglo1[ inicio ];
            arreglo1[ inicio ] = arreglo1[ fin ];
            arreglo1[ fin ] = temp;
        }
        areaSalida.append("\nElementos del Arreglo A (en Orden Inverso) son: \n");
        // Ciclo que muestra en pantalla los elementos en orden inverso del arreglo1
        for(elemento = 0; elemento &lt; arreglo1.length ; elemento++)
        {
            areaSalida.append("  " + arreglo1[ elemento ] + ",");
        }
       
        // Mostramos los resultados en pantalla
        JOptionPane.showMessageDialog( null, areaSalida, "Arreglo Unidimensional", JOptionPane.INFORMATION_MESSAGE);
    }
}

Salida:

Suma de dos arreglos y almacenarlos en un tercer arreglo

// Suma de Arreglo1 + Arreglo2 da como resultado un tercer Arreglo3
import javax.swing.JOptionPane;
import javax.swing.JTextArea;

public class Arreglo_Unidimensional
{
    public static void main (String args[])
    {
        int elemento, N;    // Declaramos dos variables de tipo int
        int arreglo1[];     // Declaramos el arreglo1[]        
        int arreglo2[];     // Declaramos el arreglo2[]  
        int arreglo3[];     // Declaramos el arreglo3[]  
        String entrada, entrada1, entrada2;
        
        // Creamos un objeto JTextArea con nombre areaSalida y colocamos texto en el objeto con setText
        JTextArea areaSalida = new JTextArea();
        areaSalida.setText("                Suma de Arreglos\n\n");
        
        // Pide al usuario que ingrese el tamaño de elemento para el arreglo1 y arreglo2
        entrada = JOptionPane.showInputDialog("Introduce el tamaño de elementos para Arreglo1 y Arreglo2");
        // Convierte el dato introducido de tipo String a tipo int en la variable N
        N = Integer.parseInt( entrada );
        // Creamos los tres arreglos cada uno con elementos de N ingresado por el usuario
        arreglo1 = new int [ N ];
        arreglo2 = new int [ N ];
        arreglo3 = new int [ N ];
        
        // Mostramos texto en el objeto areaSalida de JTextArea
        areaSalida.append("El tamaño de cada Arreglo es de:\n" + N);
        areaSalida.append("\nElementos del Arreglo1 son:\n");
        // Ciclo que pide en cada pasada los elementos del arreglo1
        for (elemento = 0; elemento < N; elemento++)
        {
        // Pide al usuario que ingrese en cada pasada los elementos del arreglo1
        entrada1 = JOptionPane.showInputDialog("Introduzca el elemento " + (elemento + 1) + " del Arreglo 1");
        // Cada elemento introducido lo convertimos a tipo int en el arreglo1[]
        arreglo1[elemento] = Integer.parseInt( entrada1 );
        // En cada pasada se iran agregando los elementos al objeto areaSalida
        areaSalida.append(" " + arreglo1[elemento] + ",");
        }
        // Mostramos texto en el objeto aresaSalida de JTextArea
        areaSalida.append("\nElementos del Arreglo2 son:\n");
        // Ciclo que pide en cada pasada los elementos del arreglo2
        for (elemento = 0; elemento < N; elemento++)
        {
        // Pide al usuario que ingrese en cada pasada los elementos del arreglo2
        entrada2 = JOptionPane.showInputDialog("Introduzca el elemento " + (elemento + 1) + " del Arreglo 2");
        // Cada elemento introducido lo convertimos a tipo int en el arreglo2[]
        arreglo2[elemento]  = Integer.parseInt( entrada2 );
        // En cada pasada se iran agregando los elementos al objeto areaSalida
        areaSalida.append(" " + arreglo2[elemento] + ",");
        }        
        // Mostramos texto en el objeto areaSalida
        areaSalida.append("\nSuma del Arreglo1 + Arreglo2 = Arreglo3\n\n");
        // Ciclo que suma los elementos del arreglo1 y arreglo2 para dar resultado a un arreglo3
        // Y en cada pasada se va mostrando en el objeto areaSalida los elementos del arreglo3
        for (elemento = 0; elemento < N; elemento++)
        {
            arreglo3[elemento]= arreglo1[elemento] + arreglo2[elemento];
            areaSalida.append(" " + arreglo1[elemento] + " + " + arreglo2[elemento] + " = " + arreglo3[elemento] + "\n");    
        }
        // Mostramos los resultados en pantalla
        JOptionPane.showMessageDialog(null, areaSalida);
    }
}

Output:

Arboles en Java: Recorrido Preorden, Inorden y Postorden

El recorrido de árboles refiere al proceso de visitar de una manera sistemática, exactamente una vez, cada nodo en una estructura de datos de árbol (examinando y/o actualizando los datos en los nodos).

Preorden: (raíz, izquierdo, derecho). Para recorrer un árbol binario no vacío en preorden, hay que realizar las siguientes operaciones recursivamente en cada nodo, comenzando con el nodo de raíz:

1. Visite la raíz
2. Atraviese el sub-árbol izquierdo
3. Atraviese el sub-árbol derecho

Inorden: (izquierdo, raíz, derecho). Para recorrer un árbol binario no vacío en inorden (simétrico), hay que realizar las siguientes operaciones recursivamente en cada nodo:

1. Atraviese el sub-árbol izquierdo
2. Visite la raíz
3. Atraviese el sub-árbol derecho

Postorden: (izquierdo, derecho, raíz). Para recorrer un árbol binario no vacío en postorden, hay que realizar las siguientes operaciones recursivamente en cada nodo:

1. Atraviese el sub-árbol izquierdo
2. Atraviese el sub-árbol derecho
3. Visite la raíz

En general, la diferencia entre preorden, inorden y postorden es cuándo se recorre la raíz. En los tres, se recorre primero el sub-árbol izquierdo y luego el derecho.

• En preorden, la raíz se recorre antes que los recorridos de los subárboles izquierdo y derecho
• En inorden, la raíz se recorre entre los recorridos de los árboles izquierdo y derecho, y
• En postorden, la raíz se recorre después de los recorridos por el subárbol izquierdo y el derecho

public class NodoArbol
{
    //miembros de acceso
    NodoArbol nodoizquierdo;
    int datos;
    NodoArbol nododerecho;
    
    //iniciar dato y hacer de este nodo un nodo hoja
    public NodoArbol(int datosNodo)
    {
        datos = datosNodo;
        nodoizquierdo = nododerecho = null; //el nodo no tiene hijos
    }
    
    //buscar punto de insercion e inserter nodo nuevo
    public synchronized void insertar(int valorInsertar)
    {
        //insertar en subarbol izquierdo
        if(valorInsertar < datos)
        {
            //insertar en subarbol izquierdo
            if(nodoizquierdo == null)
                nodoizquierdo = new NodoArbol(valorInsertar);
            else    //continua recorriendo subarbol izquierdo
                nodoizquierdo.insertar(valorInsertar);
        }
        
        //insertar nodo derecho
        else if(valorInsertar > datos)
        {
            //insertar nuevo nodoArbol
            if(nododerecho == null)
                nododerecho = new NodoArbol(valorInsertar);
            else
                nododerecho.insertar(valorInsertar);
        }
    } // fin del metodo insertar
}

class Arbol
{
    private NodoArbol raiz;
    
    //construir un arbol vacio
    public Arbol()
    {
        raiz = null;
    }
    
    //insertar un nuevo ndo en el arbol de busqueda binaria
    public synchronized void insertarNodo(int valorInsertar)
    {
        if(raiz == null)
            raiz = new NodoArbol(valorInsertar); //crea nodo raiz
        else
            raiz.insertar(valorInsertar); //llama al metodo insertar        
    }
    
    // EMPIEZA EL RECORRIDO EN PREORDEN
    public synchronized void recorridoPreorden()
    {
        ayudantePreorden(raiz);
    }
    //meoto recursivo para recorrido en preorden
    
    private void ayudantePreorden(NodoArbol nodo)
    {
        if(nodo == null)
            return;
        
        System.out.print(nodo.datos + " ");     //mostrar datos del nodo
        ayudantePreorden(nodo.nodoizquierdo);   //recorre subarbol izquierdo
        ayudantePreorden(nodo.nododerecho);     //recorre subarbol derecho
    }
    
    //EMPEZAR RECORRIDO INORDEN
    public synchronized void recorridoInorden()
    {
        ayudanteInorden(raiz);
    }
    
    //meoto recursivo para recorrido inorden
    private void ayudanteInorden( NodoArbol nodo)
    {
        if(nodo == null)
            return;
        
        ayudanteInorden(nodo.nodoizquierdo);
        System.out.print(nodo.datos + " ");
        ayudanteInorden(nodo.nododerecho);
    }
    
    //EMPEZAR RECORRIDO PORORDEN
    public synchronized void recorridoPosorden()
    {
        ayudantePosorden(raiz);        
    }
    
    //meotod recursivo para recorrido posorden
    private void ayudantePosorden(NodoArbol nodo)
    {
        if( nodo == null )
            return;
        
        ayudantePosorden(nodo.nodoizquierdo);
        ayudantePosorden(nodo.nododerecho);
        System.out.print(nodo.datos + " ");
    }
}

Clase controladora:

import javax.swing.JOptionPane;

public class PruebaArbol
{
    public static void main(String args [])
    {
        Arbol arbol = new Arbol();
        int valor;
        String Dato;
        
        System.out.println("Insertando los siguientes valores: ");
        
        Dato = JOptionPane.showInputDialog("Inserta el numero de nodos que desea ingresar");
        int n = Integer.parseInt(Dato);
        
        for(int i = 1; i <= n; i++ )
        {
            Dato = JOptionPane.showInputDialog("Dame el " + i + " valor para colocar en el Arbol");
            valor = Integer.parseInt(Dato);
            System.out.print(valor + " ");
            arbol.insertarNodo(valor);
        }
        
        System.out.println("\n\nRecorrido Preorden");
        arbol.recorridoPreorden();
        
        System.out.println("\n\nRecorrido Inorden");
        arbol.recorridoInorden();
        
        System.out.println("\n\nRecorrido Postorden");
        arbol.recorridoPosorden();
    }
}

Output:
Insertando los siguientes valores:
35 50 8 12 69 84 25 75 93 16

Recorrido Preorden
35 8 12 25 16 50 69 84 75 93

Recorrido Inorden
8 12 16 25 35 50 69 75 84 93

Recorrido Postorden
16 25 12 8 75 93 84 69 50 35

Comparar dos archivos de texto en Java

Comparar dos archivos de texto linea por linea en Java.

import java.io.FileReader;
import java.io.IOException;
import java.io.BufferedReader;

public class Compara
{
    public static void main(String[] args) throws IOException
    {
        try
        {
            BufferedReader lee1 =new BufferedReader(new FileReader("original.txt"));
            BufferedReader lee2 =new BufferedReader(new FileReader("original.txt"));
           
            String linea1="", linea2 = "";
            System.out.println("Comparando Archivos...");
            int cont1=0, cont2=0;
           
            while(linea1!=null || linea2!=null)
            {
              linea1=lee1.readLine();
              linea2=lee2.readLine();
              if(linea1!=null){
                  cont1++;
              }
              if(linea2!=null){
                  cont2++;
              }
            };
            System.out.println("Fin de comparacion de los archivos...\n");
            System.out.println("El primer archivo tiene "+cont1+" Lineas");
            System.out.println("El segundo archivo tiene "+cont2+" Lineas");
            if(cont1 == cont2){
                System.out.println("Los archivos comparados son iguales");
            }
            else{
                System.out.println("Los archivos comparados son diferentes");
            }
            lee1.close();
            lee2.close();
        }
        finally
        {
          System.out.println("fin...");
        }
    }
}

Output:
Comparando Archivos...
Fin de comparacion de los archivos...

El primer archivo tiene 39 Lineas
El segundo archivo tiene 39 Lineas
Los archivos comparados son iguales
fin...

Leer un archivo de texto con FileReader

import java.io.FileReader;
import java.io.BufferedReader;

public class Datos {
    
    public static void main(String [] args) throws Exception
    {
        FileReader fr = new FileReader("alumnos.txt");
        BufferedReader br = new BufferedReader(fr);
        String s;
        
        while((s = br.readLine()) != null )
        {
            System.out.println(s);
        }
        fr.close();
    }    
}

Lectura básica de un archivo de texto (alumnos.txt)
Output:

Matricula    Alumnos Califcacion Sexo
12345 Jose Suarez                     8.9 M
23233      Joaquin Hernandez         4.6               M
56789      Felipe Reyes                 10                F
34567 Enrique Salas                 9.5               M
99392      Eduardo Sanchez         5.3                M

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.

Diferencia entre next y nextLine en Java

next() solo lee hasta donde encuentra un espacio (hasta un espacio).
nextLine() lee todo incluyendo espacios (hasta un enter).

A continuación, los siguientes métodos pueden ser útiles para la lectura de datos simples:
Scanner lector = new Scanner(System.in);

String p1 = lector.next();               //lee una cadena de texto
String p2 = lector.nextLine();       //lee una cadena de texto hasta fin de linea

int n1 = lector.nextInt();                 //lee un numero entero
double n2 = lector.nextDouble();   //lee un numero de tipo double
float n3 = lector.nextFloat();          //lee un número de tipo flotante

Operaciones con Arreglos # I

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;

public class OperacionesI
{
    public static void main(String[] args) throws IOException
    {
        //Creamos un objerto para obtener datos desde el teclado
        BufferedReader teclado = new BufferedReader(new InputStreamReader (System.in));
        
        String arreglo[];
        int i, n;
        String modifica;
        int posicion;
        String buscador;
        char opcion = 0;
        
        System.out.print("Introduce el numero de datos a procesar: ");
        n = Integer.parseInt(teclado.readLine());
        arreglo = new String [n];
        
        for (i=0; i<n; i++)
        {
            System.out.print("Ingresa el elemento no. "+(i+1)+ ": ");
            arreglo[i] = teclado.readLine();
        }
        while(opcion !='x')
        {
            System.out.println("\n******************************");
            System.out.println("a.- Registrar nuevos elementos");
            System.out.println("b.- Contar elementos");
            System.out.println("c.- Quitar un elemento");
            System.out.println("d.- Exhibir los elementos");
            System.out.println("e.- Convertir elementos de minuscula-mayuscula"); 
            System.out.println("f.- Buscar un elemento");
            System.out.println("g.- Limpiar el arreglo");
            System.out.println("h.- Remplazar un elemento");
            System.out.println("i.- Invertir arreglo");
            System.out.println("x.- Salir");
            System.out.println("******************************");
            System.out.print("Ingresa una opcion...  ");
            opcion = (char)System.in.read();
            teclado.readLine();
           
            //Sentencia switch para elegir una de varias opciones
            switch(opcion) //dependiendo de la opcion ingresada se ejecuta una sentencia de las varias opciones disponibles
            {
                case 'a':                  
                    String nuevo;
                    System.out.println("Registrando nuevos elementos para el arreglo\n");

                    for(i=0; i<arreglo.length; i++)
                    {
                        System.out.print("Ingresa el elemento ["+(i)+"] = ");
                        arreglo[i] = teclado.readLine();                      
                    }
                    System.out.println("\nLos "+arreglo.length+" elementos han sido ingresado correctamente");
                break;
                
                case 'b':    //Si se ingresa la opcion "b" ejecuta esta sentencia
                    System.out.println("Total de elementos \n "+arreglo.length);
                    break;
               
                case 'c':
                    System.out.println("Los Elementos almacenados en el arreglo son\n");
                    for(i=0; i<N; i++)
                    {
                        System.out.print(arreglo[i] + ", ");
                    }                  
                    System.out.println("\n");
                    String quitar;                   
                    System.out.print("Que elemento desea quitar?? ");
                    quitar = teclado.readLine();                   
                   
                    System.out.println();                   
                    for(i=0; i<N; i++)
                    {
                        if( arreglo[i].equals(quitar) )
                        {
                            System.out.println("Elemento ["+i+"] = "+arreglo[i]+" <- eliminado");
                            arreglo[i] = null;                          
                            //System.out.println("elemento ["+(i)+ "] eliminado"); 
                        }                
                       }
                       System.out.println("\nAhora los elementos son:\n");
                       for(i=0; i<N; i++)
                    {
                        System.out.println("Elemento ["+i+"] = "+arreglo[i]);
                    }                      
                    break;                   
               
                case 'd':    //Si se ingresa la opcion "d" ejecuta esta sentencia
                    System.out.println("\nElementos del arreglo son: \n");
                    for(i=0; i<N; i++)
                    {
                        System.out.print(" "+arreglo[i] + ", ");
                    }
                    System.out.println();                   
                    break;
                   
                case 'e':
                    System.out.println("\nVerificacion: \n");
                    for(i=0; i<arreglo.length; i++)
                    {
                        if(arreglo[i].equals(arreglo[i].toLowerCase()))
                        {
                            System.out.println("["+i+"] = "+arreglo[i]+" <- es Minuscula ");                          
                            arreglo[i] = arreglo[i].toUpperCase();
                        }
                        else
                        {
                            System.out.println("["+i+"] = "+arreglo[i]+" <- es MAYUSCULA ");
                        }
                    }
                    System.out.println();
                    System.out.println("Elementos ");
                    for(i=0; i<arreglo.length; i++)
                    {                      
                        System.out.println("["+i+"] = "+arreglo[i]);
                    }                 
                    break;
               
                case 'f':    //Si se ingresa la opcion "f" ejecuta esta sentencia
                    System.out.println();
                    System.out.print("Introduce el caracter a buscar: ");                 
                    buscador = teclado.readLine();                   
                    System.out.println();
                   
                    for(i=0; i<N; i++)
                    {
                        if( arreglo[i].equals (buscador) )
                        {
                            System.out.println("Buscando en posicion ["+i+"] = "+arreglo[i]+" <- Caracter ENCONTRADO!");
                            //System.out.println("Buscando en posicion ["+i+"] = "+arreglo[i]+" = "+buscador+" <- Caracter ENCONTRADO!");
                            //System.out.print("\nCaracter encontrado en la posicion ["+(i)+"] "); //Encuentra el caracter en la posicion
                        }
                        else
                        {
                            System.out.println("Buscando en posicion ["+i+"] = "+arreglo[i]+" <- Caracter no encontrado");
                            //System.out.print("\nCaracter no encontrado en ["+i+"]");                    
                        }                     
                       }
                       System.out.println();                 
                    break;
                    
                case 'g':
                        String confirmar;
                    System.out.print("\nHa elegido la opcion limpiar, esta seguro de que quiere hacerlo?\nFavor de confirmar si o no? ");
                        confirmar = teclado.readLine();
                       
                        String eliminar = "si";
                        //System.out.println("\nHa elegido la opcion limpiar, esta seguro de que quiere hacerlo?");
                        //confirmar = teclado.readLine();
                        System.out.println();
                        if(eliminar.equals(confirmar))
                        {
                        for (i=0; i<N; i++)
                        {
                            arreglo[i] = null;
                            System.out.println("elemento ["+(i)+ "] eliminado");                           
                            //System.out.println("elemento ["+(i)+ "] eliminado");
                            //arreglo[i] = " ";
                            //System.out.print(arreglo[i] + ", ");
                        }
                        }
                        else
                        {
                            System.out.println("Ha elegido conservar los elementos\n\tGracias!");
                        }
                    
                               
                                /*for (i=0; i<N; i++)
                        {
                            System.out.println("elemento ["+(i)+ "] eliminado");
                            arreglo[i] = null; //Elementos del arreglo se eliminan, pero el tamaño sigue siendo el mismo
                            //System.out.print("valor de ["+i+"] = "+arreglo[i]);
                        }*/
                    break;
                    
                case 'h':
                    System.out.print("\nIntroduce el nuevo Elemento: ");                 
                    modifica = teclado.readLine();

                    System.out.print("Introduce la posicion valida en el Arreglo.. de [0] hasta ["+(arreglo.length-1)+"] : ");
                    posicion = Integer.parseInt(teclado.readLine());
                   
                    System.out.println("\nEl elemento ha sido reemplazado y se ha agregado el nuevo elemento: \n");
                    if( modifica !=  arreglo[posicion] )
                    {
                        arreglo[posicion] = modifica;
                        for (i = 0; i < N; i++)
                        {
                            System.out.print(" " + arreglo[i] + ",");
                        }
                    }
                    System.out.println();
                    break;
                    
                case 'i':    //Si se ingresa la opcion "i" ejecuta esta sentencia
                    System.out.println("\nArreglo Invertido: \n");                   
                    for (i = arreglo.length-1; i >= 0; i--)
                    {
                        System.out.print(" "+arreglo[i] + ", ");
                    }
                    System.out.println();
                    break;
               
                case 'x':    //Si se ingresa la opcion "j" ejecuta esta sentencia
                    opcion = 'x';
                    break;
                    
                default:    //Si el compilador no encuentra la opcion que se ingreso entonces se ejecuta esta sentencia (default)
                    System.out.println("\nOpción incorrecta.. favor de insertar la opcion disponible en el Menu");
                    break;
            }
        }
        System.out.println("\nHa salido correctamente de la Aplicacion...");
    }
}

Output:

Introduce el numero de datos a procesar: 4
Ingresa el elemento no. 1: a
Ingresa el elemento no. 2: t
Ingresa el elemento no. 3: v
Ingresa el elemento no. 4: h

******************************
a.- Registrar nuevos elementos
b.- Contar elementos
c.- Quitar un elemento
d.- Exhibir los elementos
e.- Convertir elementos de minuscula-mayuscula
f.- Buscar un elemento
g.- Limpiar el arreglo
h.- Remplazar un elemento
i.- Invertir arreglo
x.- Salir
******************************
Ingresa una opcion...  d

Elementos del arreglo son:

 a,  t,  v,  h,

******************************
a.- Registrar nuevos elementos
b.- Contar elementos
c.- Quitar un elemento
d.- Exhibir los elementos
e.- Convertir elementos de minuscula-mayuscula
f.- Buscar un elemento
g.- Limpiar el arreglo
h.- Remplazar un elemento
i.- Invertir arreglo
x.- Salir
******************************
Ingresa una opcion...  e

Verificacion:

[0] = a <- es Minuscula
[1] = t <- es Minuscula
[2] = v <- es Minuscula
[3] = h <- es Minuscula

Elementos
[0] = A
[1] = T
[2] = V
[3] = H

******************************
a.- Registrar nuevos elementos
b.- Contar elementos
c.- Quitar un elemento
d.- Exhibir los elementos
e.- Convertir elementos de minuscula-mayuscula
f.- Buscar un elemento
g.- Limpiar el arreglo
h.- Remplazar un elemento
i.- Invertir arreglo
x.- Salir
******************************
Ingresa una opcion...  f

Introduce el caracter a buscar: T

Buscando en posicion [0] = A <- Caracter no encontrado
Buscando en posicion [1] = T <- Caracter ENCONTRADO!
Buscando en posicion [2] = V <- Caracter no encontrado
Buscando en posicion [3] = H <- Caracter no encontrado


******************************
a.- Registrar nuevos elementos
b.- Contar elementos
c.- Quitar un elemento
d.- Exhibir los elementos
e.- Convertir elementos de minuscula-mayuscula
f.- Buscar un elemento
g.- Limpiar el arreglo
h.- Remplazar un elemento
i.- Invertir arreglo
x.- Salir
******************************
Ingresa una opcion...  h

Introduce el nuevo Elemento: k
Introduce la posicion valida en el Arreglo.. de [0] hasta [3] : 2

El elemento ha sido reemplazado y se ha agregado el nuevo elemento:

 A, T, k, H,

******************************
a.- Registrar nuevos elementos
b.- Contar elementos
c.- Quitar un elemento
d.- Exhibir los elementos
e.- Convertir elementos de minuscula-mayuscula
f.- Buscar un elemento
g.- Limpiar el arreglo
h.- Remplazar un elemento
i.- Invertir arreglo
x.- Salir
******************************
Ingresa una opcion...  x

Ha salido correctamente de la Aplicacion...