HashMaps en collecties in Java

Een map bewaart een koppeling van elke sleutel naar één waarde. In een voorraadmap is een productnaam de sleutel en de hoeveelheid de waarde. Twee producten kunnen dezelfde hoeveelheid hebben, maar één productsleutel kan niet twee afzonderlijke sleutel-waardeparen hebben.

Maak de map

import java.util.HashMap;

HashMap<String, Integer> stock = new HashMap<>();

Het eerste type, String, beschrijft sleutels. Het tweede, Integer, beschrijft waarden. Met de diamantnotatie <> rechts kan Java die typen afleiden. Typeargumenten moeten referentietypen zijn: gebruik Integer, Double, Character of Boolean in plaats van int, double, char of boolean. Java zet een gewone int via autoboxing om als die als Integer wordt opgeslagen en zet een Integer via unboxing om als een int nodig is.

Volg elke wijziging

stock.put("apple", 12);
stock.put("pear", 7);
Integer previous = stock.put("apple", 15);

De eerste aanroep maakt apple=12; de tweede voegt pear=7 toe. De derde vindt de bestaande sleutel "apple" en vervangt de waarde ervan. De map heeft nu twee sleutel-waardeparen en previous bevat 12. Een put voor een sleutel die nog niet aan een waarde is gekoppeld, geeft null terug.

stock.get("apple") geeft nu 15 terug. stock.remove("pear") geeft 7 terug en verwijdert dat paar. Als je "pear" opnieuw verwijdert, krijg je null terug. size() telt de paren, isEmpty() controleert of er geen paren zijn en clear() verwijdert alle paren.

Handel een ontbrekende sleutel af

stock.get("kiwi") geeft null terug en stock.containsKey("kiwi") geeft false terug. Deze instructie compileert, maar mislukt tijdens de uitvoering:

int quantity = stock.get("kiwi");

Java probeert null via unboxing om te zetten naar een int, waardoor een NullPointerException ontstaat. Gebruik bij een map met hoeveelheden die niet null zijn een standaardwaarde:

int quantity = stock.getOrDefault("kiwi", 0);

Dit geeft 0 zonder "kiwi" aan de map toe te voegen. Je kunt ook containsKey controleren voordat je leest. containsValue(15) vraagt of een van de paren die waarde heeft; de methode kan alle waarden doorzoeken en verschilt dus van het zoeken naar een bekende sleutel.

Een HashMap staat ook een null-sleutel en null-waarden toe. Als een sleutel expliciet aan null is gekoppeld, geeft getOrDefault die opgeslagen null terug, niet de standaardwaarde. Met containsKey onderscheid je dat geval van een ontbrekende sleutel. Voorraadmaps zijn eenvoudiger als elke opgeslagen hoeveelheid een echt getal is.

Vergelijk sleutels en waarden correct

Strings als sleutel zijn hoofdlettergevoelig: "apple", "Apple" en "apple " zijn verschillend. Pas vóór het opslaan en zoeken dezelfde opschoning toe, zoals name.trim().toLowerCase(). Alleen een zoeksleutel opschonen kan inconsistent opgeslagen sleutels niet herstellen.

Vergelijk waarden in wrapperobjecten op inhoud met equals. Als twee paren elk 1000 bevatten, kunnen hun Integer-referenties verschillen, zodat == onwaar kan zijn hoewel hun numerieke inhoud overeenkomt. Nadat je hebt gecontroleerd dat beide waarden niet null zijn, vergelijkt a.equals(b) hun inhoud.

Een map kan één zoekactie beantwoorden of al zijn gegevens aan een lus aanbieden. Kies de weergave die de onderdelen geeft die de lus nodig heeft. De weergaven zijn gekoppeld aan de map, dus wijzigingen via die weergaven kunnen ook de map wijzigen.

Kies sleutels, waarden of sleutel-waardeparen

Gebruik keySet() om sleutels te doorlopen. Met een zoekactie binnen die lus kun je elke waarde ophalen:

for (String name : phoneBook.keySet()) {
    System.out.println(name + ": " + phoneBook.get(name));
}

Gebruik values() als de sleutels niet relevant zijn. Voor de voorraadhoeveelheden appel 15, peer 7 en vijg 3:

int total = 0;
for (int quantity : stock.values()) {
    total += quantity;
}

Het totaal wordt 25. Herhaalde waarden leveren nog steeds afzonderlijke bijdragen: een waardenweergave is geen verzameling.

Een sleutel-waardepaar bevat een sleutel en de bijbehorende waarde samen. Importeer java.util.Map en gebruik Map.Entry<K, V> met getKey() en getValue(). Zo voorkom je een tweede zoekactie:

String best = null;
int bestScore = Integer.MIN_VALUE;
for (Map.Entry<String, Integer> entry : scores.entrySet()) {
    if (best == null || entry.getValue() > bestScore) {
        best = entry.getKey();
        bestScore = entry.getValue();
    }
}

Voor Ana 82, Ben 91 en Cai 77 is het resultaat Ben met 91. De test best == null handelt ook een eerste score af die gelijk is aan de kleinst mogelijke int. Bij een lege map blijft best gelijk aan null.

Kies de volgorde expliciet

Een HashMap garandeert geen iteratievolgorde. Je kunt niet uitgaan van invoegvolgorde, gesorteerde volgorde of de volgorde waarin de map vandaag wordt weergegeven. Een LinkedHashMap behoudt de invoegvolgorde; een TreeMap doorloopt gesorteerde sleutels. Als twee scores gelijk zijn, bewaart de lus hierboven de eerste die wordt aangetroffen. Bij een HashMap kan elk van de namen met de hoogste score winnen. Voeg een expliciete regel voor een gelijke stand toe als het resultaat voorspelbaar moet zijn.

Verwijder paren via de iterator

Als je stock.remove(key) aanroept binnen een for-each-lus over stock.keySet(), verander je de sleutels die de lus doorloopt. Dit kan een ConcurrentModificationException veroorzaken. Detectie is niet gegarandeerd; een uitvoering zonder exceptie maakt dit patroon niet geldig.

Gebruik de eigen verwijdermethode van de iterator:

Iterator<Map.Entry<String, Integer>> it =
    stock.entrySet().iterator();
while (it.hasNext()) {
    if (it.next().getValue() == 0) {
        it.remove();
    }
}

Importeer java.util.Iterator. Voor appel 15, peer 0, vijg 0 en kiwi 4 verwijdert dit peer en vijg. Een andere veilige aanpak is om sleutels in een lijst te bewaren, de lus af te maken en die sleutels daarna te verwijderen.

Een bestaande waarde vervangen voegt geen sleutel toe en verwijdert er geen. Tijdens een lus over sleutel-waardeparen kan entry.setValue(entry.getValue() * 2) de hoeveelheden veilig verdubbelen. Voeg tijdens die lus geen nieuwe sleutels toe via de map.

Onderscheid een weergave van een kopie

stock.keySet().remove("apple") verwijdert het bijbehorende sleutel-waardepaar uit de map. Een aparte lijst die je maakt met new ArrayList<>(stock.keySet()) is een kopie van de huidige sleutels. Het sorteren van die lijst verandert de volgorde van de map niet en het verwijderen van een naam uit de lijst verwijdert de bijbehorende koppeling niet.

Een product-ID die als String is opgeslagen, heeft al bruikbare gelijkheidsregels. Bij een sleutel van je eigen klasse moet je een keuze maken: stellen twee afzonderlijke objecten met dezelfde gegevens dezelfde sleutel voor?

Hashcodes beperken de zoekactie; gelijkheid bevestigt de overeenkomst

Een HashMap gebruikt hashCode() om een sleutel te helpen lokaliseren en equals() om een overeenkomst te controleren. Gelijke sleutels moeten gelijke hashcodes hebben. Verschillende sleutels kunnen een hashcode delen; gelijkheid onderscheidt ze nog steeds. Standaardwaardeklassen zoals String en Integer volgen dit contract al.

Zonder overschrijvingen erft een klasse van Object gelijkheid op basis van identiteit. Twee afzonderlijk gemaakte punten met coördinaten 2 en 3 zijn verschillende sleutels, ook al komen hun velden overeen:

labels.put(new Point(2, 3), "door");
String label = labels.get(new Point(2, 3));

Bij gelijkheid op basis van identiteit is label gelijk aan null. De zoekactie maakte een tweede object, niet het object dat voor het toevoegen is gebruikt.

Overschrijf het paar samen

Hier bepaalt een punt zijn inhoud via de coördinaten:

import java.util.Objects;

final class Point {
    private final int x;
    private final int y;

    Point(int x, int y) {
        this.x = x;
        this.y = y;
    }

    @Override
    public boolean equals(Object other) {
        if (this == other) {
            return true;
        }
        if (!(other instanceof Point)) {
            return false;
        }
        Point point = (Point) other;
        return x == point.x && y == point.y;
    }

    @Override
    public int hashCode() {
        return Objects.hash(x, y);
    }
}

De identiteitscontrole handelt hetzelfde object snel af. De typecontrole wijst null en objecten van een niet-verwant type af. De laatste vergelijking controleert beide coördinaten. Objects.hash(x, y) bouwt de hashcode op uit diezelfde velden. Met deze klasse geeft de zoekactie hierboven "door" terug.

Als je alleen equals overschrijft, blijft de overgeërfde hashcodebepaling bestaan. Die garandeert geen gelijke hashcodes voor afzonderlijke objecten met gelijke velden. Een map kan daardoor een gelijke sleutel missen. Een constante hashcode zou de juistheid behouden, maar het zoeken vertragen. Als je beide overschrijvingen in een editor genereert, voorkom je makkelijker dat de gebruikte velden niet overeenkomen.

Gebruik de exacte methodesignatuur

public boolean equals(Point other) overlaadt de methode; die vervangt equals(Object) niet. Bij het opzoeken in een map wordt equals(Object) gebruikt, dus geeft de nieuwe overladen methode de map geen inhoudelijke gelijkheid. De annotatie @Override maakt van een verkeerde signatuur een compilatiefout in plaats van een verborgen fout bij het opzoeken.

Houd de identiteit van een sleutel stabiel

Wijzig velden die de gelijkheid of hashcode van een sleutel bepalen niet zolang de sleutel is opgeslagen. Als een opgeslagen punt verandert van (2, 3) naar (5, 3), kan de map het onder geen van beide waarden meer vinden, ook al is size() ongewijzigd. Verwijder het punt voordat je het wijzigt en voeg het daarna opnieuw toe. Door sleutelvelden final te maken, zoals hierboven, voorkom je deze fout.

Deze regels bepalen ook het lidmaatschap van een HashSet. Een ArrayList gebruikt equals voor zoekacties op inhoud zoals contains; voor die zoekactie zijn geen hashcodes nodig.

Een frequentietabel heeft één sleutel voor elk uniek element en een getal dat aangeeft hoe vaak het voorkomt. Het eerste voorkomen begint een telling; elk volgend voorkomen werkt hetzelfde sleutel-waardepaar bij.

Bouw een telling element voor element op

HashMap<String, Integer> counts = new HashMap<>();
for (String word : text.split(" ")) {
    int oldCount = counts.getOrDefault(word, 0);
    counts.put(word, oldCount + 1);
}

Voor een tekst waarin "the" als eerste woord voorkomt, ontbreekt die sleutel aanvankelijk, dus is het oude aantal 0 en het nieuwe aantal 1. De volgende twee keren dat het woord voorkomt, verandert het aantal in dat paar naar 2 en daarna 3. "cat" eindigt op 2; "saw", "dog", "and" en "ran" eindigen elk op 1.

Er zijn 6 unieke woorden, dus is counts.size() gelijk aan 6. De waarden tellen op tot 9, het aantal voorkomens van woorden. Dit zijn verschillende maten: de grootte van de map is niet de lengte van de oorspronkelijke reeks.

De bijwerking kan op één regel worden geschreven:

counts.put(word, counts.getOrDefault(word, 0) + 1);

Een gelijkwaardige langere vorm controleert containsKey, verhoogt een bestaand aantal en slaat 1 op voor een nieuwe sleutel. Alle aantallen die met dit patroon worden opgeslagen, zijn niet null.

Behoud het oude resultaat

Als je voor elk woord counts.put(word, 1) aanroept, overschrijf je elk aantal steeds opnieuw met 1. Zo leg je vast dat een woord bestaat, maar gaat de frequentie verloren. Als je counts.get(word) + 1 aanroept zonder het eerste voorkomen af te handelen, probeert Java null via unboxing om te zetten en mislukt de uitvoering. De standaardwaarde hoort bij het lezen; het verhoogde aantal moet daarna worden teruggeplaatst.

Bepaal wat als hetzelfde element telt

Gelijkheid van strings is exact. "The" en "the" zijn verschillende sleutels, net als "cat" en "cat,". Als de taak die als hetzelfde woord beschouwt, schoon dan elk token op voordat je het telt. Zet tekst om naar kleine letters en verwijder de leestekens die het programma als scheidingstekens behandelt. Gebruik één consistente regel zodat de resultaten niet afhangen van welke schrijfwijze het eerst voorkwam.

De sleutel kan ook een teken zijn. Met HashMap<Character, Integer> levert een lus over "banana".toCharArray() met hetzelfde patroon van lezen, verhogen en opslaan a=3, n=2 en b=1 op.

Tel bedragen op in plaats van voorkomens

Tel voor categorietotalen het huidige bedrag op in plaats van 1:

HashMap<String, Double> totals = new HashMap<>();
double oldTotal = totals.getOrDefault(category, 0.0);
totals.put(category, oldTotal + amount);

Eten 12,50, vervoer 3,20 en eten 7,25 leveren eten 19,75 en vervoer 3,20 op. De standaardwaarde is 0.0, passend bij het waardetype Double. De map heeft nog steeds één paar per categorie, ongeacht hoeveel bedragen hebben bijgedragen.

Lees de voltooide tabel

Doorloop sleutel-waardeparen om het grootste aantal of totaal te vinden en onthoud daarbij de beste sleutel en waarde. Leg zo nodig een regel voor gelijke standen vast. Voor een alfabetisch overzicht kopieert new TreeMap<>(counts) de koppelingen in gesorteerde sleutelvolgorde. De aantallen blijven ongewijzigd; de sleutels sorteren sorteert de categorieën niet op hun totalen.

Een mapwaarde kan een collectie zijn. Als meerdere studenten bij één cursus horen, is de cursus een sleutel en bevat de bijbehorende lijst alle studenten van die cursus. De regel dat maps unieke sleutels hebben, geldt nog steeds: de lijst is de ene waarde voor die cursus.

Maak een groep voordat je er iets aan toevoegt

HashMap<Character, ArrayList<String>> groups = new HashMap<>();
for (String fruit : fruits) {
    char letter = fruit.charAt(0);
    if (!groups.containsKey(letter)) {
        groups.put(letter, new ArrayList<>());
    }
    groups.get(letter).add(fruit);
}

Voor “appel”, “banaan”, “avocado”, “kers” en “bes” maakt de eerste vrucht de lijst voor a en voegt “appel” toe. “Banaan” maakt de lijst voor b. “Avocado” vindt de bestaande lijst voor a en voegt zichzelf achteraan toe. Het resultaat is a → [appel, avocado], b → [banaan, bes] en k → [kers]. Elke lijst behoudt zijn eigen invoegvolgorde, ook al ordent de HashMap zijn sleutels niet.

De controle kan korter:

groups.putIfAbsent(letter, new ArrayList<>());
groups.get(letter).add(fruit);

putIfAbsent behoudt een bestaande lijst die niet null is. De daaropvolgende get geeft die lijst terug, klaar voor de toevoeging.

Behoud de lijst die je al hebt opgebouwd

Een onvoorwaardelijke groups.put(letter, new ArrayList<>()) binnen de lus vervangt bij elk voorkomen de oude lijst. Na de volgende add blijft alleen de laatste vrucht per letter over. De tegenovergestelde fout is het aanmaken helemaal overslaan: groups.get(letter).add(fruit) werpt voor een nieuwe sleutel een NullPointerException op omdat er nog geen lijst bestaat.

Begrijp de referentie

get geeft de opgeslagen lijstreferentie terug. Als je daar iets aan toevoegt, verandert diezelfde lijst, dus hoef je die niet terug te plaatsen. Dit verklaart ook een fout met gedeelde referenties:

ArrayList<String> shared = new ArrayList<>();
courses.put("Art", shared);
courses.put("Music", shared);
courses.get("Art").add("Jin");

Beide sleutels leiden nu naar [Jin]. Twee sleutels hebben niet twee lijsten gemaakt. Maak voor elke nieuwe groep een nieuwe lijst als de groepen onafhankelijk moeten zijn.

Kies lijsten of verzamelingen binnen groepen

Een lijst behoudt herhaalde toevoegingen. Een verzameling voorkomt duplicaten binnen die groep. Een HashMap<String, HashSet<String>> kan zo de verschillende cursuslidmaatschappen van elke student verzamelen zonder dezelfde student twee keer in één cursus te tellen. De verzamelingsregel geldt binnen elke waarde; de buitenste map heeft nog steeds één paar per cursus.

Controleer bij het lezen van een groep die mogelijk ontbreekt containsKey of gebruik groups.getOrDefault(letter, new ArrayList<>()). Een ontbrekende sleutel levert dan voor die aanroep een lege lijst op. De standaardlijst wordt niet automatisch ingevoegd; als je er iets aan toevoegt, ontstaat geen opgeslagen groep.

Als je het laatste element van een groep verwijdert, blijft de sleutel aan een lege collectie gekoppeld. Als het programma lege groepen niet langer moet vermelden, controleer dan isEmpty() en verwijder ook die sleutel. Tel groepen met de grootte van de buitenste map en elementen met de groottes van de binnenste collecties.

Een index koppelt een identificerende sleutel aan een object. Een bibliotheek kan een boek via het ISBN vinden zonder elk boek in een lijst te doorzoeken. Een opzoektabel gebruikt dezelfde vorm om een code aan een eenvoudige waarde te koppelen, zoals een productprijs.

Kies een identificerende sleutel

Een HashMap<String, Book> kan een ISBN aan het bijbehorende boek koppelen. Elke zoekactie heeft alleen de sleutel nodig. De naam van een persoon is vaak geen goede unieke sleutel: als je een andere persoon met de naam “Sam Lee” onder dezelfde string opslaat, vervangt die de vorige persoon. Gebruik een unieke ID of gebruik een groepeermap als één naam naar meerdere personen moet leiden.

Bewaar een index binnen de klasse die verantwoordelijk is voor de gegevens:

class Library {
    private HashMap<String, Book> byIsbn;

    Library() {
        byIsbn = new HashMap<>();
    }

    void addBook(Book book) {
        byIsbn.put(book.getIsbn(), book);
    }

    Book findByIsbn(String isbn) {
        return byIsbn.get(isbn);
    }
}

Hier biedt Book een methode getIsbn() aan. Aanroepers gebruiken addBook en findByIsbn; ze hoeven niet te weten welke mapimplementatie is opgeslagen. Het privéveld geeft de klasse ook één plek om haar regels voor het toevoegen en vervangen van boeken te onderhouden.

Controleer een ontbrekend resultaat

Als findByIsbn de waarde null teruggeeft, is geen boek gevonden. Test het resultaat voordat je er een methode op aanroept:

Book found = library.findByIsbn("978-0-00-000000-2");
if (found != null) {
    found.setOnLoan(true);
}

Als je setOnLoan rechtstreeks op een ontbrekend resultaat aanroept, wordt een NullPointerException opgeworpen. Een methode zoals hasBook(isbn) is een andere manier om aanroepers op een sleutel te laten controleren.

Volg gedeelde objecten door indexen heen

Een map slaat een objectreferentie op, geen nieuwe kopie van dat object. Als hetzelfde boek in een lijst met alle boeken, een ISBN-map en een groepering op auteur staat, wijzigt setOnLoan(true) het ene boek waarnaar alle drie verwijzen. Zo voorkom je dat drie afzonderlijke boekobjecten uiteen gaan lopen.

De collectiestructuren zelf moeten nog steeds worden onderhouden. Als je een boek uit de ISBN-map verwijdert, verwijder je de referentie niet uit de lijst van een auteur. Als een bibliotheek beide indexen bijhoudt, moeten de methoden voor toevoegen en verwijderen beide bijwerken. Door die wijzigingen te centraliseren in methoden zoals addBook en removeBook blijven zoekacties consistent.

Gebruik een tabel in een berekening

Stel dat een prijstabel koffie 2,50, thee 2,00 en muffin 3,25 bevat. Voor twee koffie en één muffin:

double cost = 2 * prices.get("coffee") + prices.get("muffin");

Het subtotaal voor de koffie is 5,00; daar 3,25 bij optellen geeft 8,25. De sleutels identificeren producten en de waarden leveren de bedragen. Voor een ontbrekend product moet je vóór de berekening een expliciete keuze maken: een standaardwaarde nul zou het product ongemerkt als gratis behandelen. Dezelfde opzoektechniek kan dus een andere regel voor ontbrekende sleutels nodig hebben dan een frequentietabel.

Een verzameling bevat elke waarde hoogstens één keer. Die past bij vragen zoals “Is deze waarde eerder voorgekomen?” of “Hoeveel verschillende waarden komen voor?” Een HashSet controleert lidmaatschap gemiddeld snel zonder een weergavevolgorde te garanderen.

Voeg waarden toe en controleer ze

import java.util.HashSet;

HashSet<String> visited = new HashSet<>();
boolean first = visited.add("Oslo");
boolean second = visited.add("Lima");
boolean third = visited.add("Oslo");
visited.add("Pune");

De drie opgeslagen booleaanse waarden zijn true, true en false. De tweede “Oslo” komt overeen met een bestaand element en wordt dus niet toegevoegd. De grootte van de verzameling is 3. Een dubbele toevoeging vervangt geen genummerde plek, want een verzameling heeft geen index.

visited.contains("Lima") geeft true terug. visited.remove("Lima") verwijdert de waarde en geeft true terug; als je die verwijdering herhaalt, krijg je false terug. Gebruik een for-each-lus om waarden te doorlopen. Er is geen get(0) voor de eerste waarde van een HashSet.

Verwijder duplicaten uit een lijst

ArrayList<Integer> values = new ArrayList<>();
values.add(3);
values.add(1);
values.add(3);
values.add(2);
values.add(1);
HashSet<Integer> distinct = new HashSet<>(values);

De verzameling heeft drie waarden: {1, 2, 3}. De werkelijke iteratievolgorde is niet gespecificeerd. De oorspronkelijke lijst heeft nog steeds vijf elementen omdat de constructor een aparte collectie maakt.

Gebruik new LinkedHashSet<>(values) om de volgorde van eerste voorkomens te behouden: 3, 1, 2. Gebruik new TreeSet<>(values) om gesorteerde waarden te krijgen: 1, 2, 3. Verzamelingen worden hier tussen accolades geschreven om het lidmaatschap te benadrukken; de standaardmethode toString() van Java gebruikt voor verzamelingen vierkante haken.

Detecteer de eerste herhaling

Het resultaat van add kan de lidmaatschapstest en de toevoeging samen uitvoeren:

HashSet<Integer> seen = new HashSet<>();
for (int number : numbers) {
    if (!seen.add(number)) {
        System.out.println(number);
        break;
    }
}

Voor [4, 7, 2, 7, 4] geeft de lus 7 weer. Dat is de eerste waarde die voor de tweede keer wordt aangetroffen, ook al kwam 4 eerder in de reeks voor. Voordat 7 wordt herhaald, bevat de verzameling 4, 7 en 2. De mislukte toevoeging zorgt ervoor dat de lus stopt.

Weet wat een verzameling je niet kan vertellen

contains vóór elke add controleren is overbodig, omdat add duplicaten al afhandelt. Een lijst met een contains-controle kan waarden ook uniek houden, maar elke zoekactie in de lijst kan alle opgeslagen elementen doorlopen. Een HashSet drukt de regel direct uit.

Gelijkheid is van belang voor je eigen objecten. Een HashSet<Point> heeft een equals op basis van inhoud en een bijpassende hashCode nodig om afzonderlijk gemaakte punten met gelijke coördinaten samen te nemen. Zonder die overschrijvingen blijven afzonderlijke instanties afzonderlijke elementen.

Tot slot meet size() het aantal unieke waarden, niet het aantal voorkomens. De negen woorden in “de kat zag de hond en de kat rende” leveren zes unieke woorden op. Een verzameling vertelt je niet meer dat “de” drie keer voorkwam; gebruik een frequentietabel in een map als die aantallen van belang zijn.

Verzamelingen kunnen groepen beschrijven en hun lidmaatschap vergelijken. Als twee evenementenlijsten dezelfde persoon meerdere keren bevatten, brengt een verzameling elke lijst eerst terug tot de aanwezige personen. Bewerkingen op verzamelingen beantwoorden daarna vragen over minstens één van beide evenementen, beide evenementen of slechts één ervan.

Combineer twee groepen

Laat maandag {Ana, Ben, Cai, Dee} zijn en dinsdag {Ben, Dee, Eva}.

Deze bewerkingen zijn vereniging, doorsnede en verschil. Ze wijzigen de verzameling waarop ze worden aangeroepen en geven een booleaanse waarde terug die aangeeft of die is gewijzigd. Ze geven geen nieuwe resultaatverzameling terug.

Behoud het origineel

Maak een kopie voordat je het lidmaatschap wijzigt als maandag nog nodig is:

HashSet<String> both = new HashSet<>(monday);
both.retainAll(tuesday);

both begint met alle vier de namen van maandag. retainAll verwijdert Ana en Cai omdat ze op dinsdag ontbreken. Maandag zelf blijft ongewijzigd. Om alleen dinsdag te vinden, begin je met een kopie van dinsdag en verwijder je de namen van maandag. Dat geeft {Eva}. Verschil heeft een richting; als je die omdraait, verandert de vraag.

Controleer deelverzamelingen en gelijkheid

monday.containsAll(group) vraagt of elke waarde in group op maandag aanwezig is. Voor {Ben, Dee} geeft dit true terug: die groep is een deelverzameling van maandag. Het vereist niet dat maandag alleen die twee personen bevat.

Twee verzamelingen zijn gelijk als hun elementen overeenkomen, ongeacht de invoegvolgorde of implementatie. Een HashSet met “x” en “y” is gelijk aan een TreeSet met “y” en “x”. Lidmaatschap bepaalt de gelijkheid van verzamelingen, dus alleen de volgorde kan ze niet ongelijk maken.

Kies een volgorde voor het doorlopen

Alle drie voorkomen duplicaten. Gebruik LinkedHashSet als van belang is wanneer elke naam voor het eerst voorkwam. Gebruik TreeSet als elke doorloop al gesorteerd moet zijn. Voor strings volgt natuurlijk sorteren de tekencodes: kleine letters en hoofdletters gedragen zich niet als één hoofdletterongevoelig alfabet.

Een TreeSet met zijn standaardconstructor heeft elementen nodig die een natuurlijke vergelijking hebben, zoals strings, getallen of objecten die Comparable implementeren. In die verzameling markeert een vergelijkingsresultaat van nul een duplicaat. Een klasse die geen natuurlijke vergelijking biedt, veroorzaakt bij het invoegen een ClassCastException. Een expliciete comparator meegeven is een andere manier om de volgorde van een boomcollectie te definiëren; de standaardvoorbeelden gebruiken de natuurlijke volgorde.

Een interface beschrijft bewerkingen die een klasse aanbiedt als die de interface implementeert. Met een interface kan een variabele beschrijven wat de code nodig heeft, terwijl de keuze voor de opslag bij een concrete klasse blijft. List, Set en Map zijn interfaces in java.util die met collecties te maken hebben.

Lees beide kanten van een declaratie

List<String> names = new ArrayList<>();
Set<String> tags = new HashSet<>();
Map<String, Integer> counts = new HashMap<>();

Links staat de declaratie van het type van de variabele. Rechts wordt een object gemaakt van een klasse die de interface implementeert. Importeer beide typen, zoals java.util.List en java.util.ArrayList. Je kunt niet new List<>() of new Map<>() schrijven: een interface is geen concreet object dat je kunt maken.

Code die counts gebruikt, kan put, get en entrySet aanroepen omdat Map die declareert. Als alfabetische sleutels van pas komen, verander je de constructie in new TreeMap<>(). Bestaande aanroepen compileren nog steeds. Hun volgorde kan veranderen, omdat implementaties verschillende garanties over volgorde kunnen geven; de interface maakt hun gedrag niet in alle opzichten gelijk.

Accepteer de functionaliteit die een methode nodig heeft

Een methode die alleen lange woorden telt, kan een Collection accepteren:

static int countLong(Collection<String> words, int min) {
    int count = 0;
    for (String word : words) {
        if (word.length() >= min) {
            count++;
        }
    }
    return count;
}

Voor [“a”, “tree”, “house”] en een minimum van 4 geeft de methode 2 terug. Dezelfde methode kan een ArrayList, een LinkedList, een HashSet of List.of(...) ontvangen, omdat die alleen de elementen leest. Een verzameling kan duplicaten al hebben verwijderd en daardoor andere invoergegevens leveren dan een lijst.

Met een interfaceparameter voorkom je dat één specifieke opslagklasse vereist is terwijl de methode die niet nodig heeft. Als posities nodig zijn, accepteer je List. Als opzoeken via een sleutel nodig is, accepteer je Map.

Ken de grenzen van het gedeclareerde type

List<String> names = new ArrayList<>();
names.ensureCapacity(100);  // does not compile

Het object is een ArrayList, maar List declareert ensureCapacity niet. De compiler controleert het gedeclareerde type van de variabele. Gebruik een concreet klassetype als de speciale bewerking daarvan echt nodig is; verander gewone lijstparameters niet alleen om ze bij de klasse van één aanroeper te laten passen.

Plaats Map naast Collection

List en Set breiden Collection uit, dat een groep elementen beschrijft. Deze interface declareert methoden zoals add, remove, contains, size, isEmpty, addAll en clear. Of een wijziging wordt ondersteund, hangt af van de werkelijke collectie.

Map breidt Collection niet uit. Een map slaat koppelingen op en biedt weergaven die collecties zijn: keySet() is een Set, values() is een Collection en entrySet() is een Set met sleutel-waardeparen. Geef counts.values() door aan een methode die een collectie waarden nodig heeft, niet counts zelf.

Een klasse kan meerdere interfaces implementeren. LinkedList implementeert zowel List als Deque, een interface voor een dubbelzijdige wachtrij. Je eigen klasse noemt de interfaces die ze belooft te implementeren na implements, zoals in class Member implements Comparable<Member>.

Kies een interface op basis van de regels die je gegevens nodig hebben. Inhoud die op elkaar lijkt, maakt een lijst, een verzameling en een map niet onderling uitwisselbaar: elk geeft een andere betekenis aan posities, herhaling en gelijkheid.

Vergelijk de garanties

ArrayList en LinkedList implementeren List. HashSet, LinkedHashSet en TreeSet implementeren Set. HashMap, LinkedHashMap en TreeMap implementeren Map. Hashvarianten garanderen geen volgorde bij het doorlopen; linked-varianten behouden de invoegvolgorde; tree-varianten houden elementen of sleutels gesorteerd. Als je een bestaande sleutel opnieuw plaatst in een gewone LinkedHashMap met invoegvolgorde, behoudt die sleutel zijn plaats.

Lees verwijdering uit een lijst met gehele getallen zorgvuldig

Een List<Integer> heeft twee relevante overladen methoden:

List<Integer> numbers = new ArrayList<>(List.of(1, 5, 7));
numbers.remove(1);

Het argument 1 is een int, dus verwijdert Java het element op index 1: de waarde 5. Het resultaat is [1, 7]. Als je opnieuw begint met [1, 5, 7], kiest numbers.remove(Integer.valueOf(1)) voor verwijdering op waarde en blijft [5, 7] over. Het wrapperobject maakt duidelijk welke overladen methode is bedoeld.

Vergelijk inhoud met de juiste regel

Twee lijsten zijn gelijk als dezelfde elementen in dezelfde volgorde voorkomen. Een ArrayList [1, 2] is gelijk aan een LinkedList [1, 2], maar niet aan een lijst [2, 1]. Twee verzamelingen vergelijken het lidmaatschap en negeren de volgorde. Twee maps vergelijken koppelingen, dus beïnvloedt de invoegvolgorde hun gelijkheid niet. Hun concrete klassen kunnen verschillen terwijl hun inhoud volgens de regel van de interface gelijk is.

Herken niet-wijzigbare collecties

List<String> labels = List.of("a", "b");
Set<Integer> levels = Set.of(1, 2, 3);
Map<String, Double> prices = Map.of("tea", 2.0, "coffee", 2.5);

Deze fabrieksmethoden geven niet-wijzigbare collecties terug. Pogingen om de inhoud toe te voegen, te verwijderen, te vervangen of te sorteren werpen een UnsupportedOperationException op. Map.of accepteert maximaal tien sleutel-waardeparen.

Alle drie wijzen ze null-elementen, -sleutels of -waarden af met een NullPointerException. Set.of wijst dubbele elementen af en Map.of dubbele sleutels, met een IllegalArgumentException. List.of staat duplicaten toe omdat een lijst een element mag herhalen. De iteratievolgorde van de verzamelingen en maps die deze fabrieksmethoden maken, is niet gespecificeerd.

Kopieer als wijzigingen nodig zijn

new ArrayList<>(labels) maakt een wijzigbare lijst met dezelfde elementen. new HashSet<>(someList) en new HashMap<>(someMap) maken op dezelfde manier afzonderlijke collectiestructuren.

Deze kopieën zijn ondiep: ze bevatten dezelfde elementreferenties. Als je een element uit een kopie verwijdert, blijft de oorspronkelijke structuur intact, maar als je via een van beide collecties een veranderlijk object wijzigt, verandert het gedeelde object. Een niet-wijzigbare collectie verhindert wijzigingen aan de structuur; die bevriest niet elk object dat erin is opgeslagen.

Een lijst behoudt een volgorde, maar die volgorde kan eenvoudigweg weergeven hoe waarden zijn binnengekomen. Sorteren herschikt de lijst met een vergelijkingsregel. Java biedt al een natuurlijke volgorde voor getallen en strings.

Sorteer een wijzigbare lijst ter plaatse

List<Double> values = new ArrayList<>(List.of(3.5, -1.0, 2.25));
Collections.sort(values);

Importeer java.util.Collections. Dezelfde lijst bevat nu [-1,0; 2,25; 3,5]. De sortering geeft void terug, dus values = Collections.sort(values) compileert niet. values.sort(null) sorteert ook in natuurlijke volgorde. Gebruik voor een array Arrays.sort(array); een array met 5, 2 en 8 wordt 2, 5, 8.

Voorspel de stringvolgorde teken voor teken

Bij het vergelijken van strings wordt naar het eerste verschillende teken gekeken. Als de ene string een prefix van de andere is, komt de kortere eerst. Zo komt “appel” vóór “appels”.

De lijst [“pear”, “Banana”, “apple”, “10”, “9”] wordt gesorteerd tot [“10”, “9”, “Banana”, “apple”, “pear”]. Voor deze tekens komen cijfers vóór hoofdletters en hoofdletters vóór kleine letters. “10” komt vóór “9” omdat ‘1’ vóór ‘9’ komt; de stringvolgorde interpreteert cijferstrings niet als gehele getallen. Sla numerieke gegevens op als getallen wanneer een numerieke volgorde nodig is.

Gebruik kant-en-klare alternatieve volgorden

names.sort(String.CASE_INSENSITIVE_ORDER);
values.sort(Collections.reverseOrder());

De eerste aanroep ordent [“pear”, “Banana”, “apple”] als [“apple”, “Banana”, “pear”] zonder de opgeslagen hoofdletters en kleine letters te wijzigen. De tweede gebruikt aflopende natuurlijke volgorde. De getallen 4, 9 en 1 worden 9, 4 en 1. Deze argumenten zijn comparators, objecten die een alternatieve volgorde bieden.

Collections.reverse(list) keert alleen de huidige reeks om. Dit levert een aflopende volgorde op als die reeks al oplopend was gesorteerd; op zichzelf sorteert het geen willekeurige lijst.

Behoud de volgorde bij gelijke sorteerrangen

Het sorteren van lijsten is stabiel: elementen die bij vergelijking gelijk zijn, behouden hun eerdere onderlinge volgorde. Als een vergelijking die alleen scores gebruikt twee personen als gelijk beoordeelt, blijft hun eerdere volgorde in de lijst behouden. Stabiliteit bewaart die invoervolgorde; er ontstaat niet vanzelf een aanvullend alfabetisch sorteercriterium.

Herken fouten en handige methoden

Een lijst van List.of(...) kan niet ter plaatse worden gesorteerd. Kopieer die eerst naar een ArrayList. Voor een klasse zonder Comparable mislukt de typecontrole van Collections.sort(list) bij het compileren. Als je list.sort(null) op zulke objecten aanroept, mislukt dat tijdens de uitvoering met een ClassCastException wanneer een vergelijking nodig is.

Collections.max(collection) en Collections.min(collection) vinden de grootste en kleinste elementen volgens de natuurlijke volgorde zonder de collectie te herschikken. Ze werpen een NoSuchElementException op voor een lege collectie.

Voor gesorteerde mapsleutels kun je map.keySet() naar een ArrayList kopiëren en de kopie sorteren, of een TreeMap gebruiken. Het sorteren van een gekopieerde sleutellijst laat de eigen iteratievolgorde van de map ongewijzigd.

Java kan niet raden of een lid eerst op naam, lengte of een ander veld moet komen. Implementeer Comparable om de klasse één natuurlijke volgorde te geven. Sorteercode kan dan elk object vragen zichzelf te vergelijken met een ander object van die klasse.

Schrijf de vergelijkingsmethode

class Member implements Comparable<Member> {
    private String name;
    private int height;

    Member(String name, int height) {
        this.name = name;
        this.height = height;
    }

    @Override
    public int compareTo(Member other) {
        return Integer.compare(this.height, other.height);
    }
}

De lengte wordt gemeten in centimeters. Comparable<Member> geeft aan dat het andere object een Member is; een expliciete typeconversie is niet nodig. public int compareTo(Member other) is de vereiste methode. De standaardinterface Comparable staat in java.lang, dus is daarvoor geen import nodig.

Bij a.compareTo(b) plaatst een negatief resultaat a vóór b, zet nul ze op dezelfde vergelijkingspositie en plaatst een positief resultaat a na b. Alleen het teken is van belang: -35 is een even geldig negatief resultaat als -1.

Volg de volgorde

Met de vergelijking op lengte worden Ana 172, Ben 165 en Cai 180 gesorteerd tot Ben 165, Ana 172 en Cai 180. Verwissel de argumenten om langere leden eerst te plaatsen:

return Integer.compare(other.height, this.height);

Verander de regel bewust. Als je de argumenten omdraait, keer je de sorteerrichting van dat veld om; je verandert niet de betekenis van lengte of de gegevens van een lid.

Vergelijk gehele numerieke waarden veilig

Aftrekken lijkt handig, maar kan het verkeerde teken teruggeven als een int overloopt. Voor -2.000.000.000 en 2.000.000.000 geeft het aftrekken van het tweede getal van het eerste na overloop 294.967.296, een positief resultaat. Integer.compare geeft terecht een negatief resultaat terug.

Gebruik voor velden met kommagetallen Double.compare(this.price, other.price). Een verschil expliciet omzetten naar int laat informatie verloren gaan: (int) (1.8 - 1.5) is 0, zodat ongelijke prijzen dezelfde sorteerrang krijgen. Een vergelijkingsmethode behoudt de volgorde zonder het verschil af te kappen.

Vergelijk tekst en gebruik de regel opnieuw

Geef voor een volgorde op naam this.name.compareTo(other.name) terug. Deze methode volgt de tekenvolgorde van de string. compareToIgnoreCase biedt een hoofdletterongevoelige tekstvergelijking wanneer dat de bedoelde regel voor het veld is.

Zodra een klasse een natuurlijke volgorde definieert, kunnen bewerkingen zoals Collections.sort, Collections.max en de standaardvergelijkingen van TreeSet of TreeMap die gebruiken. Een klasse kan ook andere interfaces implementeren, gescheiden door komma’s na implements.

Er is één natuurlijke volgorde voor de klasse; er wordt niet voor elke lijst een andere compareTo gekozen. Gebruik aparte comparatorobjecten wanneer de ene context een volgorde op naam nodig heeft en de andere een volgorde op lengte. Een vergelijking die alleen lengte gebruikt, geeft ook alle gelijke lengtes dezelfde sorteerrang; of dat aanvaardbaar is, wordt vooral belangrijk bij gesorteerde verzamelingen.

Een primaire vergelijking laat vaak gelijke sorteerrangen over. Twee films kunnen hetzelfde jaar hebben of twee spelers dezelfde score. Een aanvullend sorteercriterium geeft het volgende veld pas een beurt als de eerdere velden bij vergelijking gelijk zijn.

Vergelijk velden in volgorde van prioriteit

@Override
public int compareTo(Film other) {
    int byYear = Integer.compare(this.year, other.year);
    if (byYear != 0) {
        return byYear;
    }
    return this.title.compareTo(other.title);
}

Het jaar is de hoofdregel. De titel is alleen van belang als de jaren gelijk zijn. Up (2009), Avatar (2009) en Alien (1979) worden gesorteerd tot Alien (1979), Avatar (2009), Up (2009). Als je eerst titels vergelijkt, krijgen die voorrang op het jaar en voer je een andere sorteertaak uit.

De richtingen kunnen per veld verschillen. Voor de hoogste punten eerst en namen van A tot Z begin je met Integer.compare(other.points, this.points). Geef bij nul this.name.compareTo(other.name) terug. Als je de hele uiteindelijke lijst zou omkeren, zou je ook de namen binnen gelijke scores omkeren.

Begrijp de duplicaatregel van een gesorteerde verzameling

Een standaard TreeSet<Member> gebruikt de natuurlijke vergelijking zowel om elementen te ordenen als om te bepalen wanneer een element al aanwezig is. Als Member.compareTo alleen lengte gebruikt, levert het vergelijken van Ana 172 en Dee 172 nul op. Het toevoegen van Ana geeft true terug; het toevoegen van Dee geeft false terug. Ana blijft het opgeslagen element, ook als equals de twee leden als verschillend beschouwt.

Een lijst kan beide objecten met gelijke sorteerrang behouden; een tree-verzameling geeft ze één vergelijkingspositie. Voeg het nodige aanvullende sorteercriterium toe als ze afzonderlijk in de verzameling moeten staan.

Stem vergelijking af op gelijkheid

Een volgorde is consistent met equals wanneer de vergelijking nul teruggeeft dan en slechts dan als equals true teruggeeft. Voor een klasse waarvan de gelijkheid lengte en naam gebruikt, kan vergelijken op lengte en daarna naam aan deze regel voldoen. Als gelijkheid een andere identiteit gebruikt, zoals een lid-ID, zorgt alleen naam toevoegen als aanvullend sorteercriterium niet voor consistentie.

De vergelijking moet zich ook gedragen als een geldige volgorde. Als a vóór b komt, moet de omgekeerde vergelijking b na a plaatsen. Als a vóór b komt en b vóór c, moet a vóór c komen. Vergelijkingsmethoden voor hele velden gebruiken in een vaste volgorde van prioriteit ondersteunt deze regels. Een inconsistente methode kan resultaten verkeerd ordenen of ervoor zorgen dat een sortering een IllegalArgumentException opwerpt.

Houd ook mapsleutels gesorteerd

Een TreeMap sorteert sleutels, geen waarden. Voor de woordtellingen van “de kat zag de hond en de kat rende” is de eerste sleutel “de” en de laatste “zag”. firstKey() en lastKey() geven die uiterste sleutels. Declareer een TreeMap of een passende interface voor gesorteerde maps wanneer je methoden aanroept die de gewone Map niet declareert.

De sleutelvergelijking bepaalt ook welke sleutels overeenkomen. Een tweede sleutel die bij vergelijking nul oplevert, werkt de bestaande koppeling bij, ook als equals de objecten onderscheidt. Standaard hebben tree-collecties elementen of sleutels nodig die van nature vergelijkbaar zijn; als je een object zonder geschikte vergelijking invoegt, wordt een ClassCastException opgeworpen. Een expliciet meegegeven comparator kan een andere volgorde definiëren.

De kosten van een bewerking beschrijven hoe het werk groeit met het aantal opgeslagen elementen. Zo kun je code herkennen die snel is voor een klein voorbeeld, maar traag wordt als de collectie groot wordt.

Vergelijk groei, geen seconden

Constante tijd, O(1), blijft ongeveer onafhankelijk van de collectiegrootte. Lineaire tijd, O(n), kan evenredig met het aantal elementen groeien. Logaritmische tijd, O(log n), groeit langzaam als de grootte toeneemt. Deze aanduidingen beschrijven groei, geen exacte uitvoeringstijden op een bepaalde computer.

Een zoekactie in een ArrayList kan elk element controleren; wijzigingen aan het begin verschuiven latere elementen. Een LinkedList moet naar een positie lopen, dus herhaald benaderen via een index kan veel kosten. ArrayList is een bruikbare standaardkeuze voor gewoon werk met lijsten.

Herken het herhaald doorzoeken

Stel dat een programma 10.000 namen controleert tegen een lijst met 100.000 namen. Voor elke naam list.contains(name) aanroepen kan maximaal 1.000.000.000 gelijkheidscontroles vereisen. Een methodeaanroep die er snel uitziet, blijft bij dit gebruik een volledige zoekactie.

Maak één keer een verzameling voor lidmaatschap:

Set<String> allowed = new HashSet<>(allowedNames);
int matches = 0;
for (String name : incomingNames) {
    if (allowed.contains(name)) {
        matches++;
    }
}

Het opbouwen van de verzameling met 100.000 elementen kost werk, gevolgd door 10.000 lidmaatschapscontroles die gemiddeld constante tijd kosten. Als je beide fasen meetelt, groeit het totaal ongeveer met de som van de twee invoergroottes, in plaats van met hun product. Als je de verzameling binnen de lus opnieuw zou opbouwen, herhaal je het opbouwwerk en gaat dat voordeel verloren.

Lees gemiddelde garanties correct

Hashbewerkingen vertrouwen op sleutels waarvan de hashcodes waarden goed spreiden. Voor elk object één constante hashcode teruggeven kan nog steeds voldoen aan de eisen voor correcte gelijkheid, maar maakt het opzoeken traag. Het is geen kosteloze manier om het schrijven van een bruikbare hashmethode te vermijden.

Tree-collecties behouden een gesorteerde volgorde met basisbewerkingen in logaritmische tijd. Een verdubbeling van het aantal elementen voegt maar een kleine hoeveelheid zoekwerk toe. Voor 100.000 elementen is een logaritme met grondtal twee ongeveer 16,6; dit geeft een indruk van de omvang van de zoekactie, geen exacte garantie van 17 vergelijkingen bij elke zoekactie in een Java-boom.

Houd rekening met de hele taak

Een extra verzameling opbouwen kost tijd en geheugen. Voor enkele elementen of één zoekactie kan de oorspronkelijke lijst voldoende zijn. Voor herhaalde lidmaatschapscontroles neemt één herbruikbare verzameling vaak de belangrijkste kosten weg. Begin bij het vereiste gedrag en onderzoek daarna de bewerkingen die het vaakst worden herhaald.

De juiste collectie bewaart de informatie die het programma nodig heeft en maakt de belangrijkste vragen eenvoudig uit te drukken. Bepaal de regels voor de gegevens voordat je een vertrouwde klassenaam kiest.

Vraag wat een element identificeert

Een double[12] kan de neerslag in millimeters bevatten wanneer van elke plaats de maand bekend is. Een map met alleen posities 0, 1, 2 enzovoort als sleutels voegt een laag toe die een lijst of array al biedt.

Kies de volgorde die je nodig hebt

Gebruik voor maps en verzamelingen HashMap of HashSet als geen volgorde vereist is, LinkedHashMap of LinkedHashSet voor invoegvolgorde en TreeMap of TreeSet voor gesorteerde sleutels of elementen. Begin voor een lijst voor algemeen gebruik met ArrayList.

Alfabetisch weergegeven woordtellingen passen bij een TreeMap<String, Integer>. Een lijst met unieke labels in de volgorde waarin ze voor het eerst voorkwamen, past bij LinkedHashSet<String>. Herhaalde nummers vereisen een lijst, ook als de nummers elders in een verzameling zijn opgeslagen: herhalingen weggooien zou de afspeellijst veranderen.

Combineer collecties als de gegevens uit lagen bestaan

Studenten per cursus kunnen een Map<String, List<String>> vormen; elke waarde is een geordende lijst met inschrijvingen. Labels per artikel kunnen een Map<String, Set<String>> vormen; elk artikel krijgt unieke labels. Een ranglijst kan een List<Player> zijn die is gesorteerd volgens de natuurlijke vergelijking van de speler.

De keuze voor de buitenste en binnenste collectie beantwoordt verschillende vragen. Als cursussen alfabetisch moeten worden vermeld en studenten in volgorde van inschrijving moeten worden bewaard, gebruik dan buiten een TreeMap en binnen een lijst. Het sorteren van de sleutels sorteert de lijsten niet. Als dubbele inschrijvingen moeten worden genegeerd, gebruik dan een verzameling voor de binnenste groepen.

Houd verwante gegevens bij elkaar

Twee parallelle lijsten, één voor namen en één voor telefoonnummers, vertrouwen op overeenkomende posities. Als je een naam zonder het bijbehorende nummer verwijdert, klopt elke latere koppeling niet meer. Als namen personen uniek identificeren, kan een map de koppeling bewaren. Als namen vaker voorkomen of meerdere velden bij één persoon horen, bewaar dan objecten die personen voorstellen in een lijst of indexeer ze op een unieke ID.

Een lijst steeds opnieuw op een veld doorzoeken is een ander signaal om een indexmap te overwegen. Bewaar de lijst ook als weergavevolgorde en herhaalde elementen van belang zijn, maar werk beide structuren samen bij wanneer gegevens worden toegevoegd of verwijderd.

Controleer de elementregels en het gedeclareerde type

Gebruik een interfacedeclaratie zoals Map<String, Double> prices = new HashMap<>(); zodat aanroepers kunnen vertrouwen op de mapbewerkingen die ze nodig hebben. Hashcollecties hebben zinvolle gelijkheid en bijpassende hashcodes nodig voor zelfgemaakte sleutels of elementen. Standaard hebben tree-collecties een natuurlijke vergelijking nodig die precies de waarden onderscheidt die de collectie moet bewaren. Deze regels horen bij het laten weergeven van de bedoelde gegevens door de gekozen collectie.