Foros aprenderaprogramar.com
Didáctica y divulgación de la programación

Necesito una ayuda para solucionar un problema con el Map:
lo he intentado de varias maneras y no doy con el método correcto, agradecería su ayuda;
Se usa una clase "Iterables2" para leer desde el archivo, usando sus métodos.
la clase Iterables2:
*******************************************************
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.Arrays;
import java.util.Iterator;
import java.util.NoSuchElementException;
import java.util.Scanner;

import com.google.common.base.CharMatcher;
import com.google.common.base.Splitter;
public class Iterables2 {
public static Iterable<String> from(String fileName) {
return new InputStreamSeq(fileName);
}
public static <T> Iterable<T> from(T[] array) {
return Arrays.asList(array);
}

/**
* Devuelve un Iterable&ltString&gt a partir de una cadena y unos
* delimitadores. Los delimitadores entran en forma de una String, en la que
* cada uno de los caracteres se considera un delimitador. El método elimina
* las cadenas vacías de la salida; elimina también los espacios en blanco
* delante y detrás de cada cadena devuelta.
*
* @param cadena
* @param delimitadores
* @return Iterable&ltString&gt
*/
public static Iterable<String> from(String cadena, String delimitadores) {
Splitter sp = Splitter.on(CharMatcher.anyOf(delimitadores));
sp.omitEmptyStrings().trimResults();
Iterable<String> it = sp.split(cadena);
return it;
}

/**
* Devuelve un Iterable&ltString&gt con las cadenas que se vayan
* introduciendo por el teclado terminadas con Enter, finalizando cuando se
* pulsa control+z. Las cadenas vacías no las devuelve en el momento: las
* devuelve todas juntas cuando se introduce una cadena no vacía.
*
* @return Iterable&ltString&gt
*/
public static Iterable<String> from() {
Iterable<String> it = new EntradaTeclado();
return it;
}

private static class EntradaTeclado implements Iterable<String> {
public EntradaTeclado() {
}

public Iterator<String> iterator() {
return new IteradorEntradaTeclado();
}

private class IteradorEntradaTeclado implements Iterator<String> {
private Scanner sc;

public IteradorEntradaTeclado() {
sc = new Scanner(System.in);
}

public boolean hasNext() {
return sc.hasNext();
}

public String next() {
String linea = sc.nextLine();
return linea;
}

public void remove() {
throw new UnsupportedOperationException();
}
}
}

private static class InputStreamSeq implements Iterable<String> {
private String nf;

public InputStreamSeq(String f) {
nf = f;
}

public Iterator<String> iterator() {
return new InputStreamIterator();
}

public String toString() {
String result = "[";

String item = "";
for (Iterator<String> it = this.iterator(); it.hasNext();) {
item = it.next();
if (it.hasNext())
result += item + ", ";
else
result += item + "";
}

result += "]";

return result;

}

private class InputStreamIterator implements Iterator<String> {
private BufferedReader bf;
private String line;

public InputStreamIterator() {
try {
bf = new BufferedReader(new FileReader(nf));
line = bf.readLine();
} catch (IOException e) {
throw new IllegalArgumentException(
"No se puede acceder al fichero de entrada");
}
}

public boolean hasNext() {
return line != null;
}

public String next() {
if (!hasNext())
throw new NoSuchElementException();
String pal = line;
try {
line = bf.readLine();
} catch (IOException e) {
throw new IllegalArgumentException(
"No se puede acceder al fichero de entrada");
}
return pal;
}
public void remove() {
throw new UnsupportedOperationException();
}
}
}
}

********************************************************************
y la clase principal es:
*******************************************************************
import com.google.common.collect.Ordering;

public class ClimaGroenlandiaImpl implements ClimaGroenlandia {
// TODO Apartado a
// Atributo:
private Map<String , List<Integer>> mapa, mapa1;
// El constructor crea el Map vacío
public ClimaGroenlandiaImpl(){
mapa = new HashMap<String , List<Integer>>();
mapa1 = new HashMap<String , List<Integer>>();
}
// TODO Apartado b
public void cargaFichero(String nombreFichero) {
// Creamos un Iterable<String> a partir del nombre de fichero con el
// método from con un argumento de Iterables2
// TODO
List<String> listaStr = new ArrayList<String>();
List<Integer> listaInt = new ArrayList<Integer>();
Iterable<String> lineas = Iterables2.from(nombreFichero);
// Iteramos sobre él
// TODO
for( String lineaEntera:lineas ){
Iterable<String> lineaPartida = Iterables2.from(lineaEntera, ",");
listaStr.clear();
listaInt.clear();
for( String elemLinea:lineaPartida ){
listaStr.add(elemLinea);
}//for segundo
String muni = listaStr.get(0);
listaStr.remove(0);
for( String s:listaStr ){
listaInt.add(Integer.parseInt(s));
}//for tercero
// System.out.println("Municipio: "+muni);
// System.out.println("lista de valores: "+listaInt);
//System.out.println("CARGANDO VALORES...........");

// mapa.put(muni, listaInt);
List<Integer> aux = new ArrayList<Integer>();
if( mapa.containsKey(muni) ){
// System.out.println("Ya existe el municipio......");
// aux.addAll(mapa.get(muni));
// System.out.println(muni+"------>"+aux);
// System.out.println(listaInt);
// aux.addAll(listaInt);
// mapa.put(muni, listaInt);
// System.out.println(mapa.get(muni));
}//if
else {
// System.out.println("Municipio Nuevo....");

mapa.put(muni, listaInt);
// System.out.println(mapa);
//mapa.get(muni).addAll(aux);
}//else
System.out.println(muni+" temperaturas: "+mapa.get(muni));
}//fin del for

System.out.println("===============================================");
Iterator it = mapa.entrySet().iterator();
while (it.hasNext()) {
Map.Entry e = (Map.Entry)it.next();
System.out.println(e.getKey() + " " + e.getValue());
}
// Cada String devuelta es una línea del fichero. Ahora hay que
//partirla.
//Usamos el from de dos argumentos de Iterables2
// TODO
    //Cada elemento de este Iterable<String> contiene cada uno de los
    //componentes de la línea. Ahora hay que trasformar el Iterable en
    //una lista.
    //Para ello, creamos una lista
// TODO

// Iteramos sobre los elementos de la línea añadiendo sus
// elementos a la lista
// TODO



// El municipio será el primer elemento
// TODO

// Ahora se transforman el resto de los elementos de la línea, que
// son temperaturas, en enteros, guardándolos en otra lista.
// TODO
// El método estático parteInt de la clase Integer devuelve el
// valor como entero de una String


// Se insertan las temperaturas en el map, asociándolas con el
// municipio. Comprobamos si el municipio existía o no:
// TODO

// El municipio ya existía; se añaden las temperaturas a las que
// ya había
// TODO
// El municipio no existía; se crea un nuevo par municipio -
// temperaturas
// TODO
// }//el primer for   //////////////////////////////////
}//fin del metodo
*******************************************************************
y el archivo de texto desde el que se lee es:
*********************************************************
Kujalleq,-12,-4,3,5,-20,-37
Qaasuitsup,-2,-14,3,4
Qeqqata,-19,-5,3,12,20,15,20,-34
Kujalleq,-26,-11,3,17,10,13,20,-31
Sermersooq,-42,-4,3,11,0,17,20,-14
Qaasuitsup,-19,-4,3,22,11,15,20,-23
Qeqqata,-33,-23,3,15,0,15,20,-40
Sermersooq,-40,-14,3,13,22,19,20,-50
*************************
Muchas gracias de antemano.