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

Vale los miraré, gracias por tu ayuda Alex

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

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:
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: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í: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.

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:
package Hashmap;

import java.util.SortedSet;

public interface ClimaGroenlandia {
void cargaFichero(String nombreFichero);
Integer temperaturaMinima();
// String municipioConMayorDiferenciaTemperaturas();
// SortedSet<String> municipiosBajo(Integer temp);
}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;
// }
}
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());
}

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

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