[Java] Interfaccia Map

[Snakethesniper]

Devo creare un programma che visualizzi l'occorrenza delle parole inserite, per farlo devo utilizzare l'interfaccia Map, ma non capisco bene come funziona. Per poterla utilizzare devo utilizzare una delle classi concrete che la implementi.
Il codice che ho scritto è:

import java.lang.*;
import java.io.*;
import java.util.*;

public class Soluzione5{
	public static void main(String[] args) throws IOException{
	BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
	HashMap map = new HashMap();
	String input;
	String[] nomi = new String[21];
	int i=0;
	while((input=in.readLine()) != null){
		nomi[i]=input;
		i++;
		}
	String[] nomie = new String[i];
	for(int j=0;j<i;j++){
		nomie[i]=nomi[i];
		}
	Arrays.sort(nomie);
	int j=0;
	int c=0;
	int k;
	while(j<i){
		for(k=j+1;k<i;k++){
			if(nomie[i].equals(nomie[j])){
				c+=1;
				}
			j=c;
			}
		map.put(nomie[i],c);
		}
	}
	}

Solo che in fase di compilazione mi segnala un warning sul map.put(nomie[i],c). Qualcuno sa aiutarmi?

[banryu79]

E' un warning perchè stai usando Map come "raw type" invece di parametrizarlo con un tipo.
Se guardi nei javadoc la definiizione di Map vedrai che essa e' una classe parametrica del tipo: Map<K,V> dove quel K e V sono dei parametri che indicano rispettivamente il tipo di "chiave" e il tipo di "valore" contenuti nella mappa.

Posto che il modo in cui stai usando la mappa va benissimo anche così (usare i Generics non è obbligatorio), puoi specificare i tipi della tua mappa in questo modo:

Map<String,Integer> map = new HashMap<String,Integer>();

Dato che la usi così:

...
map.put(nomie[counter], c);

dove nomie[counter] è una String e 'c' è un int (ed essendo int un tipo primitivo e non un tipo reference non può essere infilato in una Map, quindi viene wrappato in un Integer).

Ancora una cosa che ho notato, questo pezzo di codice:

...
String[] nomie = new String[i];
for(int j=0;j<i;j++){
    nomie[i]=nomi[i];
}
Arrays.sort(nomie);
...

Visto che già hai importato la classe java.util.Arrays per il sorting, perchè non sfruttarla anche per copiare l'array?

Potresti incapsulare queste due utilità (copia dell'array e sorting) in un metodo che, appunto, prende in ingresso un array di String e ne restituisce una copia ordinata:

private static String[] copyAndSort(String[] nomi)
{
    String[] copy = Arrays.copyOf(nomi, nomi.length);
    Arrays.sort(copy);
    return copy;
}

e quindi sostituire il pezzo di codice con la chiamata al metodo:

// crea 'nomie'
String[] nomie = copyAndSort(nomi);

Infine due note:
1) il ciclo che "consuma" il BufferedInput per popolare l'array 'nomi' procede finche' una invocazione di readLine non torna null.
Va bene, ma non quando come sorgente usi System.in perchè non si verificherà mai quel caso (System.in non "arriverà mai alla fine", semplicemente presa in ingresso una stringa, dopo l'ennesimo "invio" dell'utente rimane in attesa di un nuovo input).
Dovresti quindi aggiungere un controllo per terminare l'inserimento delle stringhe basato sul numero di stringhe inserite, pena un ArrayIndexOutOfBoundsException.
Oppure potresti leggere l'input da un file di testo.

2) il Sorting delle String viene fatto ordinando le String in maniera lessicografica, e l'odine finale forse non e' quello che ti aspetteresti, dato che, ad esempio, tutte le lettere maiuscole "vengono prima" di tutte le lettere minuscole nella tabella ascii.
Cioè risulterebbe che la stringa "Cane" verrebbe prima della stringa "ape", per esempio. Nel package java.text trovi una classe Collator che torna utile nel gestire questi aspetti e altri (anche più raffinati, tipo la gestione delle differenze dovute agli accenti, in modo specifico per un dato linguaggio naturale, ad esempio per quello Polacco), se mai ti servisse.

In alternativa, potresti prendere l'array di stringhe in input e renderle tutte lowercase o tutte uppercase, giusto per ovviare al problema delle maiuscole/minuscole (prima di "farlo a mano" ovviamente controlla se per caso non esiste qualche classe che già lo fa )