Tengo un archivo txt con el formato:

Key:value
Key:value
Key:value
...

Quiero poner todas las llaves con su valor en un hashMap que yo he creado. ¿Cómo puedo obtener una FileReader(file) o Scanner(file) saber cuando la división de las claves y valores en los dos puntos (:) ? 🙂

He probado:

Scanner scanner = new scanner(file).useDelimiter(":");
HashMap<String, String> map = new Hashmap<>();

while(scanner.hasNext()){
    map.put(scanner.next(), scanner.next());
}
InformationsquelleAutor Casper TL | 2015-03-15

3 Comentarios

  1. 7

    Leer el archivo línea por línea el uso de un BufferedReader, y para cada línea de realizar un split en la primera aparición de : dentro de la línea (y si no hay : luego ignoramos que la línea).

    Aquí está el código de ejemplo – evita el uso de Escáner (que tiene algunas sutiles comportamientos y en mi humilde opinión es en realidad más problemas de lo que vale la pena).

    public static void main( String[] args ) throws IOException
    {
        String filePath = "test.txt";
        HashMap<String, String> map = new HashMap<String, String>();
    
        String line;
        BufferedReader reader = new BufferedReader(new FileReader(filePath));
        while ((line = reader.readLine()) != null)
        {
            String[] parts = line.split(":", 2);
            if (parts.length >= 2)
            {
                String key = parts[0];
                String value = parts[1];
                map.put(key, value);
            } else {
                System.out.println("ignoring line: " + line);
            }
        }
    
        for (String key : map.keySet())
        {
            System.out.println(key + ":" + map.get(key));
        }
        reader.close();
    }
    • Que funcionaba como yo quería! Muchas gracias por su ejemplo detallado! 🙂
    • Es el cierre de los recursos de la sobrevalorada en estos días? Nadie parece hacer nada más.
    • definitivamente sobrevalorado </snark> era sólo un ejemplo de Tom, pero su punto es bien tomado. Por favor, siéntase libre de modificar la respuesta a añadir un try/finally, si usted piensa que se lo merece.
  2. 6

    El de abajo va a trabajar en java 8.

    La .filter(s -> s.matches("^\\w+:\\w+$")) significa que sólo se trata de trabajo en línea en el archivo que son dos cadenas separadas por :, obviamente fidling con esta expresión va a cambiar lo que permitirá que a través de.

    La .collect(Collectors.toMap(k -> k.split(":")[0], v -> v.split(":")[1])) funcionará en cualquiera de las líneas que coinciden con el filtro anterior, dividir en :, a continuación, utilizar la primera parte de la división como la clave de una entrada de mapa, a continuación, la segunda parte de ese partido como el valor en la entrada de mapa.

    import java.io.IOException;
    import java.nio.file.FileSystems;
    import java.nio.file.Files;
    import java.nio.file.Path;
    import java.util.Map;
    import java.util.stream.Collectors;
    
    public class Foo {
    
        public static void main(String[] args) throws IOException {
            String filePath = "src/main/resources/somefile.txt";
    
            Path path = FileSystems.getDefault().getPath(filePath);
            Map<String, String> mapFromFile = Files.lines(path)
                .filter(s -> s.matches("^\w+:\w+"))
                .collect(Collectors.toMap(k -> k.split(":")[0], v -> v.split(":")[1]));
        }
    }
    • Como alternativa, se puede utilizar Files.lines(Paths.get(filePath))...
  3. 3

    Uno más JDK 1.8 aplicación.

    Sugiero usar try-con-recursos y forEach iterador con putIfAbsent() método para evitar java.lang.IllegalStateException: valor de clave Duplicada si hay algunos valores duplicados en el archivo.

    FileToHashMap.java

    import java.io.IOException;
    import java.nio.file.Files;
    import java.nio.file.Paths;
    import java.util.Map;
    import java.util.HashMap;
    import java.util.stream.Stream;
    
    public class FileToHashMap {
        public static void main(String[] args) throws IOException {
            String delimiter = ":";
            Map<String, String> map = new HashMap<>();
    
            try(Stream<String> lines = Files.lines(Paths.get("in.txt"))){
                lines.filter(line -> line.contains(delimiter)).forEach(
                    line -> map.putIfAbsent(line.split(delimiter)[0], line.split(delimiter)[1])
                );
            }
    
            System.out.println(map);    
        }
    }

    in.txt

    Key1:value 1
    Key1:duplicate key
    Key2:value 2
    Key3:value 3

    La salida es:

    {Key1=value 1, Key2=value 2, Key3=value 3}

Dejar respuesta

Please enter your comment!
Please enter your name here