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...

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...

Tabla Pitagorica

public class TablaPitagorica
{
    public static void main (String args [])
    {
        // Declaramos dos variables de tipo int
        int A, B;
       
        // Mostramos texto en consola 
        System.out.println("Tabla Pitagorica:\n\n");
        A=1;         // Iniciamos la variable A
        while(A<=10) // Itera 10 veces
        {
            B=1;
            while(B<=10) // Itera 10 veces y muestra la salida en pantalla
            {
                System.out.printf("%5d",A*B);
                B++; // En cada pasada se ira incrementando la variable B
            }
            // En cada pasada se mostrara un espacio y se ira incrementara la variable A
            System.out.println();
            A++;
        }
        // Termina las iteraciones y sale del programa
        System.exit(0);
    }
}

Output:

Tabla Pitagorica:

    1    2    3    4    5    6    7    8    9   10
    2    4    6    8   10   12   14   16   18   20
    3    6    9   12   15   18   21   24   27   30
    4    8   12   16   20   24   28   32   36   40
    5   10   15   20   25   30   35   40   45   50
    6   12   18   24   30   36   42   48   54   60
    7   14   21   28   35   42   49   56   63   70
    8   16   24   32   40   48   56   64   72   80
    9   18   27   36   45   54   63   72   81   90
   10   20   30   40   50   60   70   80   90  100