Notice: This page requires JavaScript to function properly.
Please enable JavaScript in your browser settings or update your browser.Lära Vad är en Map? | Behärska Map i Java
Java Datastrukturer

bookVad är en Map?

Vi kommer att diskutera gränssnittet Map i Java. Gränssnittet Map är en del av Java Collections framework och definierar metoder för att arbeta med data i form av nyckel-värde-par.

Låt oss titta på definitionen:

Den primära implementationen av en sådan datastruktur i Java är HashMap, som implementerar gränssnittet Map. Låt oss utforska de viktigaste metoderna och principerna för hur denna implementation fungerar.

Vi börjar med deklaration och metoder:

Main.java

Main.java

copy

              
1

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

Här ser du att i generics eller diamantparenteser anges två värden:

  • Värdet K motsvarar datatypen för nyckeln;
  • Värdet V motsvarar datatypen för värdet.

När vi deklarerar denna datastruktur anger vi alltså datatyperna för våra nyckel-värde-par.

Nu ska vi granska metoderna som definieras i Map -gränssnittet.

Metoder

V put(K key, V value): associerar det angivna värdet med den angivna nyckeln i denna Map. Om Map tidigare innehöll en koppling för nyckeln, ersätts det gamla värdet.

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): returnerar värdet som den angivna nyckeln är kopplad till, eller null om denna Map inte innehåller någon koppling för nyckeln.

Här anger vi nyckeln för att hämta det motsvarande värdet.

Vi hämtar värdet med nyckel 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): returnerar true om Map innehåller en koppling för den angivna nyckeln;

  • boolean containsValue(Object value): returnerar true om Map innehåller en eller flera nycklar kopplade till det angivna värdet.

Dessa två metoder är uppenbart relaterade, och de hjälper till att avgöra om den angivna Map innehåller de önskade nycklarna eller värdena. Dessa metoder är praktiska att använda som villkor eftersom de returnerar boolean-värden.

Vi tittar på ett exempel:

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 exemplet ovan kontrolleras förekomsten av en nyckel och förekomsten av ett värde i Map. Om värden hittas visas de i konsolen. Om det inte finns sådana värden, skrivs meddelanden ut som indikerar avsaknad av sådan data.

  • boolean isEmpty(): returnerar true om denna Map inte innehåller några nyckel-värde-par;

  • V remove(Object key): tar bort kopplingen för den angivna nyckeln från denna Map om den finns och returnerar det tidigare värdet.

Precis som i andra datastrukturer kan du ta bort element från 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);
    }
}

Således kan vi ta bort element med nyckel.

Grundläggande metoder för hantering av Map

Härnäst finns det metoder du redan är bekant med, vilka jag listar utan exempel. Men det finns också intressanta metoder kvar.

Vi börjar med grunderna:

  • void clear(): tar bort alla element från Map;

  • int size(): returnerar antalet nyckel-värde-par i denna Map;

  • void putAll(Map<? extends K, ? extends V> m): kopierar alla mappningar från den angivna Map till denna Map.

Nu går vi vidare till metoder som returnerar en samling med värden (eller nycklar) från Map. Med andra ord hämtar vi från datastrukturen en nyckel-värde-struktur som endast lagrar värden (eller nycklar). Till exempel, 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);
    }
}

Här har vi hämtat en samling värden från Map. Nu kan vi överföra denna samling till 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 initierade en ArrayList med värden från Map.

Det finns även en metod som returnerar nycklar från Map. Dessa nycklar returneras dock i form av en struktur som kallas Set. Vi kommer inte att gå in på denna datastruktur nu; det är värt att nämna att en Set är en datastruktur som endast innehåller unika värden.

Låt oss titta på denna metod:

Set<K> keySet(): returnerar en Set-vy av nycklarna som finns i denna 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);
    }
}

Således kan vi också hämta en mängd av alla nycklar från Map.

Det verkar som att vi är klara med metoderna. Låt oss nu titta på användningen av Map, samt praktiska exempel:

Användning av Map

En struktur som nyckel-värde har många praktiska tillämpningar. Låt oss betrakta den enklaste av dessa strukturer: ett betygssystem för studenter.

Vi skapar en Map där nyckeln är av typen String, vilket representerar studentens namn, och värdet är av typen Integer, vilket representerar studentens betyg. På detta sätt kan du tilldela betyg till studenter och enkelt hämta betyget för en specifik student med hjälp av nyckeln:

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

Föreställ dig nu att vi har i uppgift att hämta betygen för Mike och Alice, och sedan jämföra dem. Du kan enkelt åstadkomma detta med hjälp av de metoder du har lärt dig ovan. Låt oss implementera detta 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 och metoden compareTo() från omslagsklassen Integer användes. Om du inte förstår hur det fungerar kan det förklaras enligt följande:

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

Låt oss nu överväga vad som händer om vi ombeds att samla alla studenter med ett betyg högre än 7 (exklusive 7). Detta blir intressant, och jag kommer nu att förklara hur du gör det!

Iteration genom Map

Att iterera över element i en Map i Java kan göras med olika metoder som tillhandahålls av Map-gränssnittet och dess implementationer. Här är flera sätt att iterera över en Map:

Iterera över nycklar (keySet()): metoden keySet() returnerar en mängd av alla nycklar i Map. Du kan använda denna mängd för att iterera över nycklar och hämta motsvarande värden.

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

Iterera över värden (values()): Metoden values() returnerar en samling av alla värden i Map. Denna samling kan användas för att iterera över värdena.

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

Iterera över nyckel-värde-par (entrySet()): Metoden entrySet() returnerar en mängd av Map.Entry-objekt som representerar nyckel-värde-par. Detta möjliggör iteration direkt över paren.

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

Låt oss fördjupa oss lite mer i detta. Inledningsvis kan det verka otroligt komplext att förstå, men du behöver inte gå in på detaljer om hur det fungerar, eftersom syntaxen alltid är densamma.

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

Med hjälp av entry-objektet kan du samtidigt komma åt både nyckeln och värdet i Map. Nu ska vi lösa uppgiften som gavs tidigare med hjälp av entry set: hämta alla studenter med ett betyg högre än 7. För detta använder vi en kontroll via entry.getValue(), och när vi hittar lämpliga studenter hämtar vi deras nycklar till en förskapad 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);
    }
}

Således kan du iterera genom Map och hitta önskad lista av studenter som klarade provet!

Entry set är ett mycket användbart verktyg eftersom det möjliggör olika sätt att iterera genom Map med en loop, med åtkomst till både nyckel och värde.

I nästa kapitel kommer vi att fördjupa oss i hur HashMap, som vi använde så aktivt i detta kapitel, faktiskt fungerar!

1. Vilket interface i Java representerar en samling av nyckel-värde-par?

2. Hur itererar du genom alla nycklar i en Map med en for-each-loop?

3. Vad är syftet med metoden values() i en Map?

4. Vilken metod används för att kontrollera om en specifik nyckel finns i en Map?

5. Vilken metod används för att ta bort ett nyckel-värde-par från en Map i Java?

question mark

Vilket interface i Java representerar en samling av nyckel-värde-par?

Select the correct answer

question mark

Hur itererar du genom alla nycklar i en Map med en for-each-loop?

Select the correct answer

question mark

Vad är syftet med metoden values() i en Map?

Select the correct answer

question mark

Vilken metod används för att kontrollera om en specifik nyckel finns i en Map?

Select the correct answer

question mark

Vilken metod används för att ta bort ett nyckel-värde-par från en Map i Java?

Select the correct answer

Var allt tydligt?

Hur kan vi förbättra det?

Tack för dina kommentarer!

Avsnitt 3. Kapitel 1

Fråga AI

expand

Fråga AI

ChatGPT

Fråga vad du vill eller prova någon av de föreslagna frågorna för att starta vårt samtal

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?

bookVad är en Map?

Svep för att visa menyn

Vi kommer att diskutera gränssnittet Map i Java. Gränssnittet Map är en del av Java Collections framework och definierar metoder för att arbeta med data i form av nyckel-värde-par.

Låt oss titta på definitionen:

Den primära implementationen av en sådan datastruktur i Java är HashMap, som implementerar gränssnittet Map. Låt oss utforska de viktigaste metoderna och principerna för hur denna implementation fungerar.

Vi börjar med deklaration och metoder:

Main.java

Main.java

copy

              
1

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

Här ser du att i generics eller diamantparenteser anges två värden:

  • Värdet K motsvarar datatypen för nyckeln;
  • Värdet V motsvarar datatypen för värdet.

När vi deklarerar denna datastruktur anger vi alltså datatyperna för våra nyckel-värde-par.

Nu ska vi granska metoderna som definieras i Map -gränssnittet.

Metoder

V put(K key, V value): associerar det angivna värdet med den angivna nyckeln i denna Map. Om Map tidigare innehöll en koppling för nyckeln, ersätts det gamla värdet.

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): returnerar värdet som den angivna nyckeln är kopplad till, eller null om denna Map inte innehåller någon koppling för nyckeln.

Här anger vi nyckeln för att hämta det motsvarande värdet.

Vi hämtar värdet med nyckel 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): returnerar true om Map innehåller en koppling för den angivna nyckeln;

  • boolean containsValue(Object value): returnerar true om Map innehåller en eller flera nycklar kopplade till det angivna värdet.

Dessa två metoder är uppenbart relaterade, och de hjälper till att avgöra om den angivna Map innehåller de önskade nycklarna eller värdena. Dessa metoder är praktiska att använda som villkor eftersom de returnerar boolean-värden.

Vi tittar på ett exempel:

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 exemplet ovan kontrolleras förekomsten av en nyckel och förekomsten av ett värde i Map. Om värden hittas visas de i konsolen. Om det inte finns sådana värden, skrivs meddelanden ut som indikerar avsaknad av sådan data.

  • boolean isEmpty(): returnerar true om denna Map inte innehåller några nyckel-värde-par;

  • V remove(Object key): tar bort kopplingen för den angivna nyckeln från denna Map om den finns och returnerar det tidigare värdet.

Precis som i andra datastrukturer kan du ta bort element från 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);
    }
}

Således kan vi ta bort element med nyckel.

Grundläggande metoder för hantering av Map

Härnäst finns det metoder du redan är bekant med, vilka jag listar utan exempel. Men det finns också intressanta metoder kvar.

Vi börjar med grunderna:

  • void clear(): tar bort alla element från Map;

  • int size(): returnerar antalet nyckel-värde-par i denna Map;

  • void putAll(Map<? extends K, ? extends V> m): kopierar alla mappningar från den angivna Map till denna Map.

Nu går vi vidare till metoder som returnerar en samling med värden (eller nycklar) från Map. Med andra ord hämtar vi från datastrukturen en nyckel-värde-struktur som endast lagrar värden (eller nycklar). Till exempel, 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);
    }
}

Här har vi hämtat en samling värden från Map. Nu kan vi överföra denna samling till 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 initierade en ArrayList med värden från Map.

Det finns även en metod som returnerar nycklar från Map. Dessa nycklar returneras dock i form av en struktur som kallas Set. Vi kommer inte att gå in på denna datastruktur nu; det är värt att nämna att en Set är en datastruktur som endast innehåller unika värden.

Låt oss titta på denna metod:

Set<K> keySet(): returnerar en Set-vy av nycklarna som finns i denna 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);
    }
}

Således kan vi också hämta en mängd av alla nycklar från Map.

Det verkar som att vi är klara med metoderna. Låt oss nu titta på användningen av Map, samt praktiska exempel:

Användning av Map

En struktur som nyckel-värde har många praktiska tillämpningar. Låt oss betrakta den enklaste av dessa strukturer: ett betygssystem för studenter.

Vi skapar en Map där nyckeln är av typen String, vilket representerar studentens namn, och värdet är av typen Integer, vilket representerar studentens betyg. På detta sätt kan du tilldela betyg till studenter och enkelt hämta betyget för en specifik student med hjälp av nyckeln:

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

Föreställ dig nu att vi har i uppgift att hämta betygen för Mike och Alice, och sedan jämföra dem. Du kan enkelt åstadkomma detta med hjälp av de metoder du har lärt dig ovan. Låt oss implementera detta 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 och metoden compareTo() från omslagsklassen Integer användes. Om du inte förstår hur det fungerar kan det förklaras enligt följande:

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

Låt oss nu överväga vad som händer om vi ombeds att samla alla studenter med ett betyg högre än 7 (exklusive 7). Detta blir intressant, och jag kommer nu att förklara hur du gör det!

Iteration genom Map

Att iterera över element i en Map i Java kan göras med olika metoder som tillhandahålls av Map-gränssnittet och dess implementationer. Här är flera sätt att iterera över en Map:

Iterera över nycklar (keySet()): metoden keySet() returnerar en mängd av alla nycklar i Map. Du kan använda denna mängd för att iterera över nycklar och hämta motsvarande värden.

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

Iterera över värden (values()): Metoden values() returnerar en samling av alla värden i Map. Denna samling kan användas för att iterera över värdena.

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

Iterera över nyckel-värde-par (entrySet()): Metoden entrySet() returnerar en mängd av Map.Entry-objekt som representerar nyckel-värde-par. Detta möjliggör iteration direkt över paren.

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

Låt oss fördjupa oss lite mer i detta. Inledningsvis kan det verka otroligt komplext att förstå, men du behöver inte gå in på detaljer om hur det fungerar, eftersom syntaxen alltid är densamma.

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

Med hjälp av entry-objektet kan du samtidigt komma åt både nyckeln och värdet i Map. Nu ska vi lösa uppgiften som gavs tidigare med hjälp av entry set: hämta alla studenter med ett betyg högre än 7. För detta använder vi en kontroll via entry.getValue(), och när vi hittar lämpliga studenter hämtar vi deras nycklar till en förskapad 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);
    }
}

Således kan du iterera genom Map och hitta önskad lista av studenter som klarade provet!

Entry set är ett mycket användbart verktyg eftersom det möjliggör olika sätt att iterera genom Map med en loop, med åtkomst till både nyckel och värde.

I nästa kapitel kommer vi att fördjupa oss i hur HashMap, som vi använde så aktivt i detta kapitel, faktiskt fungerar!

1. Vilket interface i Java representerar en samling av nyckel-värde-par?

2. Hur itererar du genom alla nycklar i en Map med en for-each-loop?

3. Vad är syftet med metoden values() i en Map?

4. Vilken metod används för att kontrollera om en specifik nyckel finns i en Map?

5. Vilken metod används för att ta bort ett nyckel-värde-par från en Map i Java?

question mark

Vilket interface i Java representerar en samling av nyckel-värde-par?

Select the correct answer

question mark

Hur itererar du genom alla nycklar i en Map med en for-each-loop?

Select the correct answer

question mark

Vad är syftet med metoden values() i en Map?

Select the correct answer

question mark

Vilken metod används för att kontrollera om en specifik nyckel finns i en Map?

Select the correct answer

question mark

Vilken metod används för att ta bort ett nyckel-värde-par från en Map i Java?

Select the correct answer

Var allt tydligt?

Hur kan vi förbättra det?

Tack för dina kommentarer!

Avsnitt 3. Kapitel 1
some-alt