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

Ejemplo Arreglo

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

public class EjemploArreglo
{
    public static void main (String args[])
    {
        //Creamos un objeto JTextArea con nombre llamado Area y agrega los componentes al frame
        JTextArea Area = new JTextArea(15,40);
        JScrollPane ScrollPane;
        
        // Creamos dos variables de tipo String Ns para tamaño y ValorS para elementos
        String Ns, valorS; 
        int i, j, N, A[]; // Variables de tipo int mas la declaracion del arreglo A[]
        
        // Pide al usuario que ingrese el tamaño del arreglo
        Ns = JOptionPane.showInputDialog("De que tamaño desea el arreglo");
        N = Integer.parseInt(Ns); // Convertimos el dato ingresado (Ns) a tipo int 
        A = new int [N];          // Creamos el arreglo con elementos N
        
        // Ciclo que controlara las pasadas dependiendo del tamaño (N) del arreglo
        for (i=0; i<N; i++) 
        {
            // En cada pasada pedira que el usuario teclee los elementos del arreglo
            valorS = JOptionPane.showInputDialog("Introduzca el elemento" + (i+1) + " para el Arreglo");
            A[i] = Integer.parseInt(valorS); // En cada pasada se almacenara al Arreglo A[i]
        }
        // Mostramos texto con el objeto Area
        Area.setText("Los elementos del arreglo son;\n\n");
        // Ciclo que mostrara en pantalla los elementos introducidos del arreglo 
        for(i=0; i<N; i++)
            
        Area.append("A[ "+ (i+1) + "]  = " + A[i] + "\n");
        ScrollPane = new JScrollPane(Area);
        
        // Mostramos la salida en pantalla
        JOptionPane.showMessageDialog(null, ScrollPane, "Ejemplo de Arreglo", JOptionPane.INFORMATION_MESSAGE);
        
        System.exit(0);  // Terminar el programa
    }  
}

Multiplication Table

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

public class TablaMultiplicar
{
     public static void main(String args[])
     {
         String Num1; // Numero de la tabla introducido por el usuario
         int A;       // Valor del numero de la tabla a multiplicar
         
         // Creamos un objeto JTextArea con nombre areaSalida y colocamos texto con setText
         JTextArea TextoSalida = new JTextArea();
         TextoSalida.setText("El numero introducido es: ");
         
         // Pide al usuario que introduzca el numero a multiplicar
         Num1 = JOptionPane.showInputDialog("Introduce el Numero de la Tabla a Multiplicar");
         // Convertimos el numero introducido a int con la variable A
         A = Integer.parseInt( Num1 );
         
         // Ciclo que itera 10 veces
         for ( int x=1;x<11;x++ )
         {
             // Concatemos texto incluyendo la operacion de multiplicacion del numero introducido
             TextoSalida.append("\n" + A  + " x " + x + " = " + ( x*A ));
         }
         
         // Mostramos los resultados en pantalla         
         JOptionPane.showMessageDialog( null, TextoSalida, "Obtencion de la Tabla de Multiplicar", JOptionPane.PLAIN_MESSAGE);
        }
}

Another Application: Adding Integers

Aplicacion1.java

// El programa usa la clase JOptionPane
import javax.swing.JOptionPane;

public class Aplicacion1
{
    public static void main(String args[])
    {
        String Num1; // Variable para primera cadena introducida por el usuario
        String Num2; // Variable para segunda cadena introducida por el usuario

        int A;      //Declaramos una variable int llamada A que sera el primer numero introducido
        int B;      // Segunda variable que sera el segundo numero
        int Mayor;  // variable con parametro mayor

        Num1 = JOptionPane.showInputDialog( "Introduce el Primer Numero" ); //pide al usuario introducir el primer numero
        Num2 = JOptionPane.showInputDialog( "Introduce el Segundo Numero" ); //pide el segundo numero
        
        //Convierte los numeros de tipo string a tipo int
        A = Integer.parseInt( Num1 );
        B = Integer.parseInt( Num2 );

        if ( A > B ) //Si la condicion se cumple entonces el numero mayor es = A
            Mayor = A;
        else        // Si la condicion no se cumple entonces el numero mayor es = B
            Mayor = B;
           
        //Imprimimos en pantalla los resultados con la clase JOptionPane y el metodo showMessageDialog mas los argumentos
        JOptionPane.showMessageDialog( null, " El mayor de " + A + ", " + B + " es: " +  Mayor , "Obtención del Numero Mayor", JOptionPane.PLAIN_MESSAGE);
    }
}

Aplicacion2.java

import javax.swing.JOptionPane;

public class Aplicacion2
{
    public static void main(String args[])
    {
        // Declaramos las variables para las tres cadenas que introduzca el usuario
        String Num1;
        String Num2;
        String Num3;

        int A;  // Primero Numero
        int B;  // Segundo Numero
        int C;  // Tercer Numero
        int Mayor; // Parametro para elegir el numero mayor
        
        // Pedir la entrada de datos, del primer, segundo y tercer numero
        Num1 = JOptionPane.showInputDialog( "Introduce el Primer Numero" );
        Num2 = JOptionPane.showInputDialog( "Introduce el Segundo Numero" );
        Num3 = JOptionPane.showInputDialog( "Introduce el Tercer Numero" );
        
        // Convertimos los numero introducidos de tipo String a tipo int 
        A = Integer.parseInt( Num1 );
        B = Integer.parseInt( Num2 );
        C = Integer.parseInt( Num3 );
        
        // Realizamos la condicion de los primeros dos numeros (A) y (B)
        if ( A > B ) // Si el primero numero (A) introducido, es mayor que el segundo numero (B) entonces A = Mayor
            Mayor = A;
        else // Si la condicion anterior no se cumple, entonces B = Mayor
            Mayor = B;
        if ( C > Mayor ) // De la lo anterior se compara el Mayor con el tercer numero (C) y si esta condicion
            Mayor = C;   // se cumple entonces C = Mayor y si no se cumple se descarta esta condicion.
        
        // Por ultimo, imprimimos los resultados en pantalla y listo
        JOptionPane.showMessageDialog( null, " El mayor de " + A + ", " + B + " y " +  C + " es: " +  Mayor , "Obtención del Numero Mayor", JOptionPane.PLAIN_MESSAGE);
    }
}