Free Web Site - Free Web Space and Site Hosting - Web Hosting - Internet Store and Ecommerce Solution Provider - High Speed Internet
Search the Web

Ejercicio de Strings y arreglo

El ejercicio consiste en ingresar por teclado un conjunto de string ( países ) y almacenarlos en un arreglo, para realizar las siguientes operaciones :

1) ordenar alfabeticamente el arreglo

2) imprimir el arreglo en pantalla

3) buscar un string en el arreglo

4) contar cuantas veces se repite un caracter ingresado por teclado en el arreglo

Ejemplo de lo que debería ser la salida

Declaración de variables

Para tener en memoria el espacio necesario de almacenamiento de un conjunto de strings, tenemos que declarar una variable de tipo int que guarde el numero de elementos que va a tener el arreglo (se lee por teclado) y una variable de tipo arreglo de String.

Por ejemplo vamos a declarar las siguientes variables :

int numEntradas;
String arr[ ];

Reservar espacio en memoria para el arreglo arr

Hasta el momento solo existe la variable de tipo arreglo, pero al no asignar un tamaño (numero de elementos), es imposible acceder a un elemento cualquiera.
Por lo tanto, arr[0] o arr[3] hasta ahora no existen. Para efectivamente asignar un tamaño leemos por teclado un número y se realiza la inicialización.

Ej :

Leer por teclado --> numEntradas
arr = new String[numEntradas];

*nota : al igual que otras alternativas de inicialización de arreglos, se puede crear el arreglo en un sólo paso. La siguientes instrucciones muestran como crear un arreglo de longitud numEntradas, para tipos de datos int, double y String.

int arrEnteros[ ] = new int[numEntradas];

double arrReales[ ] = new double[numEntradas];

String arrStr[ ] = new String[numEntradas]; 

Llenar el arreglo de String

Para asignar a cada posición del arreglo arr de tipo String, un valor válido ingresado por teclado, ocupamos el método realLine() de la clase BufferedReader, de la siguiente manera :

BufferedReader in = new BufferedReader( new InputStreamReader(System.in) );
:
:
for(i = 0; i < arr.length; i++)
{
    System.out.print("Ingrese string " + (i + 1) + " : ");
    arr[i] = in.readLine( );
}

Una vez ejecutado el ciclo y suponiendo que se creo un arreglo de 5 elementos se tiene el siguiente diagrama :

Estructura de la clase

La clase que se está creando, va a consistir en un método main, junto a los métodos : imprimir , ordenar , buscar y contar, especificados en la primera parte del enunciado del ejercicio.

Por lo tanto la estructura de esta clase sería la siguiente :

import java.io.*;

class ejercicio
{
 
    public static void imprimir(String a[ ]) { }

    public static void ordenar(String a[ ]) { }
    
    public static int buscar(String str, String a[ ]) { }
    
    public static int contar(String a[ ], char c) { }

    public static void main(String arg[ ]) throws IOException { }

}

Implementación de métodos

1.- Método imprimir

Para imprimir, se recibe como parámetro un arreglo de String, para recorrer con un coclo for desde la posición 0 hasta a.length - 1. Además, se imprime la palabra "Arreglo" y luego se subraya. Por lo tanto con el ciclo, imprimimos cada arreglo almacenado en a[i].

public static void imprimir(String a[ ])
    {
        System.out.println("\nArreglo");
        System.out.println("-------");
        for(int i = 0; i < a.length; i++)
        {
            System.out.println(a[i]);    
        }    
    }

2.- Método ordenar

Para ordenar el arreglo, se usará el algoritmo de la burbuja que consiste en ir comparando el elemento i e i + 1 del arreglo,para ordenar en forma ascendente.
Si se encuentra que a[i] es mayor que a[i+1], se intercambian dichos elementos.

public static void ordenar(String a[ ])
    {
        String tmp;
        for(int k = 0; k < a.length; k++)
            for(int i = 0; i < a.length - 1; i++)
            {
                if ( a[i].compareTo(a[i+1]) > 0)
                {
                    tmp = a[i];
                    a[i] = a[i+1];
                    a[i+1] = tmp;    
                }
            }
    }
    

Por ejemplo, al ejecutar el ciclo for(i = 0 ...) se encuentra que hay que cambiar de posición los elementos "Peru" y "Bolivia". Para realizar este cambio, se lleva a cabo las tres instrucciones que muestra el diagrama.

Ahora bien, además se tiene que aplicar el ciclo for, tantas veces como elementos tenga el arreglo, ya que en el peor caso los elementos podrían estar ordenados en forma descendente. Es para eso que se implementa el ciclo for con el índice k.

En el siguiente diagrama, se muestra el estado del arreglo, y los valores de los índices i y k.

Para comparar strings (lexicográficamente) no se puede usar el operador de igualdad ==. Para comparar dos strings se ocupa el método int compareTo(String str) de la clase String de la siguiente manera :

Sean a y b objetos de tipo String.

La instrucción : a.compareTo(b)

1) retorna un valor menor que cero si a es menor que b
2) retorna un valor mayor que cero si a es mayor que b
3) retorna 0 (cero) si b es igual que a

3.- Método buscar

Recorre el arreglo, comparando el string pasado como parámetro con cada a[i]. Inicializa una variable p en -1, asumiendo que el string no se va a encontrar. Si durante el ciclo se encuentra, se asigna a p la posición correspondiente (i) y se ejecuta la instrucción break para no seguir buscando.

public static int buscar(String str, String a[ ])
    {
        int i;
        int pos = -1;  /* asume que no lo encuentra */
        for(i = 0; i < a.length; i++)
        {
            if ( str.compareTo(a[i]) == 0)
            {
                pos = i;    
                break;
            }    
        }
        
        return pos;
    }
    

4.- Método contar

El método char charAt(int indice) de la clase String, retorna el
caracter ( de tipo char) i-ésimo de un string.

String temp = "DEA"
temp.charAt(0) --> 'D'
temp.charAt(1) --> 'E'
temp.charAt(2) --> 'A'
temp.length( ) --> 3  (número de caracteres)

Para recorrer el string caracter por caracter se usa :
 
for(i = 0; i < temp.length( ) ; i++ )



Realizando la comparación (temp.charAt(i) == c) se va verificando si se cumple la condición.
 
Si esto ocurre,el contador cont se incrementa en 1. 
Ahora, como hay que recorrer todo el arreglo en busca del caracter, se recorre
el arreglo con un ciclo for(k = 0...), y dentro de este ciclo, se asigna a temp, el valor de a[k].   



public static int contar(String a[ ], char c)
    {
        int k,i;
        int cont = 0;
        String temp;
        for(k = 0; k < a.length; k++)
        {    
            temp = a[k];  /* string k-esimo */
            for(i = 0; i < temp.length( ); i++)    
                if ( temp.charAt(i) == c) cont++;
        }
        return cont;
    }



Idea del programa

import java.io.*;

class ArregloString
{
    public static void main(String arg[ ]) throws IOException
    {
        
        CREAR VARIABLES
        LEER NUMERO DE ELEMENTOS A INGRESAR
        CREAR EL ARREGLO
        LEER ARREGLO DE STRING
        
        LLAMAR A LOS METODOS :
        
        imprimir(arr);
        
        ordenar(arr);
        
        imprimir(arr);
        
        String s;
        
        LEER STRING s
        
        LLAMAR AL METODO BUSCAR
        
        char letra;
        
        IMPRIMIR "Ingrese caracter a contar : "
        s = in.readLine( );
        letra = s.charAt(0);
        
        LLAMAR AL METODO CONTAR
        MOSTRAR RESULTADO EN PANTALLA        
    }
}