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

¿Cómo comprobar si un char es igual a un espacio vacío?

Here's what I've got:

private static int countNumChars(String s) {
    for(char c : s.toCharArray()){
        if (Equals(c," "))
    }
}

But that code says it cannot find Symbol for that method. I remember Java having a comparer like this... Any suggestions?

Answers:
if (c == ' ')
char is a primitive data type, so it can be compared with ==.
Also, by using double quotes you create String constant (" "), while with single quotes it's a char constant (' ').

In this case, you are thinking of the String comparing function "String".equals("some_text"). Chars do not need to use this function. Instead a standard == comparison operator will suffice.

private static int countNumChars(String s) {
    for(char c : s.toCharArray()){
        if (c == ' ') // your resulting outcome
    }
}

Sintaxis para utilizar Equals en java?

El método equals realiza una comparación del objeto contra el objeto que recibe como parámetro, para determinar si son iguales en sus atributos o no. Regresa true o false.

Está definido en la clase Object. Se usa:
objeto1.equals(objeto2);

Este metodo es una comparasion de caracteres tanto como de enteros y el valor de cada uno es determinado como true o false la sintaxis es la siguiente.

si el dato es caracter se determina de la siguiente forma
a="hola";
if(a.equals("hola")){
sistem.out.printlan("es igual");
}else
sistem.out.println("diferentel");

System.out.println("e.- buscar un registro");
...
                case 'e':
                    String busca;
                    System.out.print("\ningresa el registro a buscar: ");
                    busca = leer.readLine();

                    System.out.println();
                    for(i=0; i< N; i++)
                    {
                        if( arreglo[i].equals(busca))
                        {
                            System.out.print("\nCaracter encontrado en la posicion ["+(i)+"] ");

                            //Encuentra el caracter en la posicion
                        }
                        else
                        {
                            System.out.print("\nCaracter no encontrado en ["+i+"]"); 
                        }
                    }
                    System.out.println();                
                    break;