Leer desde un archivo y guardarlo en un Map con Java Guava framework

[abel]

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:
*******************************************************

Código: [Seleccionar]

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:
*******************************************************************

Código: [Seleccionar]

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:
*********************************************************

Código: [Seleccionar]

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.

[Alex Rodríguez]

He visto el post pero no tengo claro algunas cuestiones:

¿Dices que tienes un problema con el map pero cuál es el problema concreto que tienes?

Estás usando el Guava framework (com.google.common.base), ¿qué versión o desde dónde lo has descargado?

¿Qué versión de Java estás usando?

Y finalmente, si pudieras pegar el código usando el botón # del editor que te introduce las etiquetas [code ] [ /code] mejor, porque al pegar como texto aparecen algunos emoticonos y se pierde el código

Al usar el botón # el código aparecerá así:

Código: [Seleccionar]

Aquí el código
Saludos

[Alex Rodríguez]

Estoy intentando compilarlo y me encuentro dos problemas adicionales:

a) Se declara: public class ClimaGroenlandiaImpl implements ClimaGroenlandia pero creo que no has puesto el código de la clase ClimaGroenlandia

b) Indicas que hay una clase principal pero ¿dónde está el método principal public static void main (String [ ] args)  ...

Saludos

[abel]

Hola Alex, gracias por tu respuesta y tu interés.
Me bajé unos apuntes que se ve bastante completos, y estoy haciéndolos, vienen medio hechos y solo se deja vacío el concepto que en la teoría se esplica(en este caso tocaba el Map usando los iterables, una clase denominada "Iterables2" nos sirve de utilidad con sus métodos estáticos como
"from(String fileName)" para leer desde el archivo filename y devolver un iterable con las líneas de este filename.
y el el comentario de cada clase se explican los métodos.
Perdona se me ha escapado ahora te lo pongo todo para que lo puedas compilar
NOTA: me interesa completar el método "public void cargaFichero(String nombreFichero) " de la clase "ClimaGreonlandiaImpl", los códigos escritos son mis intentos, Me interesa que al leer el archivo, que si la ciudad no exista que me la crea en un Map<String ciudad, List<Integer> lista_temperaturas> con sus respectivas temperaturas,
Si la ciudad ya existe, añadir a la lista de temperaturas las temperaturas nuevas.
la clase Iterables2

Código: [Seleccionar]

package utils;

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();
}
}
}
}
la clase ClimaGreonlandiaImp

Código: [Seleccionar]

package groenlandia;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.SortedSet;
import java.util.TreeSet;

import types.ListType;
import utils.Iterables2;
import utils.Lists;

import com.google.common.collect.Ordering;

public class ClimaGroenlandiaImpl implements ClimaGroenlandia {
// TODO Apartado a
// Atributo:
private Map<String , List<Integer>> mapa;
// El constructor crea el Map vacío
public ClimaGroenlandiaImpl(){
mapa = 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

// TODO Apartado c
public Integer temperaturaMinima() {
Integer minima = null;
// Creamos un Ordering
// TODO
// Iteramos sobre todas las temperaturas, que son las listas del Map:
// TODO
// Encontramos el mínimo de cada lista
// TODO
// Y vemos si es el primero o si ha superado el menor encontrado
// hasta el momento
// TODO

return minima;
}

// TODO Apartado f
// public String municipioConMayorDiferenciaTemperaturas() {
// // TODO
// // Utilizando Ordering, sería:
// // Ordering<String> ordCmp = Ordering.from(cmp);
// // String municipioMaxDif = ordCmp.max(temperaturasMunicipios.keySet());
// return municipioMaxDif;
// }

// TODO Apartado g
// public SortedSet<String> municipiosBajo(Integer temp) {
// // Se crea el conjunto ordenado
// // TODO
// // Se itera sobre los municipios, que son las claves del Map
// // TODO
// // Se obtiene la lista de temperaturas correspondientes a cada
// // municipio
// // TODO
// // Y si su temperatura es menor que la dada, se añade al conjunto
// // ordenado de salida
// // TODO
// return ss;
// }
}
y la clase principal que aquí le llamamos TestGreonlandia

Código: [Seleccionar]

package test;

import groenlandia.ClimaGroenlandia;
import groenlandia.ClimaGroenlandiaImpl;

import java.io.File;


public class TestGroenlandia extends Test {
private static final String SEP = File.separator;
private static final String ARCHIVO_DATOS = "." + SEP + "res" + SEP
+ "registrosTemperaturas.txt";

public static void main(String[] args) {
ClimaGroenlandia ecg = new ClimaGroenlandiaImpl();
ecg.cargaFichero(ARCHIVO_DATOS);
mostrar("Temperatura mínima: " + ecg.temperaturaMinima());
// mostrar("Municipio con mayor diferencia de temperaturas: "
// + ecg.municipioConMayorDiferenciaTemperaturas());
// Integer tempMin = -35;
// mostrar("Municipios que han alcanzado menos de " + tempMin + " grados: "
// + ecg.municipiosBajo(tempMin));
}
}


[abel]

esto para que se pueda compilar:
La interface ClimaGreonlandia que se implementa en la clase ClimaGreonladiaImpl

Código: [Seleccionar]

package groenlandia;

import java.util.SortedSet;

public interface ClimaGroenlandia {
void cargaFichero(String nombreFichero);
Integer temperaturaMinima();
// String municipioConMayorDiferenciaTemperaturas();
// SortedSet<String> municipiosBajo(Integer temp);
}

[Alex Rodríguez]

Sigo teniendo problemas para compilar en concreto errores en:

a) public class TestGroenlandia extends Test ¿Cuál es la clase Test?

b) import types.ListType; ¿Cuál es la clase types?

c) import utils.Lists; ¿Cuál es la clase Lists?

[abel]

las otras clases se usan para otras preguntas por eso no la he incluido en la pregunta:
ahora te vuelvo a colgar las clases después de corregir y eliminar las clases que no nos hacen falta:
pero para que todo funcione correctamente debes incluir en el proyecto la librería Guava de google, descargala en la pagina web: http://code.google.com/p/guava-libraries/
 y dale a descargar guava-14.0.1 jar.
selecciona el proyecto y después dale al botón derecho del raton: propiedades java build path y después add external jar, seleccionas el archivo guava descargado y le das a ok.
las clases aquí, si le pone el mismo nombre del package en todas las clases debería funcionar:

Código: [Seleccionar]

package Hashmap;

import java.util.SortedSet;

public interface ClimaGroenlandia {
void cargaFichero(String nombreFichero);
Integer temperaturaMinima();
// String municipioConMayorDiferenciaTemperaturas();
// SortedSet<String> municipiosBajo(Integer temp);
}

Código: [Seleccionar]

package Hashmap;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.SortedSet;
import java.util.TreeSet;
import Hashmap.Iterables2;

import com.google.common.collect.Ordering;

public class ClimaGroenlandiaImpl implements ClimaGroenlandia {
// TODO Apartado a
// Atributo:
private Map<String , List<Integer>> mapa;
// El constructor crea el Map vacío
public ClimaGroenlandiaImpl(){
mapa = 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

// TODO Apartado c
public Integer temperaturaMinima() {
Integer minima = null;
// Creamos un Ordering
// TODO
// Iteramos sobre todas las temperaturas, que son las listas del Map:
// TODO
// Encontramos el mínimo de cada lista
// TODO
// Y vemos si es el primero o si ha superado el menor encontrado
// hasta el momento
// TODO

return minima;
}

// TODO Apartado f
// public String municipioConMayorDiferenciaTemperaturas() {
// // TODO
// // Utilizando Ordering, sería:
// // Ordering<String> ordCmp = Ordering.from(cmp);
// // String municipioMaxDif = ordCmp.max(temperaturasMunicipios.keySet());
// return municipioMaxDif;
// }

// TODO Apartado g
// public SortedSet<String> municipiosBajo(Integer temp) {
// // Se crea el conjunto ordenado
// // TODO
// // Se itera sobre los municipios, que son las claves del Map
// // TODO
// // Se obtiene la lista de temperaturas correspondientes a cada
// // municipio
// // TODO
// // Y si su temperatura es menor que la dada, se añade al conjunto
// // ordenado de salida
// // TODO
// return ss;
// }
}


Código: [Seleccionar]

package Hashmap;

public class Test {

public static <T> void mostrar(T objeto){
System.out.println(objeto.toString());
}

public static <T> void mostrar(String s, T objeto){
System.out.println(s + objeto.toString());
}

}

Código: [Seleccionar]

package Hashmap;

import Hashmap.ClimaGroenlandia;
import Hashmap.ClimaGroenlandiaImpl;

import java.io.File;


public class TestGroenlandia extends Test {
private static final String SEP = File.separator;
private static final String ARCHIVO_DATOS = "." + SEP + "res" + SEP
+ "registrosTemperaturas.txt";

public static void main(String[] args) {
ClimaGroenlandia ecg = new ClimaGroenlandiaImpl();
ecg.cargaFichero(ARCHIVO_DATOS);
mostrar("Temperatura mínima: " + ecg.temperaturaMinima());
// mostrar("Municipio con mayor diferencia de temperaturas: "
// + ecg.municipioConMayorDiferenciaTemperaturas());
// Integer tempMin = -35;
// mostrar("Municipios que han alcanzado menos de " + tempMin + " grados: "
// + ecg.municipiosBajo(tempMin));
}
}


Código: [Seleccionar]

package Hashmap;

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 finalmente en el mismo proyecto crear una carpeta con el archivo de texto:

Código: [Seleccionar]

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

[Alex Rodríguez]

Al fin he podido compilar. Lo que he visto te comento...

El HashMap mapa contiene los pares de valores ciudad (clave) y lista de enteros que representan las temperaturas tal y como vienen en los datos de entrada, sin ordenación adicional (valor u objeto asociado). Importante: si operas sobre la lista de enteros modificas el map, ambos contienen la misma referencia, más abajo te comento más.

lineas es un objeto Iterator que contiene cada una de las líneas del fichero de entrada

Veo que creas un objeto Iterable y luego usas for extendido (for each) para recorrer las colecciones de elementos. Esto no lo veo correcto, no digo que no se pueda hacer así sino que yo no lo haría así. En principio usar Iterable será para usar un iterador para recorrer la colección. Usar un iterador es una forma segura de recorrer una colección y poder manipular al mismo tiempo la colección sin alterar el recorrido de la misma. Un for extendido es una forma no segura de recorrido y se aplicaría en ciertos casos cuando es viable.

He modificado el código para basarme en el uso de iteradores. Además uso un contador para saber en qué línea me encuentro así como en qué elemento dentro de la línea. Si estamos en el elemento 1 de la línea ya sabemos que es la ciudad y a partir de ahí se puede determinar si aparece en el mapa (con containskey) o no.

Lo primero es determinar si la ciudad está en el mapa o no, ya que el tratamiento tendrá que ser distinto.

Una cuestión importante es que no podemos hacer un clear del objeto List que almacena los valores en el mapa porque si hacemos el clear borramos el contenido previo del mapa ¿Por qué? Porque el mapa contiene el objeto (la misma referencia que el list). Si borramos el list, dejamos vacío el contenido del mapa. Creo que esto quizás fuera uno de los errores que tuvieras en el anterior código, aunque tampoco lo he mirado con detenimiento.

Creo que el código que te pongo un poco más abajo resuelve lo que querías. Tiene líneas con impresión del proceso que se pueden borrar.

Compruébalo, ya me comentas cuando lo hayas revisado.

Saludos.

Código de la clase:

Código: [Seleccionar]

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.SortedSet;
import java.util.TreeSet;

import com.google.common.collect.Ordering;

public class ClimaGroenlandiaImpl implements ClimaGroenlandia {
    // TODO Apartado a
    // Atributo:
    private Map <String , List<Integer>> mapa;
    // El constructor crea el Map vacío
    public ClimaGroenlandiaImpl(){
        mapa = new HashMap <String , List<Integer>>();
    }
    // TODO Apartado b
    public void cargaFichero(String nombreFichero) {

        boolean ciudadEstaEnMapa = false; // AÑADIDO APR
        String keyParaElMap =""; //AÑADIDO APR

        // 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>();

        Iterable<String> lineas = Iterables2.from(nombreFichero);

        Iterator<String> iteradorLineasApr = lineas.iterator(); //iterador para obtener las líneas
        int i=1;
        while (iteradorLineasApr.hasNext()){

            //Tenemos que crear un nuevo objeto para evitar borrar contenidos previos del map
            List<Integer> listaInt = new ArrayList<Integer>();

            String lineaExtraida = iteradorLineasApr.next();

            System.out.println("Valor de línea " + i + ": " + lineaExtraida);

            Iterable<String> itemsEnUnaLinea = Iterables2.from(lineaExtraida, ",");
            Iterator<String> iteradorItemsEnUnaLineaApr = itemsEnUnaLinea.iterator(); //iterador para obtener cada item dentro de una línea

            int j=1;
            while (iteradorItemsEnUnaLineaApr.hasNext()){

                String itemExtraido = iteradorItemsEnUnaLineaApr.next();

                //Si es el primer item extraído es la ciudad, tenemos que comprobar si ya está en el map
                if (j==1) {
                    keyParaElMap = itemExtraido;
                    if (mapa.containsKey(itemExtraido)) {
                        System.out.println("La ciudad ESTÁ EN EL MAPA, habrá que actuar en consecuencia");
                        ciudadEstaEnMapa = true;
                        // System.out.println("Valor de keyParaElMap es" + keyParaElMap);
                        // System.out.println("Contenido del map "+ mapa.get (keyParaElMap).toString());
                    }
                    else {
                        System.out.println("La ciudad no está en el mapa, habrá que actuar en consecuencia");
                        ciudadEstaEnMapa = false;
                    }
                }

                System.out.println("Valor de item "+j+": "+ itemExtraido);
                if (j>1) {
                    listaInt.add(Integer.parseInt(itemExtraido));

                }

                j = j+1;
            } //FIN DEL BUCLE WHILE INTERNO RECORRIDO DE ITEMS

            //Una vez terminado el recorrido actuamos según la key esté en el map o no
            if (ciudadEstaEnMapa == true) {
                List<Integer> listaTmp = new ArrayList<Integer>(mapa.get (keyParaElMap));
                for( Integer enteroDeLista:listaInt ){
                    listaTmp.add(enteroDeLista);
                }
                mapa.put (keyParaElMap, listaTmp);

            }
            else {
                mapa.put (keyParaElMap, listaInt);

            }

            i = i+1;
        }

        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());
        }

    }//fin del metodo

    // TODO Apartado c
    public Integer temperaturaMinima() {
        Integer minima = null;
        // Creamos un Ordering
        // TODO
        // Iteramos sobre todas las temperaturas, que son las listas del Map:
        // TODO
        // Encontramos el mínimo de cada lista
        // TODO
        // Y vemos si es el primero o si ha superado el menor encontrado
        // hasta el momento
        // TODO

        return minima;
    }

    // TODO Apartado f
    // public String municipioConMayorDiferenciaTemperaturas() {
    // // TODO
    // // Utilizando Ordering, sería:
    // // Ordering<String> ordCmp = Ordering.from(cmp);
    // // String municipioMaxDif = ordCmp.max(temperaturasMunicipios.keySet());
    // return municipioMaxDif;
    // }

    // TODO Apartado g
    // public SortedSet<String> municipiosBajo(Integer temp) {
    // // Se crea el conjunto ordenado
    // // TODO
    // // Se itera sobre los municipios, que son las claves del Map
    // // TODO
    // // Se obtiene la lista de temperaturas correspondientes a cada
    // // municipio
    // // TODO
    // // Y si su temperatura es menor que la dada, se añade al conjunto
    // // ordenado de salida
    // // TODO
    // return ss;
    // }
}
Resultado obtenido al ejecutar:

Código: [Seleccionar]

===============================================
Sermersooq [-42, -4, 3, 11, 0, 17, 20, -14, -40, -14, 3, 13, 22, 19, 20, -50]
Qaasuitsup [-2, -14, 3, 4, -19, -4, 3, 22, 11, 15, 20, -23]
Kujalleq [-12, -4, 3, 5, -20, -37, -26, -11, 3, 17, 10, 13, 20, -31]
Qeqqata [-19, -5, 3, 12, 20, 15, 20, -34, -33, -23, 3, 15, 0, 15, 20, -40]
Temperatura mínima: null


[abel]

Hola Alex
Perdona el retraso, he estado de vacaciones y no tenia conexión ni a internet ni a mis proyectos.
Te cuento gracias a tu repuesta he podido modificar mi código y corregirlo, por lo que he viso en estos apuntes hay varias maneras de recorrer un agregado.
o mediante el for extendido (for each).
el for normal.
o mediante el while(){}.
Sería:

Código: [Seleccionar]

for(T elemento:agregado){mostrar(elemento);}
En el caso del for normal:

Código: [Seleccionar]

for(Iterator<T> it=agregado.iterator(); it.hasNext(); )
{T elemento = it.next();    mostrar(elemento);}
O con el while y sería algo así:

Código: [Seleccionar]

Iterator<T> it = agregado.iterator();
while(it.hasNext()){ mostrar( it.next() );   }
Me gustaría saber cuando es recomendable recorrer el agregado con alguno de estos métodos y cuando no, o seria lo mismo hacerlo con uno o con otro.
Ah y mas tarde colgaré una pregunta mas, relacionada con los Map.
De nuevo gracias por tu tiempo y tu paciencia.
Mi código corregido y funciona es este (si no te convencen los for each los cambiaré por while usando iterator() ):

Código: [Seleccionar]

public void cargaFichero(String nombreFichero) {
Iterable<String> lineas = Iterables2.from(nombreFichero);
for( String line:lineas ){
Iterable<String> elemLinea = Iterables2.from(line, ",");
List<Integer> listaInt = new ArrayList<Integer>();
List<String> listaStr = new ArrayList<String>();
for( String el:elemLinea ){
listaStr.add(el);
}//segundo for
String muni = listaStr.get(0);
listaStr.remove(0);

for( String s:listaStr ){
listaInt.add(Integer.parseInt(s));
}//for de conversion
if( mapa.containsKey(muni) ){
List<Integer> listaTmp = new ArrayList<Integer>(mapa.get(muni));
listaTmp.addAll(listaInt);
mapa.put(muni, listaTmp);
}//if
else{
mapa.put(muni, listaInt);
}//else
}//el primer for
Iterator it = mapa.entrySet().iterator();
while(it.hasNext()){
Map.Entry e = (Map.Entry) it.next();
System.out.println(e.getKey()+"  "+e.getValue());
}//while

[Alex Rodríguez]

¿Qué tal? Ya me extrañaba que no hubieras respondido. Efectivamente hay varias maneras de recorrer una colección en Java. Mi opinión es la siguiente: usar el for extendido cuando se trate de hacer un recorrido en el que no se va a manipular la colección, por ejemplo si simplemente quieres mostrar el contenido por pantalla puedes usar un for extendido. Usar el while con iterator cuando se quiera hacer un recorrido en el que al mismo tiempo se vaya a operar sobre la colección, por ejemplo cambiar un valor por otro si se detecta determinada circunstancia.
Hay cosas en tu código como:

for( String el:elemLinea ){
               listaStr.add(el);
         }//segundo for

que yo no haría así, lo cual no quiere decir que no se pueda hacer así. Fíjate que estás extrayendo el en cada pasada y estás añadiendo el a una colección. En cierto modo estás operando con el, aunque en este caso no va a tener efectos colaterales en otros sí los puede tener, por eso prefiero el iterator.

El iterator hace una copia de la colección para efectuar el recorrido. El recorrido se basa en la copia, por eso puedes manipular la colección sin alterar el transcurrir del recorrido.

El uso del for con iterator si te digo la verdad no lo uso, es una construcción un tanto extraña aunque para gustos colores.

[abel]

Ok a partir de ahora lo aplicaré a mis ejercicios:
Tengo otra duda que me tiene loco haber si podrías ayudarme, el mismo proyecto pero mas adelante me pide calcular cual es el municipio con mayor diferencia temperaturas(diferencia=maxTemperatura-minTemperatura);
se me pide implementar comparator en una clase aparte para comparar entre las diferenciasMax de los municipios del Map, hasta ahí llego pero me pide poner un constructor en esta ultima clase(algo que no había hecho hasta el momento, "poner un constructor" en la clase que me compara las diferenciasMax, y que está implemente comparator), ah hay que usar una clase auxiliar con un método static para caluclar dicha diferencia:
Espero no ser pesado con mis preguntas y te agradecería tu atenta ayuda:

Código: [Seleccionar]

Queremos saber cuál es el municipio donde se registró la mayor diferencia entre las temperaturas máxima y mínima. Para ello:
d) implemente el método estático diferenciaMaxima en la clase ClimaUtiles tal que reciba un String representando un municipio y el Map y devuelva la diferencia entre las temperaturas máxima y mínima de ese municipio. Si necesita encontrar máximos o mínimos, utilice la clase Ordering.
e) Usando la función anterior implemente un Comparator ComparadorTemperaturas para comparar dos municipios (identificados por sus nombres) por su diferencia de temperaturas. Esta clase debe recibir en el constructor el Map del apartado a).
f) Use el comparador anterior para escribir el método String municipioConMayorDiferenciaTemperaturas() que dé respuesta a la pregunta inicial. Utilice el método max de la clase Collections para encontrar el máximo: si tiene un solo argumento (que será de tipo Collection) devuelve el máximo de la colección usando el orden natural. Si recibe dos argumentos, el primero será una colección y el segundo un comparador; en este caso devuelve el máximo de la colección según el criterio establecido por el comparador. Si hubiera más de un municipio con la misma diferencia máxima el método devolverá una cualquiera de ellas.la clase que implementa Comparator sin acabar es:

Código: [Seleccionar]

package groenlandia;

import java.util.Comparator;
import java.util.List;
import java.util.Map;

// TODO Apartado e
public class ComparadorTemperaturas implements Comparator<String> {
// Atributo
// TODO

// El constructor debe recibir, y almacenar en el atributo, el Map con los
// municipios y las temperaturas
// TODO

public int compare(String municipio1, String municipio2) {
// TODO
}
}
La clase auxiliar con el método estatico y calcula la diferencia sería así:

Código: [Seleccionar]

package groenlandia;

import java.util.List;
import java.util.Map;
import java.util.NoSuchElementException;

import com.google.common.collect.Ordering;

public class ClimaUtiles {
// TODO Apartado d
public static Integer diferenciaMaxima(String municipio, Map<String, List<Integer>> temperaturas) {
// Comprobamos si existe el municipio
// TODO
Integer diferencia = null;
if(temperaturas.containsKey(municipio)){
// Creamos un Ordering
// TODO
Ordering<Integer> OrdenUsingMinMax = Ordering.natural();
// Obtenemos los registros de temperaturas del municipio
// TODO
Integer minima = OrdenUsingMinMax.min(temperaturas.get(municipio));
Integer maxima = OrdenUsingMinMax.max(temperaturas.get(municipio));
// Calculamos la diferencia entre la temperatura máxima y la mínima
// TODO
diferencia = maxima - minima;
}
return diferencia;
}
}Y la clase principal queda siendo la misma que la anterior, Gracias de antemano.

[Alex Rodríguez]

He intentado hacer una prueba para comprobar que la clase ClimaUtiles funcione usando este código:

Código: [Seleccionar]

import java.util.Map;
import java.util.List;
import java.io.File;


public class TestGroenlandia extends Test {
private static final String SEP = File.separator;
//private static final String ARCHIVO_DATOS = "." + SEP + "res" + SEP + "registrosTemperaturas.txt";
      private static final String ARCHIVO_DATOS = "registrosTemperaturas.txt";


public static void main(String[] args) {
ClimaGroenlandiaImpl ecg = new ClimaGroenlandiaImpl();
ecg.cargaFichero(ARCHIVO_DATOS);
mostrar("Temperatura mínima: " + ecg.temperaturaMinima());

ClimaUtiles prueba = new ClimaUtiles();
Map <String , List<Integer>> pruebaMapa = ecg.getMap();
System.out.println ("La diferencia máxima en Kujalleq es: "+ prueba.diferenciaMaxima("Kujalleq", pruebaMapa));

}
}

Taqmbién hace falta en la clase ClimaGroenlandiaImpl añadir este método:

Código: [Seleccionar]

public Map <String , List<Integer>> getMap() {return mapa;}

Todo compila pero me salta un error que no me deja continuar enla clase ClimaUtiles, en la línea:

Ordering<Integer> OrdenUsingMinMax = Ordering.natural();

indica "Caused by: java.lang.ClassNotFoundException: com.google.common.collect.ReverseOrdering
"

Ahora mismo no sé si es un error en guava, un error tuyo al plantear el código o que se me está escapando algo, haz tú la prueba a ver si te salta el mismo error. Ese método se necesita para completar los otros apartados y es lógico probar primero que funcione. Saludos.

[abel]

Hola Alex, a mi la prueba me funciona correctamente, creo que podrías ser por dos motivos lo del error al compilar, algunas veces me ha pasado, por causas desconocidas a veces me da la sensación que eclipse no reconoce las librerías importadas, entonces algo que arreglo con volver a importar el Guapa(agregarlo mejor dicho).
Otra observación: la clase ClimaUtiles contiene un método static con esto no nos hace falta instanciar un objeto para utilizar sus métodos, baste con poner el nombre de la clase un punto y en seguida el nombre del método, sería algo así:

Código: [Seleccionar]

Map <String , List<Integer>> pruebaMapa = ecg.getMap();
System.out.println ("La diferencia máxima en Kujalleq es: "+ ClimaUtiles.diferenciaMaxima("Kujalleq", pruebaMapa));ahora mirándolo bien tiene toda la pinta de ser un error de Guava, agregala otra vez.
Ah por cierto buen estilo de trabajar, vas probando paso a paso el funcionamiento de cada clase para asegurarte de su correcto funcionamiento.
Un saludo

[abel]

Ya lo he conseguido es un poco difícil de entender per funciona, lo que mas me ha costado es hacer un constructor de la clase "ComparadorTemperaturas" que a su vez implementa la interfaz Comparator<String>.
Te dejo el código haber si tu lo captas mejor que yo.
La clase ComparadorTemperaturas es:

Código: [Seleccionar]

package groenlandia;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

// TODO Apartado e
public class ComparadorTemperaturas implements Comparator<String> {
// Atributo
// TODO
private Map<String, List<Integer>> mapaDifTemp = new HashMap<String, List<Integer>>();
// El constructor debe recibir, y almacenar en el atributo, el Map con los
// municipios y las temperaturas
// TODO
public ComparadorTemperaturas(Map<String , List<Integer>> mapTemp){

mapaDifTemp.putAll(mapTemp);
}
public int compare(String municipio1, String municipio2) {
// TODO
Integer dif1 = ClimaUtiles.diferenciaMaxima(municipio1, mapaDifTemp);
Integer dif2 = ClimaUtiles.diferenciaMaxima(municipio2, mapaDifTemp);
return dif1-dif2;
}
}
la clase ClimaUtiles funciona y queda tal cual, el método de la clase ClimaGroenlandiaImpl será:

Código: [Seleccionar]

public String municipioConMayorDiferenciaTemperaturas() {
// TODO
String municipioMaxDif = null;
// Utilizando Ordering, sería:
Comparator<String> cmp = new ComparadorTemperaturas(mapa);
Ordering<String> ordCmp = Ordering.from(cmp);
municipioMaxDif = ordCmp.max(mapa.keySet());
return municipioMaxDif;
}Haber si tienes o sabes de alguna pagina de ejercicios dedicados al "Map" para forzar mis conocimiento, Gracias Alex

[abel]

Se me ha escapado un detalle, en el constructor de la clase ComparadorTemperaturas
es mas correcto poner,

Código: [Seleccionar]

this.mapaDifTemp = mapaTemp;en vez de:

Código: [Seleccionar]

mapaDifTemp.putAll(mapTemp);y otra cosa que he aprendido también es que en la clase ClimaGroenlandiaImpl:

Código: [Seleccionar]

if( mapa.containsKey(muni) ){
List<Integer> listaTmp = new ArrayList<Integer>(mapa.get(muni));
listaTmp.addAll(listaInt);
mapa.put(muni, listaTmp);
//LAS TRES LINEAS ANTERIORES SE PUEDEN RESUMIR A ESTA UNICA LINEA:
                                      //mapa.get(muni).addAll(listaInt);
}//if
else{
mapa.put(muni, listaInt);
}//else

[Alex Rodríguez]

Creo que vas avanzando... Decías por ahí "si tienes o sabes de alguna pagina de ejercicios dedicados al "Map" para reforzar mis conocimientos..." yo como colaboro directamente con aprenderaprogramar.com obviamente recomiendo nuestros propios contenidos, no voy a recomendar los de otros  :

Conceptos más básicos pero bien estructurados en un curso básico: https://www.aprenderaprogramar.com/index.php?option=com_content&view=category&id=68&Itemid=188

Conceptos más avanzados (incluidos maps y otros): https://www.aprenderaprogramar.com/index.php?option=com_content&view=category&id=58&Itemid=180

Saludos

[abel]

Vale los miraré, gracias por tu ayuda Alex