programa Java lea palabras guarde en arreglo ordenar alfabéticamente y mostrar

[nikiton]

Hola, solicito ayuda con este ejercicio, he avanzado en lo más simple pero en el ultimo punto no logro hacerlo, de antemano muchas gracias

<<Crear un programa que lea 10 palabras y las guarde en un arreglo. Se debe
mostrar las palabras ingresadas, ordenarlas en orden alfabético y luego volver a mostrar.>>

Código: [Seleccionar]

public class Ejercicio1 {

public static void main(String[] args) {
String palabra;
Scanner leer=new Scanner(System.in);
String array[]=new String[10];

System.out.println("Introduzca 10 palabras:");

for(int i=0; i<=9; i++) {
palabra=leer.nextLine();
array[i]=palabra;
}
System.out.println("Las palabras ingresadas fueron: \n" + Arrays.toString(array));

}
}

y el segundo ejercicio es este el cual nuevamente no logro completar la ultima funcion, el ejercicio recomienda hacer con hashmap pero a mi se me ha hecho mas facil con array

crear un programa que tenga el siguiente menú:
Opción ingresar ciudad: Lee el nombre y temperatura de la ciudad y lo guarda en un
HashMap.
Opción mostrar ciudades: Muestra las ciudades ingresadas. Si no hay ciudades ingresadas
muestra un mensaje.
Opción limpiar nombre: saca un símbolo ($, &, @, etc.) en nombre que se haya incluido
accidentalmente. Se debe leer el símbolo.
Opción salir: Sale del programa.

Código: [Seleccionar]

public class Ejercicio3 {

public static void main(String[] args) {

Scanner leer=new Scanner(System.in);
ArrayList<Double> temperaturas=new ArrayList<Double>();
ArrayList<String> ciudades=new ArrayList<String>();
double temp;
String ciudad;
int opcion,op,indice;
try {
do {
System.out.print("\nMenú\n");
System.out.print("****");
System.out.print("\n 1. Ingresar ciudad ");
System.out.print("\n 2. Mostrar ciudad");
System.out.print("\n 3. Limpiar ciudad");
System.out.print("\n 4. Salir");
System.out.print("\nIndicar opción: ");

opcion=leer.nextInt();

switch(opcion) {
case 1:
System.out.print("\nIngresar Ciudad: ");
ciudad=leer.next();
ciudades.add(ciudad);
System.out.print("\nIngresar temp: ");
temp=leer.nextDouble();
temperaturas.add(temp);
break;
case 2:
Iterator<Double> it=temperaturas.iterator();
Iterator<String> it2=ciudades.iterator();
System.out.print("\nCiudades ingresadas");
while(it.hasNext()) {
System.out.print("\n"+it2.next()+"\t"+it.next());
}
break;

case 3://limpiar



case 4:
System.exit(0);
break;
default:
System.out.print("\nOpción no válida\n");
}

}while(opcion != 4);
}catch(InputMismatchException e) {
System.out.print("\nError");
}

}

}

[Kabuto]

crear un programa que lea 10 palabras y las guarde en un arreglo. Se debe
mostrar las palabras ingresadas, ordenarlas en orden alfabético y luego volver a mostrar.

Hola, primero decir que la clase Arrays tiene un método llamado sort() que ordena arrays.
Pero claro, aquí lo interesante es que lo hagamos nosotros y no que Java nos lo de ya hecho.


Para ordenar un array de String necesitamos dos cosas:
- un algoritmo de ordenación.
- saber cómo comparar Strings

Algoritmo de ordenación..., hay varios, el más famosete y el primero que se suele enseñar, es el "método de la burbuja".
Consiste en recorrer el array con dos bucles anidados un número determinado de veces y comparar cada elemento con el siguiente. Si el elemento siguiente es menor (si queremos ordenar de menor a mayor) al elemento actual, se intercambian sus posiciones y se continua con los elementos siguientes.
De este modo, los elementos menores van "subiendo" por la lista hasta ponerse los primeros. Por eso le llaman "burbuja", porque las burbujas suben...
Sí, los informáticos no son muy buenos con las metáforas... 

Como digo, es el más famoso y sencillo, pero también el menos eficiente. Porque como dije antes el proceso se repite un número determinado de veces. Aunque el array ya esté correctamente ordenado, el proceso seguirá haciendo comparaciones innecesarias hasta que los ciclos de los bucles terminen.

Pero bueno, para un array de 10 elementos como es este caso, nos basta y nos sobra.


Ya tendríamos método de ordenación Ahora, ¿cómo comparamos Strings?

Para ordenar alfabéticamente habría que poner primero las que empiecen por a, luego b, luego c, etc....

Y de entre todas las que empiezan por a, primero irían las que su segunda letra también es a, luego las que la segunda letra es b, etc...

Y luego habría que ver la tercera letra, la cuarta, la quinta..., tener en cuenta que no todas las palabras tienen el mismo número de letras...

Sí, es complicado. Pero no temas, no vas a tener que desarrollar un algoritmo que haga todo eso (aunque si te hace ilusión, adelante...  ).

Esta vez sí vamos a dejar que Java lo haga por nosotros.

TODAS las clases escritas en Java, y cuando digo TODAS, incluyo también a las que algún día escribirás tu también cuando te enseñen Programación Orientada a Objetos (POO), TODAS son y serán hijas de la clase Object, que es algo así como la superclase suprema en Java.

Esto implica que todas las clases heredan ciertos métodos comúnes que todas van a tener.

Uno de estos métodos, es el llamado compareTo(), que está destinado a que un objeto pueda compararse con otro, para determinar si son iguales o si uno es mayor que el otro o viceversa.
Este método es para que el programador le incluya un código acorde a sus clases.
Si un programador crea una clase llamada Persona, podrá alterar este método y decidir como han de compararse sus objetos Persona, si en función de la edad, o de su altura, o de su peso, o de las letras de su apellido... o de lo que el programador crea oportuno.


La clase String ya tiene este método escrito y listo para que lo usemos.
Tan solo hay que invocarlo y saber interpretar los resultados que da.

El compareTo() retorna un valor int que nos indica cuál es mayor o menor.
Si este int tiene valor 0, es que los dos String son iguales.
Si el int es un valor negativo, es decir, es menor que 0, significa que el primer elemento es menor que el segundo.
Si fuera un valor mayor que 0, entonces el primer elemento es mayor.

Un pequeño ejemplo.
Aclarar que si una palabra es "menor" que la otra, significa que la primera palabra va delante de la otra si ordenamos alfabéticamente.

String palabra1 = "Hola";
String palabra2 = "Adios";

int comparar = palabra1.compareTo(palabra2);

if (comparar == 0)
    System.out.println("Las dos palabras son iguales");
else if (comparar < 0)
    System.out.println("Palabra1 es menor que Palabra2");
else
    System.out.println("Palabra1 es mayor que Palabra2");

Bueno, pues ahora ya tenemos método de ordenación, y también un método de comparación
Y se puede completar el ejercicio.

Disculpa si me ando mucho por las ramas con tanta explicación. Pero creo importante no solo darte el código de la solución. Si no explicar por qué funciona, y cómo funciona, y de donde sale...

Porque muchos estudiantes conocen el compareTo(), pero no saben de donde sale y por qué.., y piensan que es un método mágico que les va a servir para comparar cualquier cosa. Y no es así.
Los String los compara porque alguien ya le ha escrito un código.
El resto de clases, si nosotros no le escribimos un código, no va a saber comparar nada...


En fin, aquí te pongo la solución.
Los bucles de ordenación parecen un poco liosos, pero si te fijas básicamente lo que hace es comparar los elementos que son contiguos y si el que está detrás es menor, intercambia la posición con el otro para que quede delante.

Código: [Seleccionar]

public class OrdenaPalabras {

public static void main(String[] args) {
String palabra;
Scanner leer=new Scanner(System.in);
String array[]=new String[10];

System.out.println("Introduzca 10 palabras:");

for(int i=0; i<=9; i++) {
palabra=leer.nextLine();
array[i]=palabra;
}
leer.close();

System.out.println("Las palabras ingresadas fueron: \n" + Arrays.toString(array));

//Ordenar array, usando método burbuja y compareTo()
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array.length - 1; j++) {
if (array[j + 1].compareTo(array[j]) < 0) {
//Elemento que está detrás es menor, intercambiamos posiciones
String aux = array[j + 1];
array[j + 1] = array[j];
array[j] = aux;
}
}
}

System.out.println("Las palabras ordenadas son: \n" + Arrays.toString(array));

}
}

[Kabuto]

Respecto al segundo ejercicio.

Sí, con HashMap es un poquito más complicado.
Sobre todo a la hora de iterar en los elementos que contiene. Pero tampoco es tan difícil y supongo que la intención del ejercicio es precisamente familiarizarse con los HashMap.

Cada entrada del HashMap consta de dos datos, la clave "key" y el valor "value" que asociamos a esa clave.

En este caso, el nombre de la ciudad sería la clave y la temperatura sería el valor.

Como un HashMap no es una lista como los ArrayList, luego para recorrer y mostrar todas las entradas es un poco más engorroso.
En una lista, las cosas van una detrás de la otra, recorrerlas es sencilla. Empiezas por la primera y acabas por la última.

Un HashMap, como todos los Map, son un "conjunto". No hay un orden, las cosas no están delante o detrás de las demás, no hay una primera o una última, las posiciones ordinales no son aplicables.

Como verás en mi código, aún así podemos obtener un iterador, pero el código es más feo porque hay que pedirle al HashMap que nos devuelva un Set con las entradas, y que este Set nos de un iterador.
Y al iterador hay que decirle que el tipo de dato a iterar, son las Entradas de un Set de un HashMap, compuesto de un String y un Double....
La lógica es la misma, pero las instrucciones un poco más complicadas.

Eso en cuanto a listar la ciudades, registradas.


Sobre limpiar el nombre de una ciudad...
Lo ideal es hacer un método separado que se encargue específicamente de esta tarea, de eliminar de un String el símbolo indicado.

Primero he hecho un método que usaba el split() de la case String.
Así, "cortando" allá donde esté el símbolo (porque el símbolo puede estar repetido varias veces dentro del String) obtendría el String separdo en trocitos, ya sin restos del símbolo a retirar.

Luego solo habría que volver a juntar esos trocitos en un único String y retornarlo.

Este método funciona, pero he descubierto que da problemas con algunos símbolos.
Y es porque el método split() internamente usa expresiones regulares para encontrar el símbolo donde debe cortar.
Este tipo de expresiones usan algunos "metacaracteres" para encontrar patrones que coincidan con lo que busca, caracteres como:  *, ? , +,...

Entonces, si resulta que el símbolo coincide con uno de esos metacaracteres, el algoritmo no sabe como actuar en ese caso y lanza una excepción.

Así que he escrito un segundo método, usando subString() para separar la cadena en dos partes eliminando el símbolo y luego juntando esas dos partes otra vez.
Como este proceso solo permite eliminar un símbolo, y repito que puede ocurrir que una palabra tenga el símbolo a retirar varias veces repetido, pues lo que retorna cuando ha limpiado un símbolo es una llamada recursiva a sí mismo, pasando de nuevo el símbolo y la palabra que ha limpiado.

Así esta llamada recursiva se repite hasta que el método detecta que ya no queda ningún símbolo a retirar.


Una vez limpia la palabra, para modificar la entrada del HashMapa, como estamos modificando el nombre de la ciudad, y el nombre es la clave de la entrada, no se puede modificar (según creo...)
Así que lo que hago es guardar la temperatura, eliminar la entrada "vieja" y volver a crearla con el nombre ya limpio y la temperatura guardada.

Aquí dejo el código, pregunta lo que no entiendas. Un saludo.

Código: [Seleccionar]

public class CiudadesTemp {

public static void main(String[] args) {

HashMap<String, Double> datosCiudades = new HashMap<String, Double>();
Scanner teclado = new Scanner(System.in);
int opcion = 0;

do {
System.out.print("\nMenú\n");
System.out.print("****");
System.out.print("\n 1. Ingresar ciudad ");
System.out.print("\n 2. Mostrar ciudades");
System.out.print("\n 3. Limpiar ciudad");
System.out.print("\n 4. Salir");
System.out.print("\nIndicar opción: ");
opcion = Integer.parseInt(teclado.nextLine());
switch(opcion) {
case 1:
System.out.println("\nCiudad: ");
String ciudad = teclado.nextLine();
System.out.println("Temperatura: ");
double temp = Double.parseDouble(teclado.nextLine());
datosCiudades.put(ciudad, temp);
break;
case 2:
if (datosCiudades.isEmpty())
System.out.println("Aún no hay datos de ciudades");
else {
System.out.println("\nDATOS CIUDADES");
System.out.println("----- --------\n");
Iterator<HashMap.Entry<String, Double>> datos = datosCiudades.entrySet().iterator();
while(datos.hasNext()) {
HashMap.Entry<String, Double> dato = datos.next();
System.out.println("Ciudad: " + dato.getKey() + " -- Temperatura: " + dato.getValue());
}
}
break;
case 3:
System.out.println("\nLIMPIAR NOMBRE");
System.out.println("------- ------\n");
System.out.print("Nombre ciudad a limpiar: ");
String nombre = teclado.nextLine();
System.out.println("Símbolo a retirar: ");
String simbolo = teclado.nextLine();

if (datosCiudades.containsKey(nombre)) {
/*
* El nombre es una clave del HashMap.
* No se puede alterar, podemos guardar
* valor temperatura, eliminar la entrada
* con la clave "sucia", y hacer una nueva
* entrada con la clave "limpia"
*/
//Guardamos el valor de la temperatura
double valorTemp = datosCiudades.get(nombre);
//Eliminamos la entrada
datosCiudades.remove(nombre);
//Limpiamos nombre
String limpio = limpiarPalabra(nombre, simbolo);
//Nueva entrada con nombre limpio
datosCiudades.put(limpio, valorTemp);
}
else {
System.out.println("\nNo se ha encontrado ese nombre en la lista.");
System.out.println("Escríbalo incluyendo el símbolo equivocado.");
}
break;
case 4:
System.out.println("\nFIN DE PROGRAMA");
break;
default:
System.out.println("Opción equivocada");
}

}while(opcion != 4);

teclado.close();
}

private static String limpiarPalabra(String palabra, String simbolo) {

//Buscamos indice donde se encuentra el simbolo
int indice = palabra.indexOf(simbolo);

if (indice == -1) //No contiene símbolo, retornamos la misma palabra sin tocarla
return palabra;
else {
//Dividimos la palabra en dos partes, sin incluir el simbolo a retirar
//Parte1, desde primer caracter hasta donde esta el símbolo, excluyendolo
String parte1 = palabra.substring(0, indice);
//Parte2, desde caracter despues de símbolo, hasta el final
String parte2 = palabra.substring(indice+1);
//Juntamos dos partes
String nuevaPalabra = parte1.concat(parte2);

/*
* Solo hemos retirado un símbolo, podría haber más repeticiones
* del mismo símbolo en la palabra.
* Así que retornamos una llamada recursiva a este método.
* Esta recursividad se repetirá hasta que la palabra quede libre de símbolos
*/
return limpiarPalabra(nuevaPalabra, simbolo);
}


}

private static String limpiarPalabraNoUsar(String palabra, String simbolo) {

/*
* ATENCION: Este método produce excepcion si se usan
* determinados símbolos como asterisco --> *
* Se debe a que el método split() se vale de Espresiones Regulares (clase Pattern)
* para detectar el caracter que buscamos. Y Pattern
* usa algunos "metacaracteres" para detectar patrones en el String,
* por ejemplo, el asterisco o el signo de interrogación.
* Entonces, si el patrón a buscar coincide precisamente con uno de estos metacaracteres,
* la clase Pattern no sabe distinguir una cosa de la otra y lanza una excepción. 
*/


//Comprobamos que la palabra realmente contiene el símbolo
if (palabra.contains(simbolo)) {

/*
* La palabra puede contener el símbolo, una o varias veces.
* No importa, la dividimos en "trocitos" usando el símbolo
* como la posicion/es donde hay que "cortar"
*/
String[] trocitos = palabra.split(simbolo);
/*
* Tenemos los trocitos de palabra separados, ya sin símbolo.
* Hay que juntarlos otra vez y retornaremos la palabra "limpia"
*/
String limpia = "";
for (String trocito: trocitos)
limpia = limpia + trocito;

return limpia;
}
else //No contiene símbolo, retornamos la misma palabra sin tocarla
return palabra;
}

}

[nikiton]

hola muchas gracias, la verdad es que tu codigo se entiende muy bien

Hola, primero decir que la clase Arrays tiene un método llamado sort() que ordena arrays.

La verdad es que no tenia ni idea, cada dia se aprende algo nuevo,y obviamente la idea es complicarse la vida
De verdad te agradezco que me expliques todo me ayuda mucho a aprender como haces el codigo.

[Kabuto]

Hola, primero decir que la clase Arrays tiene un método llamado sort() que ordena arrays.

La verdad es que no tenia ni idea, cada dia se aprende algo nuevo,y obviamente la idea es complicarse la vida

Es conveniente familiarizarse y visitar de vez en cuando la documentación de Java.
Si buscas en Google por "Arrays Java", uno de los primeros resultados es la documentación de Oracle, enlazando la clase Arrays.
Ahí se detallan todos los métodos disponibles, y puedes ver que el método sort() tiene muchas "sobrecargas".
"Sobrecarga" es que un mismo método, cuenta con una serie de variantes según los datos que le pasemos por parámetros.
Se le puede pasar solo el array a ordenar, o el array más dos enteros para especificar que solo ordene desde una posición concreta del array hasta otra posición, o el array y un objeto Comparator para especificar cómo se han de ordenar...

Al principio la docu resulta un poco confusa, y encima está en inglés.., pero cuando te habitúas a ella resulta útil y como mínimo, te sirve para descubrir métodos ya existentes.
Luego ya puedes buscar en la red ejemplos de como usar dichos métodos.


Aclarar por último, que el método Arrays.sort() admite arrays de cualquier tipo y clase. Pero estas clases han de tener el método compareTo() sobrescrito de manera que indique cómo se han de comparar los objetos de dicha clase.
Como dije, en algún momento empezarás a escribir tus propias clases, y si quieres que se puedan ordenar/comparar, serás tú quien tendrá que escribir el código para establecer las reglas de ordenación

Clase Persona, ¿se ordenan por edad, por peso, por nombre... o por todos esos atributos?
Clase Factura, ¿se ordenan por número de factura, por fecha, por importe... o por todos esos atributos?
Clase Coche, ¿se ordenan por matrícula, por número de bastidor, por fecha fabricación.. o por todos esos atributos?

Esto lo decide y codifica el programador mediante compareTo().

Pero bueno, todo esto lo menciono para que te suene cuando llegues a estos temas, ahora  no es importante.