Mapok ebben a kurzusban:

A(z) Mapok fogalomról

A Map egy adatszerkezet, amely kulcs-érték párokat tárol. Hasonló más programozási nyelvek szótárához. A Map interfész határozza meg, milyen műveleteket végezhetsz el egy Map példányon.

HashMap

A Javában több különböző Map-implementáció is létezik. A HashMap az egyik leggyakrabban használt közülük.

// Make an instance
Map<String, Integer> fruitPrices = new HashMap<>();

A HashMap másoló konstruktorral is rendelkezik.

// Make a copy of a map
Map<String, Integer> copy = new HashMap<>(fruitPrices);

A maphoz a put metódussal adhatsz hozzá bejegyzéseket.

fruitPrices.put("apple", 100);
fruitPrices.put("pear", 80);
// => { "apple" => 100, "pear" => 80 }

Minden kulcshoz csak egy érték tartozhat. Ha ugyanazzal a kulccsal hívod meg a put metódust, az frissíti a kulcs értékét.

fruitPrices.put("pear", 40);
// => { "apple" => 100, "pear" => 40 }

Egy kulcs értékét a get metódussal kérheted le.

fruitPrices.get("apple"); // => 100

A containsKey metódussal ellenőrizheted, hogy a map tartalmaz-e egy adott kulcsot.

fruitPrices.containsKey("apple");   // => true
fruitPrices.containsKey("orange");  // => false

A remove metódussal bejegyzéseket távolíthatsz el.

fruitPrices.put("plum", 90);  // Add plum to map
fruitPrices.remove("plum");   // Removes plum from map

A size metódus a bejegyzések számát adja vissza.

fruitPrices.size();  // Returns 2

A keySet vagy a values metódussal egy Map kulcsait, illetve értékeit kérheted le halmazként vagy kollekcióként.

fruitPrices.keySet();  // Returns "apple" and "pear" in a set
fruitPrices.values();  // Returns 100 and 80, in a Collection

A HashMap a hashCode és az equals metódust használja

A HashMap az objektum hashCode és equals metódusát használja annak meghatározására, hogy hová tárolja, és hogyan kérje le egy kulcs értékeit. Ezért fontos, hogy a visszatérési értékük ne változzon a tárolás és a lekérés között, különben előfordulhat, hogy a HashMap nem találja meg az értéket.

Tegyük fel például, hogy a következő osztályt fogjuk egy map kulcsaként használni:

public class Stock {
    private String name;

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public int hashCode() {
        return Objects.hash(name);
    }

    @Override
    public boolean equals(Object obj) {
        if (obj == this) {
            return true;
        }
        if (Objects.equals(Stock.class, obj.getClass()) && obj instanceof Stock other) {
            return Objects.equals(name, other.name);
        }
        return false;
    }
}

A hashCode és az equals a name mezőtől függ, amely a setName metódussal megváltoztatható. A hashCode megváltoztatása meglepő eredményeket hozhat:

Stock stock = new Stock();
stock.setName("Beanies");

Map<Stock, Integer> stockCount = new HashMap<>();
stockCount.put(stock, 80);

stockCount.get(stock); // Returns 80

Stock other = new Stock();
other.setName("Beanies");

stockCount.get(other); // Returns 80 because "other" and "stock" are equal

stock.setName("Choccies");
stockCount.get(stock); // Returns null because hashCode value has changed

stockCount.get(other);  // Also returns null because "other" and "stock" are not equal

stock.setName("Beanies");
stockCount.get(stock); // HashCode restored, so returns 80 again

stockCount.get(other); // Also returns 80 again because "other" and "stock" are back to equal

Map.of és Map.copyOf

Egy map létrehozásának egy másik gyakori módja a Map.of vagy a Map.ofEntries használata.

// Using Map.of
Map<String, Integer> temperatures = Map.of("Mon", 30, "Tue", 28, "Wed", 32);

// or using Map.ofEntries
Map<String, Integer> temperatures2 = Map.ofEntries(
    Map.entry("Mon", 30),
    Map.entry("Tue", 28),
    Map.entry("Wed", 32)
);

A HashMap-mel ellentétben ezek előre feltöltik a mapot, és létrehozásuk után csak olvashatóvá válnak. A Map.copyOf egy csak olvasható másolatot készít egy mapról.

Map<String, Integer> readOnlyFruitPrices = Map.copyOf(fruitPrices);

A put, remove vagy clear metódusok meghívása UnsupportedOperationException kivételt vált ki.