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? | Sektion
Fundamentale Datastrukturer i Java

Hvad 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


              
1

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

Her ser du, at der i generics eller diamantbeslag 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 metoderne defineret i Map interfacet.

Metoder

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

Main.java

Main.java


              
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 angiver vi nøglen for at hente den tilsvarende værdi.

Lad os hente værdien med nøgle 2:

Main.java

Main.java


              
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.

Lad os se på et eksempel:

Main.java

Main.java


              
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 der for 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


              
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øgle.

Grundlæggende metoder til håndtering af Maps

Dernæst er der metoder, du allerede kender, som jeg vil opremse 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


              
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


              
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 hjælp af 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


              
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å brugen 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


              
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


              
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 wrapper-klassen blev anvendt. Hvis du ikke forstår, hvordan det fungerer, kan det forklares således:

Main.java

Main.java


              
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 der sker, 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 gennemløbe 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øgler og hente de tilsvarende værdier.

Main.java

Main.java


              
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 bruges til at gennemløbe værdierne.

Main.java

Main.java


              
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


              
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 nærmere. Indledningsvis kan det virke ekstremt komplekst at forstå, men det er ikke nødvendigt at kende detaljerne om, 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øgle og værdi 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 passende studerende findes, tilføjes deres nøgler til en forudoprettet ArrayList:

Main.java

Main.java


              
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 itererer man gennem alle nøgler i et Map ved hjælp af en for-each-løkke?

3. Hvad er formålet med metoden values() 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 et Map i Java?

question mark

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

Vælg det korrekte svar

question mark

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

Vælg det korrekte svar

question mark

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

Vælg det korrekte svar

question mark

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

Vælg det korrekte svar

question mark

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

Vælg det korrekte svar

Var alt klart?

Hvordan kan vi forbedre det?

Tak for dine kommentarer!

Sektion 1. Kapitel 13

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

Sektion 1. Kapitel 13
some-alt