Notice: This page requires JavaScript to function properly.
Please enable JavaScript in your browser settings or update your browser.Lære Hva er Map? | Mastering Map in Java
Java Datastrukturer

bookHva er Map?

Vi skal diskutere Map-grensesnittet i Java. Map-grensesnittet er en del av Java Collections-rammeverket og definerer metoder for å arbeide med data i form av nøkkel-verdi-par.

La oss se på definisjonen:

Den primære implementasjonen av en slik datastruktur i Java er HashMap, som implementerer Map-grensesnittet. La oss utforske de viktigste metodene og driftsprinsippene for denne implementasjonen.

Vi starter med deklarasjon og metoder:

Main.java

Main.java

copy

              
1

            
Map<K, V> map = new HashMap<>();

Her ser du at i generics eller diamantklammer, er to verdier spesifisert:

  • Verdien K tilsvarer datatypen til nøkkelen;
  • Verdien V tilsvarer datatypen til verdien.

Dermed angir vi datatypene for våre nøkkel-verdi-par når vi erklærer denne datastrukturen.

La oss nå se nærmere på metodene som er definert i Map-grensesnittet.

Metoder

V put(K key, V value): knytter den spesifiserte verdien til den spesifiserte nøkkelen i denne Map. Hvis Map tidligere inneholdt en tilordning for nøkkelen, blir gammel verdi erstattet.

Main.java

Main.java

copy

              
1234567891011121314

            
package com.example;

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "One");
        map.put(2, "Two");
        map.put(3, "Three");
        System.out.println(map);
    }
}

V get(Object key): returnerer verdien som den angitte nøkkelen er tilordnet, eller null hvis denne Map ikke inneholder noen tilordning for nøkkelen.

Her spesifiserer vi nøkkelen for å hente ut tilsvarende verdi.

Vi henter verdien med nøkkel 2:

Main.java

Main.java

copy

              
12345678910111213141516

            
package com.example;

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "One");
        map.put(2, "Two");
        map.put(3, "Three");
        System.out.println("Map: " + map);
        String value = map.get(2);
        System.out.println("Value: " + value);
    }
}

  • boolean containsKey(Object key): returnerer true hvis Map inneholder en tilordning for den spesifiserte nøkkelen;

  • boolean containsValue(Object value): returnerer true hvis Map inneholder én eller flere nøkler tilordnet den spesifiserte verdien.

Disse to metodene er åpenbart relatert, og de hjelper med å avgjøre om den angitte Map inneholder de ønskede nøklene eller verdiene. Disse metodene er praktiske å bruke som betingelser siden de returnerer boolean-verdier.

Vi ser på et eksempel:

Main.java

Main.java

copy

              
12345678910111213141516171819202122232425

            
package com.example;

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "One");
        map.put(2, "Two");
        map.put(3, "Three");
        System.out.println("Map: " + map);
        if (map.containsKey(2)) {
            System.out.println("Value with key 2: " + map.get(2));
        } else {
            System.out.println("There is no value with key 2!");
        }

        if (map.containsValue("Four")) {
            System.out.println(map.get(4));
        } else {
            System.out.println("There is no key with value \"Four\"!");
        }
    }
}

I eksemplet ovenfor kontrolleres tilstedeværelsen av en nøkkel og tilstedeværelsen av en verdi i Map. Hvis verdier finnes, vises de i konsollen. Hvis det ikke finnes slike verdier, vises meldinger som indikerer fravær av slike data.

  • boolean isEmpty(): returnerer true hvis denne Map ikke inneholder noen nøkkel-verdi-par;

  • V remove(Object key): fjerner tilordningen for den spesifiserte nøkkelen fra denne Map hvis den finnes, og returnerer den forrige verdien.

Akkurat som i andre datastrukturer kan du fjerne elementer fra Map.

Main.java

Main.java

copy

              
12345678910111213141516

            
package com.example;

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "One");
        map.put(2, "Two");
        map.put(3, "Three");
        System.out.println("Map: " + map);
        String removedElement = map.remove(3);
        System.out.println("Removed value: " + removedElement + ".\nMap after the removal operation: " + map);
    }
}

Dermed kan vi fjerne elementer ved nøkkel.

Grunnleggende metoder for håndtering av Maps

Videre finnes det metoder du allerede er kjent med, som jeg vil liste opp uten eksempler. Men det finnes også interessante metoder igjen.

La oss starte med det grunnleggende:

  • void clear(): fjerner alle elementer fra Map;

  • int size(): returnerer antall nøkkel-verdi-par i denne Map;

  • void putAll(Map<? extends K, ? extends V> m): kopierer alle parene fra den angitte Map til denne Map.

Nå går vi videre til metodene som returnerer en samling med verdier (eller nøkler) fra Map. Med andre ord, vi henter ut fra datastrukturen en nøkkel-verdi-struktur som kun lagrer verdier (eller nøkler). For eksempel, ArrayList<>.

Main.java

Main.java

copy

              
12345678910111213141516

            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "One");
        map.put(2, "Two");
        map.put(3, "Three");
        System.out.println("Map: " + map);
        Collection<String> list;
        list = map.values();
        System.out.println("Values" + list);
    }
}

Her har vi hentet ut en samling av verdier fra Map. Nå kan vi overføre denne samlingen til en ArrayList:

Main.java

Main.java

copy

              
123456789101112131415161718

            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "One");
        map.put(2, "Two");
        map.put(3, "Three");
        System.out.println("Map: " + map);
        Collection<String> collection;
        collection = map.values();
        System.out.println("Values" + collection);
        List<String> arrayList = new ArrayList<>(collection);
        System.out.println("ArrayList: " + arrayList);
    }
}

Vi initialiserte en ArrayList ved å bruke verdier fra Map.

Det finnes også en metode som returnerer nøkler fra Map. Disse nøklene returneres imidlertid som en struktur kalt Set. Vi skal ikke gå nærmere inn på denne datastrukturen nå; det er verdt å nevne at en Set er en datastruktur som kun inneholder unike verdier.

La oss se på denne metoden:

Set<K> keySet(): returnerer en Set-visning av nøklene som finnes i denne Map.

Main.java

Main.java

copy

              
12345678910111213141516

            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "One");
        map.put(2, "Two");
        map.put(3, "Three");
        System.out.println("Map: " + map);
        Set<Integer> keys;
        keys = map.keySet();
        System.out.println("Keys: " + keys);
    }
}

Dermed kan vi også hente ut et sett av alle nøkler fra Map.

Vel, det ser ut til at vi er ferdige med metodene. La oss nå se på bruken av Map, samt praktiske eksempler:

Bruk av Map

En struktur som nøkkel-verdi har mange praktiske bruksområder. La oss se på det enkleste av disse: et karaktersystem for studenter.

Vi lager en Map der nøkkelen er av typen String, som representerer studentens navn, og verdien er av typen Integer, som representerer studentens karakter. På denne måten kan du tildele karakterer til studenter og enkelt hente karakteren til en bestemt student ved hjelp av nøkkelen:

Main.java

Main.java

copy

              
12345678910111213141516

            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> studentsGrades = new HashMap<>();
        studentsGrades.put("Bob", 9);
        studentsGrades.put("Alice", 8);
        studentsGrades.put("Mike", 5);
        studentsGrades.put("John", 10);
        studentsGrades.put("Martin", 7);
        studentsGrades.put("Peter", 5);
        System.out.println("Student's grades: " + studentsGrades);
    }
}

La oss nå forestille oss at vi skal hente karakterene til Mike og Alice, og deretter sammenligne dem. Dette kan enkelt utføres ved å bruke metodene du har lært ovenfor. La oss implementere dette i koden:

Main.java

Main.java

copy

              
123456789101112131415161718192021

            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> studentsGrades = new HashMap<>();
        studentsGrades.put("Bob", 9);
        studentsGrades.put("Alice", 8);
        studentsGrades.put("Mike", 5);
        studentsGrades.put("John", 10);
        studentsGrades.put("Martin", 7);
        studentsGrades.put("Peter", 5);
        System.out.println("Student's grades: " + studentsGrades);

        Integer mikeGrade = studentsGrades.get("Mike");
        Integer aliceGrade = studentsGrades.get("Alice");

        System.out.println(mikeGrade.compareTo(aliceGrade) == -1 ? "Alice's grade is higher": "Mike's grade is higher");
    }
}

Ternær operator og metoden compareTo() fra Integer-wrapperklassen ble brukt. Dersom du ikke forstår hvordan dette fungerer, kan det forklares slik:

Main.java

Main.java

copy

              
12345678910111213141516171819202122232425

            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> studentsGrades = new HashMap<>();
        studentsGrades.put("Bob", 9);
        studentsGrades.put("Alice", 8);
        studentsGrades.put("Mike", 5);
        studentsGrades.put("John", 10);
        studentsGrades.put("Martin", 7);
        studentsGrades.put("Peter", 5);
        System.out.println("Student's grades: " + studentsGrades);

        Integer mikeGrade = studentsGrades.get("Mike");
        Integer aliceGrade = studentsGrades.get("Alice");

        if (mikeGrade.compareTo(aliceGrade) == -1) {
            System.out.println("Alice's grade is higher");
        } else {
            System.out.println("Mike's grade is higher");
        }
    }
}

La oss nå vurdere hva som skjer hvis vi blir bedt om å samle alle studenter med en karakter høyere enn 7 (ekskludert 7). Dette blir interessant, og jeg skal nå forklare hvordan du kan gjøre det!

Iterasjon gjennom Map

Iterasjon over elementer i en Map i Java kan gjøres ved hjelp av ulike metoder som tilbys av Map-grensesnittet og dets implementasjoner. Her er flere måter å iterere gjennom en Map på:

Iterasjon over nøkler (keySet()): Metoden keySet() returnerer et sett med alle nøkler i Map. Du kan bruke dette settet til å iterere over nøklene og hente tilhørende verdier.

Main.java

Main.java

copy

              
12345678910111213141516

            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("Key1", 1);
        map.put("Key2", 2);

        for (String key : map.keySet()) {
            Integer value = map.get(key);
            System.out.println("Key: " + key + ", Value: " + value);
        }
    }
}

Iterering over verdier (values()): Metoden values() returnerer en samling av alle verdiene i Map. Denne samlingen kan brukes til å iterere over verdiene.

Main.java

Main.java

copy

              
123456789101112131415

            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("Key1", 1);
        map.put("Key2", 2);

        for (Integer value : map.values()) {
            System.out.println("Value: " + value);
        }
    }
}

Iterasjon over nøkkel-verdi-par (entrySet()): Metoden entrySet() returnerer et sett med Map.Entry-objekter som representerer nøkkel-verdi-par. Dette gjør det mulig å iterere direkte over parene.

Main.java

Main.java

copy

              
1234567891011121314151617

            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("Key1", 1);
        map.put("Key2", 2);

        for (Map.Entry<String, Integer> entry : map.entrySet()) {
            String key = entry.getKey();
            Integer value = entry.getValue();
            System.out.println("Key: " + key + ", Value: " + value);
        }
    }
}

La oss se litt nærmere på dette. I starten kan det virke ekstremt komplisert å forstå, men det er ikke nødvendig å gå inn i detaljene om hvordan det fungerer, siden syntaksen alltid er den samme.

Map.Entry<K, V> entry : map.entrySet()

Ved å bruke entry-objektet kan du samtidig få tilgang til både nøkkelen og verdien i Map. Nå skal vi løse oppgaven som ble gitt tidligere ved å bruke entry set: hent ut alle studenter med en karakter høyere enn 7. For dette bruker vi en sjekk med entry.getValue(), og når vi finner aktuelle studenter, henter vi deres nøkler inn i en forhåndsopprettet ArrayList:

Main.java

Main.java

copy

              
1234567891011121314151617181920212223242526

            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> studentsGrades = new HashMap<>();
        studentsGrades.put("Bob", 9);
        studentsGrades.put("Alice", 8);
        studentsGrades.put("Mike", 5);
        studentsGrades.put("John", 10);
        studentsGrades.put("Martin", 7);
        studentsGrades.put("Peter", 5);
        System.out.println("Student's grades: " + studentsGrades);
        
        List<String> studentsWithGradeHigherThanSeven = new ArrayList<>();
        
        for (Map.Entry<String, Integer> entry : studentsGrades.entrySet()) {
            if (entry.getValue() > 7) {
                studentsWithGradeHigherThanSeven.add(entry.getKey());
            }
        
        }
        System.out.println(studentsWithGradeHigherThanSeven);
    }
}

Dermed kan du iterere gjennom Map og finne ønsket liste over studenter som bestod eksamen!

Entry set er et svært nyttig verktøy fordi det gir flere måter å iterere gjennom Map ved hjelp av en løkke, med tilgang til både nøkkel og verdi.

I neste kapittel skal vi se nærmere på hvordan HashMap, som vi har brukt så aktivt i dette kapittelet, faktisk fungerer!

1. Hvilket grensesnitt i Java representerer en samling av nøkkel-verdi-par?

2. Hvordan itererer du gjennom alle nøkler i et Map ved bruk av en for-each-løkke?

3. Hva er formålet med values()-metoden i et Map?

4. Hvilken metode brukes for å sjekke om en spesifikk nøkkel finnes i et Map?

5. Hvilken metode brukes for å fjerne et nøkkel-verdi-par fra en Map i Java?

question mark

Hvilket grensesnitt i Java representerer en samling av nøkkel-verdi-par?

Select the correct answer

question mark

Hvordan itererer du gjennom alle nøkler i et Map ved bruk av en for-each-løkke?

Select the correct answer

question mark

Hva er formålet med values()-metoden i et Map?

Select the correct answer

question mark

Hvilken metode brukes for å sjekke om en spesifikk nøkkel finnes i et Map?

Select the correct answer

question mark

Hvilken metode brukes for å fjerne et nøkkel-verdi-par fra en Map i Java?

Select the correct answer

Alt var klart?

Hvordan kan vi forbedre det?

Takk for tilbakemeldingene dine!

Seksjon 3. Kapittel 1

Spør AI

expand

Spør AI

ChatGPT

Spør om hva du vil, eller prøv ett av de foreslåtte spørsmålene for å starte chatten vår

Suggested prompts:

Can you explain more about how HashMap handles collisions?

What are some other implementations of the Map interface besides HashMap?

Can you provide more practical examples of using Map in Java?

bookHva er Map?

Sveip for å vise menyen

Vi skal diskutere Map-grensesnittet i Java. Map-grensesnittet er en del av Java Collections-rammeverket og definerer metoder for å arbeide med data i form av nøkkel-verdi-par.

La oss se på definisjonen:

Den primære implementasjonen av en slik datastruktur i Java er HashMap, som implementerer Map-grensesnittet. La oss utforske de viktigste metodene og driftsprinsippene for denne implementasjonen.

Vi starter med deklarasjon og metoder:

Main.java

Main.java

copy

              
1

            
Map<K, V> map = new HashMap<>();

Her ser du at i generics eller diamantklammer, er to verdier spesifisert:

  • Verdien K tilsvarer datatypen til nøkkelen;
  • Verdien V tilsvarer datatypen til verdien.

Dermed angir vi datatypene for våre nøkkel-verdi-par når vi erklærer denne datastrukturen.

La oss nå se nærmere på metodene som er definert i Map-grensesnittet.

Metoder

V put(K key, V value): knytter den spesifiserte verdien til den spesifiserte nøkkelen i denne Map. Hvis Map tidligere inneholdt en tilordning for nøkkelen, blir gammel verdi erstattet.

Main.java

Main.java

copy

              
1234567891011121314

            
package com.example;

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "One");
        map.put(2, "Two");
        map.put(3, "Three");
        System.out.println(map);
    }
}

V get(Object key): returnerer verdien som den angitte nøkkelen er tilordnet, eller null hvis denne Map ikke inneholder noen tilordning for nøkkelen.

Her spesifiserer vi nøkkelen for å hente ut tilsvarende verdi.

Vi henter verdien med nøkkel 2:

Main.java

Main.java

copy

              
12345678910111213141516

            
package com.example;

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "One");
        map.put(2, "Two");
        map.put(3, "Three");
        System.out.println("Map: " + map);
        String value = map.get(2);
        System.out.println("Value: " + value);
    }
}

  • boolean containsKey(Object key): returnerer true hvis Map inneholder en tilordning for den spesifiserte nøkkelen;

  • boolean containsValue(Object value): returnerer true hvis Map inneholder én eller flere nøkler tilordnet den spesifiserte verdien.

Disse to metodene er åpenbart relatert, og de hjelper med å avgjøre om den angitte Map inneholder de ønskede nøklene eller verdiene. Disse metodene er praktiske å bruke som betingelser siden de returnerer boolean-verdier.

Vi ser på et eksempel:

Main.java

Main.java

copy

              
12345678910111213141516171819202122232425

            
package com.example;

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "One");
        map.put(2, "Two");
        map.put(3, "Three");
        System.out.println("Map: " + map);
        if (map.containsKey(2)) {
            System.out.println("Value with key 2: " + map.get(2));
        } else {
            System.out.println("There is no value with key 2!");
        }

        if (map.containsValue("Four")) {
            System.out.println(map.get(4));
        } else {
            System.out.println("There is no key with value \"Four\"!");
        }
    }
}

I eksemplet ovenfor kontrolleres tilstedeværelsen av en nøkkel og tilstedeværelsen av en verdi i Map. Hvis verdier finnes, vises de i konsollen. Hvis det ikke finnes slike verdier, vises meldinger som indikerer fravær av slike data.

  • boolean isEmpty(): returnerer true hvis denne Map ikke inneholder noen nøkkel-verdi-par;

  • V remove(Object key): fjerner tilordningen for den spesifiserte nøkkelen fra denne Map hvis den finnes, og returnerer den forrige verdien.

Akkurat som i andre datastrukturer kan du fjerne elementer fra Map.

Main.java

Main.java

copy

              
12345678910111213141516

            
package com.example;

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "One");
        map.put(2, "Two");
        map.put(3, "Three");
        System.out.println("Map: " + map);
        String removedElement = map.remove(3);
        System.out.println("Removed value: " + removedElement + ".\nMap after the removal operation: " + map);
    }
}

Dermed kan vi fjerne elementer ved nøkkel.

Grunnleggende metoder for håndtering av Maps

Videre finnes det metoder du allerede er kjent med, som jeg vil liste opp uten eksempler. Men det finnes også interessante metoder igjen.

La oss starte med det grunnleggende:

  • void clear(): fjerner alle elementer fra Map;

  • int size(): returnerer antall nøkkel-verdi-par i denne Map;

  • void putAll(Map<? extends K, ? extends V> m): kopierer alle parene fra den angitte Map til denne Map.

Nå går vi videre til metodene som returnerer en samling med verdier (eller nøkler) fra Map. Med andre ord, vi henter ut fra datastrukturen en nøkkel-verdi-struktur som kun lagrer verdier (eller nøkler). For eksempel, ArrayList<>.

Main.java

Main.java

copy

              
12345678910111213141516

            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "One");
        map.put(2, "Two");
        map.put(3, "Three");
        System.out.println("Map: " + map);
        Collection<String> list;
        list = map.values();
        System.out.println("Values" + list);
    }
}

Her har vi hentet ut en samling av verdier fra Map. Nå kan vi overføre denne samlingen til en ArrayList:

Main.java

Main.java

copy

              
123456789101112131415161718

            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "One");
        map.put(2, "Two");
        map.put(3, "Three");
        System.out.println("Map: " + map);
        Collection<String> collection;
        collection = map.values();
        System.out.println("Values" + collection);
        List<String> arrayList = new ArrayList<>(collection);
        System.out.println("ArrayList: " + arrayList);
    }
}

Vi initialiserte en ArrayList ved å bruke verdier fra Map.

Det finnes også en metode som returnerer nøkler fra Map. Disse nøklene returneres imidlertid som en struktur kalt Set. Vi skal ikke gå nærmere inn på denne datastrukturen nå; det er verdt å nevne at en Set er en datastruktur som kun inneholder unike verdier.

La oss se på denne metoden:

Set<K> keySet(): returnerer en Set-visning av nøklene som finnes i denne Map.

Main.java

Main.java

copy

              
12345678910111213141516

            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "One");
        map.put(2, "Two");
        map.put(3, "Three");
        System.out.println("Map: " + map);
        Set<Integer> keys;
        keys = map.keySet();
        System.out.println("Keys: " + keys);
    }
}

Dermed kan vi også hente ut et sett av alle nøkler fra Map.

Vel, det ser ut til at vi er ferdige med metodene. La oss nå se på bruken av Map, samt praktiske eksempler:

Bruk av Map

En struktur som nøkkel-verdi har mange praktiske bruksområder. La oss se på det enkleste av disse: et karaktersystem for studenter.

Vi lager en Map der nøkkelen er av typen String, som representerer studentens navn, og verdien er av typen Integer, som representerer studentens karakter. På denne måten kan du tildele karakterer til studenter og enkelt hente karakteren til en bestemt student ved hjelp av nøkkelen:

Main.java

Main.java

copy

              
12345678910111213141516

            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> studentsGrades = new HashMap<>();
        studentsGrades.put("Bob", 9);
        studentsGrades.put("Alice", 8);
        studentsGrades.put("Mike", 5);
        studentsGrades.put("John", 10);
        studentsGrades.put("Martin", 7);
        studentsGrades.put("Peter", 5);
        System.out.println("Student's grades: " + studentsGrades);
    }
}

La oss nå forestille oss at vi skal hente karakterene til Mike og Alice, og deretter sammenligne dem. Dette kan enkelt utføres ved å bruke metodene du har lært ovenfor. La oss implementere dette i koden:

Main.java

Main.java

copy

              
123456789101112131415161718192021

            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> studentsGrades = new HashMap<>();
        studentsGrades.put("Bob", 9);
        studentsGrades.put("Alice", 8);
        studentsGrades.put("Mike", 5);
        studentsGrades.put("John", 10);
        studentsGrades.put("Martin", 7);
        studentsGrades.put("Peter", 5);
        System.out.println("Student's grades: " + studentsGrades);

        Integer mikeGrade = studentsGrades.get("Mike");
        Integer aliceGrade = studentsGrades.get("Alice");

        System.out.println(mikeGrade.compareTo(aliceGrade) == -1 ? "Alice's grade is higher": "Mike's grade is higher");
    }
}

Ternær operator og metoden compareTo() fra Integer-wrapperklassen ble brukt. Dersom du ikke forstår hvordan dette fungerer, kan det forklares slik:

Main.java

Main.java

copy

              
12345678910111213141516171819202122232425

            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> studentsGrades = new HashMap<>();
        studentsGrades.put("Bob", 9);
        studentsGrades.put("Alice", 8);
        studentsGrades.put("Mike", 5);
        studentsGrades.put("John", 10);
        studentsGrades.put("Martin", 7);
        studentsGrades.put("Peter", 5);
        System.out.println("Student's grades: " + studentsGrades);

        Integer mikeGrade = studentsGrades.get("Mike");
        Integer aliceGrade = studentsGrades.get("Alice");

        if (mikeGrade.compareTo(aliceGrade) == -1) {
            System.out.println("Alice's grade is higher");
        } else {
            System.out.println("Mike's grade is higher");
        }
    }
}

La oss nå vurdere hva som skjer hvis vi blir bedt om å samle alle studenter med en karakter høyere enn 7 (ekskludert 7). Dette blir interessant, og jeg skal nå forklare hvordan du kan gjøre det!

Iterasjon gjennom Map

Iterasjon over elementer i en Map i Java kan gjøres ved hjelp av ulike metoder som tilbys av Map-grensesnittet og dets implementasjoner. Her er flere måter å iterere gjennom en Map på:

Iterasjon over nøkler (keySet()): Metoden keySet() returnerer et sett med alle nøkler i Map. Du kan bruke dette settet til å iterere over nøklene og hente tilhørende verdier.

Main.java

Main.java

copy

              
12345678910111213141516

            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("Key1", 1);
        map.put("Key2", 2);

        for (String key : map.keySet()) {
            Integer value = map.get(key);
            System.out.println("Key: " + key + ", Value: " + value);
        }
    }
}

Iterering over verdier (values()): Metoden values() returnerer en samling av alle verdiene i Map. Denne samlingen kan brukes til å iterere over verdiene.

Main.java

Main.java

copy

              
123456789101112131415

            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("Key1", 1);
        map.put("Key2", 2);

        for (Integer value : map.values()) {
            System.out.println("Value: " + value);
        }
    }
}

Iterasjon over nøkkel-verdi-par (entrySet()): Metoden entrySet() returnerer et sett med Map.Entry-objekter som representerer nøkkel-verdi-par. Dette gjør det mulig å iterere direkte over parene.

Main.java

Main.java

copy

              
1234567891011121314151617

            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("Key1", 1);
        map.put("Key2", 2);

        for (Map.Entry<String, Integer> entry : map.entrySet()) {
            String key = entry.getKey();
            Integer value = entry.getValue();
            System.out.println("Key: " + key + ", Value: " + value);
        }
    }
}

La oss se litt nærmere på dette. I starten kan det virke ekstremt komplisert å forstå, men det er ikke nødvendig å gå inn i detaljene om hvordan det fungerer, siden syntaksen alltid er den samme.

Map.Entry<K, V> entry : map.entrySet()

Ved å bruke entry-objektet kan du samtidig få tilgang til både nøkkelen og verdien i Map. Nå skal vi løse oppgaven som ble gitt tidligere ved å bruke entry set: hent ut alle studenter med en karakter høyere enn 7. For dette bruker vi en sjekk med entry.getValue(), og når vi finner aktuelle studenter, henter vi deres nøkler inn i en forhåndsopprettet ArrayList:

Main.java

Main.java

copy

              
1234567891011121314151617181920212223242526

            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> studentsGrades = new HashMap<>();
        studentsGrades.put("Bob", 9);
        studentsGrades.put("Alice", 8);
        studentsGrades.put("Mike", 5);
        studentsGrades.put("John", 10);
        studentsGrades.put("Martin", 7);
        studentsGrades.put("Peter", 5);
        System.out.println("Student's grades: " + studentsGrades);
        
        List<String> studentsWithGradeHigherThanSeven = new ArrayList<>();
        
        for (Map.Entry<String, Integer> entry : studentsGrades.entrySet()) {
            if (entry.getValue() > 7) {
                studentsWithGradeHigherThanSeven.add(entry.getKey());
            }
        
        }
        System.out.println(studentsWithGradeHigherThanSeven);
    }
}

Dermed kan du iterere gjennom Map og finne ønsket liste over studenter som bestod eksamen!

Entry set er et svært nyttig verktøy fordi det gir flere måter å iterere gjennom Map ved hjelp av en løkke, med tilgang til både nøkkel og verdi.

I neste kapittel skal vi se nærmere på hvordan HashMap, som vi har brukt så aktivt i dette kapittelet, faktisk fungerer!

1. Hvilket grensesnitt i Java representerer en samling av nøkkel-verdi-par?

2. Hvordan itererer du gjennom alle nøkler i et Map ved bruk av en for-each-løkke?

3. Hva er formålet med values()-metoden i et Map?

4. Hvilken metode brukes for å sjekke om en spesifikk nøkkel finnes i et Map?

5. Hvilken metode brukes for å fjerne et nøkkel-verdi-par fra en Map i Java?

question mark

Hvilket grensesnitt i Java representerer en samling av nøkkel-verdi-par?

Select the correct answer

question mark

Hvordan itererer du gjennom alle nøkler i et Map ved bruk av en for-each-løkke?

Select the correct answer

question mark

Hva er formålet med values()-metoden i et Map?

Select the correct answer

question mark

Hvilken metode brukes for å sjekke om en spesifikk nøkkel finnes i et Map?

Select the correct answer

question mark

Hvilken metode brukes for å fjerne et nøkkel-verdi-par fra en Map i Java?

Select the correct answer

Alt var klart?

Hvordan kan vi forbedre det?

Takk for tilbakemeldingene dine!

Seksjon 3. Kapittel 1
some-alt