Introducció a HashMap

HashMap és una de les implementacions més utilitzades de la interfície Map en Java. Permet emmagatzemar parelles clau-valor, on cada clau és única. És una estructura de dades molt eficient per a operacions de cerca, inserció i eliminació.

Característiques de HashMap

  • No ordenat: Els elements no tenen un ordre específic.
  • Permet valors null: Es poden utilitzar claus i valors nulls.
  • No sincronitzat: No és segur per a l'ús en entorns multithreading sense sincronització addicional.
  • Complexitat: Les operacions de cerca, inserció i eliminació tenen una complexitat de temps constant O(1) en la majoria dels casos.

Creació d'un HashMap

Per crear un HashMap, primer has d'importar la classe des del paquet java.util.

import java.util.HashMap;

public class ExempleHashMap {
    public static void main(String[] args) {
        // Creació d'un HashMap
        HashMap<Integer, String> map = new HashMap<>();

        // Inserció de parelles clau-valor
        map.put(1, "Un");
        map.put(2, "Dos");
        map.put(3, "Tres");

        // Impressió del HashMap
        System.out.println(map);
    }
}

Explicació del Codi

  1. Importació: import java.util.HashMap; importa la classe HashMap.
  2. Creació: HashMap<Integer, String> map = new HashMap<>(); crea un HashMap amb claus de tipus Integer i valors de tipus String.
  3. Inserció: map.put(1, "Un"); insereix la parella clau-valor (1, "Un") al HashMap.
  4. Impressió: System.out.println(map); imprimeix el contingut del HashMap.

Operacions Bàsiques

Inserció

Utilitza el mètode put per afegir parelles clau-valor.

map.put(4, "Quatre");

Accés

Utilitza el mètode get per obtenir el valor associat a una clau.

String valor = map.get(2); // Retorna "Dos"

Eliminació

Utilitza el mètode remove per eliminar una parella clau-valor.

map.remove(3); // Elimina la clau 3 i el seu valor associat

Comprovació de Claus i Valors

  • containsKey: Comprova si una clau existeix al HashMap.
  • containsValue: Comprova si un valor existeix al HashMap.
boolean existeixClau = map.containsKey(1); // Retorna true
boolean existeixValor = map.containsValue("Dos"); // Retorna true

Iteració

Pots iterar sobre les claus, valors o parelles clau-valor utilitzant un bucle for-each.

// Iteració sobre les claus
for (Integer clau : map.keySet()) {
    System.out.println("Clau: " + clau);
}

// Iteració sobre els valors
for (String valor : map.values()) {
    System.out.println("Valor: " + valor);
}

// Iteració sobre les parelles clau-valor
for (Map.Entry<Integer, String> entrada : map.entrySet()) {
    System.out.println("Clau: " + entrada.getKey() + ", Valor: " + entrada.getValue());
}

Exercicis Pràctics

Exercici 1: Creació i Manipulació d'un HashMap

  1. Crea un HashMap per emmagatzemar noms de persones (claus) i les seves edats (valors).
  2. Afegeix almenys 5 parelles clau-valor.
  3. Imprimeix totes les claus i valors.
  4. Elimina una clau i el seu valor associat.
  5. Comprova si una clau específica existeix al HashMap.

Solució

import java.util.HashMap;

public class ExerciciHashMap {
    public static void main(String[] args) {
        // Creació del HashMap
        HashMap<String, Integer> persones = new HashMap<>();

        // Inserció de parelles clau-valor
        persones.put("Anna", 30);
        persones.put("Joan", 25);
        persones.put("Maria", 28);
        persones.put("Pere", 35);
        persones.put("Laura", 22);

        // Impressió de totes les claus i valors
        for (Map.Entry<String, Integer> entrada : persones.entrySet()) {
            System.out.println("Nom: " + entrada.getKey() + ", Edat: " + entrada.getValue());
        }

        // Eliminació d'una clau
        persones.remove("Pere");

        // Comprovació si una clau existeix
        boolean existeix = persones.containsKey("Maria");
        System.out.println("Maria existeix: " + existeix);
    }
}

Exercici 2: Comptar la Frequència de Paraules

  1. Escriu un programa que llegeixi una llista de paraules i compti la freqüència de cada paraula utilitzant un HashMap.
  2. Imprimeix la paraula i la seva freqüència.

Solució

import java.util.HashMap;
import java.util.Scanner;

public class FrequenciaParaules {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        HashMap<String, Integer> frequencia = new HashMap<>();

        System.out.println("Introdueix paraules (escriu 'fi' per acabar):");

        while (true) {
            String paraula = scanner.next();
            if (paraula.equals("fi")) {
                break;
            }

            frequencia.put(paraula, frequencia.getOrDefault(paraula, 0) + 1);
        }

        // Impressió de la freqüència de cada paraula
        for (Map.Entry<String, Integer> entrada : frequencia.entrySet()) {
            System.out.println("Paraula: " + entrada.getKey() + ", Freqüència: " + entrada.getValue());
        }

        scanner.close();
    }
}

Conclusió

HashMap és una eina poderosa i flexible per emmagatzemar i gestionar parelles clau-valor en Java. Amb les seves operacions eficients i la seva facilitat d'ús, és una de les estructures de dades més utilitzades en el desenvolupament de programari. Practicar amb HashMap et permetrà comprendre millor com gestionar dades de manera eficient i efectiva.

Curs de Programació en Java

Mòdul 1: Introducció a Java

Mòdul 2: Flux de Control

Mòdul 3: Programació Orientada a Objectes

Mòdul 4: Programació Orientada a Objectes Avançada

Mòdul 5: Estructures de Dades i Col·leccions

Mòdul 6: Gestió d'Excepcions

Mòdul 7: Entrada/Sortida de Fitxers

Mòdul 8: Multithreading i Concurrència

Mòdul 9: Xarxes

Mòdul 10: Temes Avançats

Mòdul 11: Frameworks i Llibreries de Java

Mòdul 12: Construcció d'Aplicacions del Món Real

© Copyright 2024. Tots els drets reservats