Notice: This page requires JavaScript to function properly.
Please enable JavaScript in your browser settings or update your browser.Lære Hvad er et Map? | Mestring af Map i Java
Learn
Kurser
Learning Tracks
Popular Topics
Practice
Projects
Quizzes & Challenges
Quizzes
Challenges
/
Java Datastrukturer

bookHvad er et Map?

Vi vil diskutere Map-interfacet i Java. Map-interfacet er en del af Java Collections framework og definerer metoder til at arbejde med data i form af nøgle-værdi-par.

Lad os se på definitionen:

Den primære implementering af en sådan datastruktur i Java er HashMap, som implementerer Map-interfacet. Lad os undersøge de vigtigste metoder og driftsprincipperne for denne implementering.

Vi starter med deklaration og metoder:

Main.java

Main.java

copy

              
1

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

Her ser du, at der i generics eller diamant-parenteser er angivet to værdier:

  • Værdien K svarer til datatypen for nøglen;
  • Værdien V svarer til datatypen for værdien.

Når vi erklærer denne datastruktur, angiver vi altså datatyperne for vores nøgle-værdi-par.

Lad os nu undersøge de metoder, der er defineret i Map interfacet.

Metoder

V put(K key, V value): knytter den angivne værdi til den angivne nøgle i denne Map. Hvis Map tidligere indeholdt en mapping for nøglen, erstattes den gamle værdi.

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 værdien, som den angivne nøgle er knyttet til, eller null hvis denne Map ikke indeholder en mapping for nøglen.

Her angives nøglen for at hente den tilsvarende værdi.

Eksempel på at hente værdien med nøgle 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 indeholder en mapping for den angivne nøgle;

  • boolean containsValue(Object value): returnerer true, hvis Map indeholder en eller flere nøgler, der er knyttet til den angivne værdi.

Disse to metoder er tydeligvis relaterede, og de hjælper med at afgøre, om den angivne Map indeholder de ønskede nøgler eller værdier. Disse metoder er praktiske at bruge som betingelser, da de returnerer boolean værdier.

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 af en nøgle og tilstedeværelsen af en værdi i Map. Hvis værdierne findes, vises de på konsollen. Hvis der ikke findes sådanne værdier, vises meddelelser, der angiver fraværet af sådanne data.

  • boolean isEmpty(): returnerer true, hvis denne Map ikke indeholder nogen nøgle-værdi-par;

  • V remove(Object key): fjerner mappingen for den angivne nøgle fra denne Map, hvis den findes, og returnerer den tidligere værdi.

Ligesom 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 via nøgle.

Grundlæggende metoder til håndtering af Maps

Dernæst er der metoder, du allerede kender, som jeg vil opliste uden eksempler. Men der er også interessante metoder tilbage.

Lad os starte med det grundlæggende:

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

  • int size(): returnerer antallet af nøgle-værdi-par i denne Map;

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

Nu går vi videre til metoder, der returnerer en samling med værdier (eller nøgler) fra Map. Med andre ord henter vi fra datastrukturen en nøgle-værdi-struktur, der kun gemmer værdier (eller nøgler). 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 opnået en samling af værdier fra Map. Nu kan vi overføre denne samling 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 initialiserede en ArrayList ved at bruge værdier fra Map.

Der findes også en metode, der returnerer nøgler fra Map. Disse nøgler returneres dog i form af en struktur kaldet et Set. Vi vil ikke gå i dybden med denne datastruktur nu; det er dog værd at nævne, at et Set er en datastruktur, der udelukkende indeholder unikke værdier.

Lad os se på denne metode:

Set<K> keySet(): returnerer et Set-view af nøglerne, der findes 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 et sæt af alle nøgler fra Map.

Det ser ud til, at vi er færdige med metoderne. Lad os nu se på anvendelsen af Map samt praktiske eksempler:

Anvendelse af Map

En struktur som nøgle-værdi har mange praktiske anvendelser. Lad os overveje den simpleste af disse strukturer: et karaktersystem for studerende.

Lad os oprette en Map, hvor nøglen er af typen String, som repræsenterer studerendes navn, og værdien er af typen Integer, som repræsenterer studerendes karakter. På denne måde kan du tildele karakterer til studerende og nemt hente karakteren for en bestemt studerende ved hjælp af nøglen:

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);
    }
}

Forestil dig nu, at vi skal hente karaktererne for Mike og Alice, og derefter sammenligne dem. Dette kan nemt opnås ved hjælp af de metoder, du har lært ovenfor. Lad os 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");
    }
}

Den ternære operator og metoden compareTo() fra Integer wrapper-klassen blev anvendt. Hvis du ikke forstår, hvordan det fungerer, kan det forklares således:

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");
        }
    }
}

Lad os nu overveje, hvad vi gør, hvis vi bliver bedt om at indsamle alle studerende med en karakter højere end 7 (eksklusive 7). Dette bliver interessant, og jeg vil nu forklare dig, hvordan du gør det!

Iteration gennem Map

Gennemløb af elementer i et Map i Java kan udføres ved hjælp af forskellige metoder, som tilbydes af Map-interfacet og dets implementeringer. Her er flere måder at iterere gennem et Map på:

Gennemløb af nøgler (keySet()): Metoden keySet() returnerer et sæt af alle nøgler i Map. Dette sæt kan bruges til at gennemløbe nøglerne og hente de tilsvarende værdier.

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);
        }
    }
}

Gennemløb af værdier (values()): Metoden values() returnerer en samling af alle værdier i Map. Denne samling kan anvendes til at gennemløbe værdierne.

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);
        }
    }
}

Gennemløb af nøgle-værdi-par (entrySet()): Metoden entrySet() returnerer et sæt af Map.Entry-objekter, der repræsenterer nøgle-værdi-par. Dette muliggør direkte gennemløb af parrene.

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);
        }
    }
}

Lad os undersøge dette lidt nærmere. Indledningsvis kan det virke ekstremt komplekst at forstå, men det er ikke nødvendigt at kende detaljerne i, hvordan det fungerer, da syntaksen altid er den samme.

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

Ved at bruge entry-objektet kan du samtidig tilgå både nøglen og værdien i Map. Nu skal vi løse den tidligere stillede opgave ved hjælp af entry set: find alle studerende med en karakter højere end 7. Til dette anvendes et tjek via entry.getValue(), og når vi finder egnede studerende, henter vi deres nøgler ind i en forudoprettet 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 gennem Map og finde den ønskede liste af studerende, der bestod eksamen!

Entry set er et meget nyttigt værktøj, da det muliggør forskellige måder at iterere gennem Map ved hjælp af en løkke, hvor du har adgang til både nøglen og værdien.

I næste kapitel vil vi dykke ned i, hvordan HashMap, som vi har brugt så aktivt i dette kapitel, faktisk fungerer!

1. Hvilket interface i Java repræsenterer en samling af nøgle-værdi-par?

2. Hvordan itereres der gennem alle nøgler i et Map ved hjælp af en for-each løkke?

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

4. Hvilken metode bruges til at kontrollere, om en bestemt nøgle er til stede i et Map?

5. Hvilken metode bruges til at fjerne et nøgle-værdi-par fra en Map i Java?

question mark

Hvilket interface i Java repræsenterer en samling af nøgle-værdi-par?

Select the correct answer

question mark

Hvordan itereres der gennem alle nøgler i et Map ved hjælp af en for-each løkke?

Select the correct answer

question mark

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

Select the correct answer

question mark

Hvilken metode bruges til at kontrollere, om en bestemt nøgle er til stede i et Map?

Select the correct answer

question mark

Hvilken metode bruges til at fjerne et nøgle-værdi-par fra en Map i Java?

Select the correct answer

Var alt klart?

Hvordan kan vi forbedre det?

Tak for dine kommentarer!

Sektion 3. Kapitel 1

Spørg AI

expand

Spørg AI

ChatGPT

Spørg om hvad som helst eller prøv et af de foreslåede spørgsmål for at starte vores chat

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?

bookHvad er et Map?

Stryg for at vise menuen

Vi vil diskutere Map-interfacet i Java. Map-interfacet er en del af Java Collections framework og definerer metoder til at arbejde med data i form af nøgle-værdi-par.

Lad os se på definitionen:

Den primære implementering af en sådan datastruktur i Java er HashMap, som implementerer Map-interfacet. Lad os undersøge de vigtigste metoder og driftsprincipperne for denne implementering.

Vi starter med deklaration og metoder:

Main.java

Main.java

copy

              
1

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

Her ser du, at der i generics eller diamant-parenteser er angivet to værdier:

  • Værdien K svarer til datatypen for nøglen;
  • Værdien V svarer til datatypen for værdien.

Når vi erklærer denne datastruktur, angiver vi altså datatyperne for vores nøgle-værdi-par.

Lad os nu undersøge de metoder, der er defineret i Map interfacet.

Metoder

V put(K key, V value): knytter den angivne værdi til den angivne nøgle i denne Map. Hvis Map tidligere indeholdt en mapping for nøglen, erstattes den gamle værdi.

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 værdien, som den angivne nøgle er knyttet til, eller null hvis denne Map ikke indeholder en mapping for nøglen.

Her angives nøglen for at hente den tilsvarende værdi.

Eksempel på at hente værdien med nøgle 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 indeholder en mapping for den angivne nøgle;

  • boolean containsValue(Object value): returnerer true, hvis Map indeholder en eller flere nøgler, der er knyttet til den angivne værdi.

Disse to metoder er tydeligvis relaterede, og de hjælper med at afgøre, om den angivne Map indeholder de ønskede nøgler eller værdier. Disse metoder er praktiske at bruge som betingelser, da de returnerer boolean værdier.

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 af en nøgle og tilstedeværelsen af en værdi i Map. Hvis værdierne findes, vises de på konsollen. Hvis der ikke findes sådanne værdier, vises meddelelser, der angiver fraværet af sådanne data.

  • boolean isEmpty(): returnerer true, hvis denne Map ikke indeholder nogen nøgle-værdi-par;

  • V remove(Object key): fjerner mappingen for den angivne nøgle fra denne Map, hvis den findes, og returnerer den tidligere værdi.

Ligesom 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 via nøgle.

Grundlæggende metoder til håndtering af Maps

Dernæst er der metoder, du allerede kender, som jeg vil opliste uden eksempler. Men der er også interessante metoder tilbage.

Lad os starte med det grundlæggende:

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

  • int size(): returnerer antallet af nøgle-værdi-par i denne Map;

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

Nu går vi videre til metoder, der returnerer en samling med værdier (eller nøgler) fra Map. Med andre ord henter vi fra datastrukturen en nøgle-værdi-struktur, der kun gemmer værdier (eller nøgler). 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 opnået en samling af værdier fra Map. Nu kan vi overføre denne samling 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 initialiserede en ArrayList ved at bruge værdier fra Map.

Der findes også en metode, der returnerer nøgler fra Map. Disse nøgler returneres dog i form af en struktur kaldet et Set. Vi vil ikke gå i dybden med denne datastruktur nu; det er dog værd at nævne, at et Set er en datastruktur, der udelukkende indeholder unikke værdier.

Lad os se på denne metode:

Set<K> keySet(): returnerer et Set-view af nøglerne, der findes 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 et sæt af alle nøgler fra Map.

Det ser ud til, at vi er færdige med metoderne. Lad os nu se på anvendelsen af Map samt praktiske eksempler:

Anvendelse af Map

En struktur som nøgle-værdi har mange praktiske anvendelser. Lad os overveje den simpleste af disse strukturer: et karaktersystem for studerende.

Lad os oprette en Map, hvor nøglen er af typen String, som repræsenterer studerendes navn, og værdien er af typen Integer, som repræsenterer studerendes karakter. På denne måde kan du tildele karakterer til studerende og nemt hente karakteren for en bestemt studerende ved hjælp af nøglen:

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);
    }
}

Forestil dig nu, at vi skal hente karaktererne for Mike og Alice, og derefter sammenligne dem. Dette kan nemt opnås ved hjælp af de metoder, du har lært ovenfor. Lad os 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");
    }
}

Den ternære operator og metoden compareTo() fra Integer wrapper-klassen blev anvendt. Hvis du ikke forstår, hvordan det fungerer, kan det forklares således:

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");
        }
    }
}

Lad os nu overveje, hvad vi gør, hvis vi bliver bedt om at indsamle alle studerende med en karakter højere end 7 (eksklusive 7). Dette bliver interessant, og jeg vil nu forklare dig, hvordan du gør det!

Iteration gennem Map

Gennemløb af elementer i et Map i Java kan udføres ved hjælp af forskellige metoder, som tilbydes af Map-interfacet og dets implementeringer. Her er flere måder at iterere gennem et Map på:

Gennemløb af nøgler (keySet()): Metoden keySet() returnerer et sæt af alle nøgler i Map. Dette sæt kan bruges til at gennemløbe nøglerne og hente de tilsvarende værdier.

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);
        }
    }
}

Gennemløb af værdier (values()): Metoden values() returnerer en samling af alle værdier i Map. Denne samling kan anvendes til at gennemløbe værdierne.

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);
        }
    }
}

Gennemløb af nøgle-værdi-par (entrySet()): Metoden entrySet() returnerer et sæt af Map.Entry-objekter, der repræsenterer nøgle-værdi-par. Dette muliggør direkte gennemløb af parrene.

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);
        }
    }
}

Lad os undersøge dette lidt nærmere. Indledningsvis kan det virke ekstremt komplekst at forstå, men det er ikke nødvendigt at kende detaljerne i, hvordan det fungerer, da syntaksen altid er den samme.

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

Ved at bruge entry-objektet kan du samtidig tilgå både nøglen og værdien i Map. Nu skal vi løse den tidligere stillede opgave ved hjælp af entry set: find alle studerende med en karakter højere end 7. Til dette anvendes et tjek via entry.getValue(), og når vi finder egnede studerende, henter vi deres nøgler ind i en forudoprettet 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 gennem Map og finde den ønskede liste af studerende, der bestod eksamen!

Entry set er et meget nyttigt værktøj, da det muliggør forskellige måder at iterere gennem Map ved hjælp af en løkke, hvor du har adgang til både nøglen og værdien.

I næste kapitel vil vi dykke ned i, hvordan HashMap, som vi har brugt så aktivt i dette kapitel, faktisk fungerer!

1. Hvilket interface i Java repræsenterer en samling af nøgle-værdi-par?

2. Hvordan itereres der gennem alle nøgler i et Map ved hjælp af en for-each løkke?

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

4. Hvilken metode bruges til at kontrollere, om en bestemt nøgle er til stede i et Map?

5. Hvilken metode bruges til at fjerne et nøgle-værdi-par fra en Map i Java?

question mark

Hvilket interface i Java repræsenterer en samling af nøgle-værdi-par?

Select the correct answer

question mark

Hvordan itereres der gennem alle nøgler i et Map ved hjælp af en for-each løkke?

Select the correct answer

question mark

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

Select the correct answer

question mark

Hvilken metode bruges til at kontrollere, om en bestemt nøgle er til stede i et Map?

Select the correct answer

question mark

Hvilken metode bruges til at fjerne et nøgle-værdi-par fra en Map i Java?

Select the correct answer

Var alt klart?

Hvordan kan vi forbedre det?

Tak for dine kommentarer!

Sektion 3. Kapitel 1
some-alt