Käsittelemme Map-rajapintaa Javassa. Map-rajapinta kuuluu Java Collections -kehykseen ja määrittelee menetelmät tietojen käsittelyyn avain-arvo-pareina.

Tarkastellaan määritelmää:

Tällaisen tietorakenteen ensisijainen toteutus Javassa on HashMap, joka toteuttaa Map-rajapinnan. Tutustutaan tämän toteutuksen keskeisiin menetelmiin ja toimintaperiaatteisiin.

Aloitetaan määrittelystä ja menetelmistä:

Main.java


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

Tässä näet, että geneerisissä tai timanttisulkeissa määritellään kaksi arvoa:

Arvo K vastaa avaimen tietotyyppiä;
Arvo V vastaa arvon tietotyyppiä.

Näin ollen, kun määrittelemme tämän tietorakenteen, ilmoitamme avain-arvo-parien tietotyypit.

Seuraavaksi tarkastellaan Map-rajapinnassa määriteltyjä metodeja.

Metodit

V put(K key, V value): liittää annetun arvon annettuun avaimeen tässä Map:ssa. Jos Map sisälsi aiemmin avaimelle liitoksen, vanha arvo korvataan.

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): palauttaa arvon, johon määritetty avain on liitetty, tai null, jos tässä Map-rakenteessa ei ole avainta vastaavaa arvoa.

Tässä määritetään avain, jolla haetaan vastaava arvo.

Haetaan arvo, jonka avain on 2:

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): palauttaa true, jos Map sisältää määritetyn avaimen;
boolean containsValue(Object value): palauttaa true, jos Map sisältää yhden tai useamman avaimen, joka on liitetty määritettyyn arvoon.

Nämä kaksi metodia ovat selvästi yhteydessä toisiinsa, ja niiden avulla voidaan selvittää, sisältääkö määritetty Map halutut avaimet tai arvot. Näitä metodeja on kätevää käyttää ehtolauseissa, koska ne palauttavat boolean-arvon.

Tarkastellaan esimerkkiä:

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

Yllä olevassa esimerkissä tarkistetaan avaimen olemassaolo ja arvon olemassaolo Map-rakenteessa. Jos arvot löytyvät, ne näytetään konsolissa. Jos arvoja ei löydy, tulostetaan viestit, jotka ilmaisevat tietojen puuttumisen.

boolean isEmpty(): palauttaa true, jos tämä Map ei sisällä avain-arvo-pareja;
V remove(Object key): poistaa määritetyn avaimen mukaisen parin tästä Map-rakenteesta, jos se on olemassa, ja palauttaa aiemman arvon.

Kuten muissakin tietorakenteissa, myös Map-rakenteesta voi poistaa alkioita.

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

Näin ollen voimme poistaa alkioita avaimen perusteella.

Perusmenetelmät Mapin hallintaan

Seuraavaksi on menetelmiä, jotka ovat sinulle jo tuttuja, ja luettelen ne ilman esimerkkejä. Mutta jäljellä on myös mielenkiintoisia menetelmiä.

Aloitetaan perusteista:

void clear(): poistaa kaikki alkiot Map-rakenteesta;
int size(): palauttaa avain-arvo-parien määrän tässä Map-rakenteessa;
void putAll(Map<? extends K, ? extends V> m): kopioi kaikki annetun Map-rakenteen avain-arvo-parit tähän Map-rakenteeseen.

Siirrytään nyt menetelmiin, jotka palauttavat kokoelman arvoista (tai avaimista) Map-rakenteesta. Toisin sanoen haemme tietorakenteesta avain-arvo-rakenteen, joka sisältää vain arvot (tai avaimet). Esimerkiksi ArrayList<>.

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

Tässä saatiin kokoelma arvoja Map-rakenteesta. Nyt voimme siirtää tämän kokoelman ArrayList-rakenteeseen:

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

Alustimme ArrayList-kokoelman käyttämällä arvoja Map-rakenteesta.

On olemassa myös metodi, joka palauttaa avaimet Map-rakenteesta. Nämä avaimet palautetaan kuitenkin rakenteessa nimeltä Set. Emme käsittele tätä tietorakennetta tarkemmin tässä vaiheessa; on kuitenkin hyvä mainita, että Set on tietorakenne, joka sisältää ainoastaan yksilöllisiä arvoja.

Tarkastellaan tätä metodia:

Set<K> keySet(): palauttaa Set-näkymän tämän Map-rakenteen sisältämistä avaimista.

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

Näin ollen voimme myös hakea joukon kaikkia avaimia Map-rakenteesta.

Vaikuttaa siltä, että olemme käsitelleet metodit. Tarkastellaan nyt Map-rakenteen käyttöä sekä käytännön esimerkkejä:

Mapin käyttö

Avain-arvo -rakenne soveltuu moniin käytännön tarkoituksiin. Tarkastellaan yksinkertaisinta näistä rakenteista: opiskelijoiden arvostelujärjestelmää.

Luodaan Map, jossa avain on tyyppiä String, joka edustaa opiskelijan nimeä, ja arvo on tyyppiä Integer, joka edustaa opiskelijan arvosanaa. Näin voit liittää arvosanat opiskelijoihin ja hakea helposti tietyn opiskelijan arvosanan avaimen avulla:

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

Kuvitellaan nyt, että tehtävänä on hakea Miken ja Alicen arvosanat ja vertailla niitä. Tämä onnistuu helposti yllä opituilla menetelmillä. Toteutetaan tämä koodissa:

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ääristä operaattoria ja compareTo()-kääreluokan Integer-metodia käytettiin. Jos et ymmärrä, miten tämä toimii, se voidaan selittää seuraavasti:

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

Tarkastellaanpa nyt tilannetta, jossa pyydetään keräämään kaikki opiskelijat, joiden arvosana on yli 7 (pois lukien 7). Tästä tulee mielenkiintoista, ja selitän nyt, miten se tehdään!

Iterointi Mapin läpi

Elementtien läpikäynti Map:issa Javassa voidaan tehdä useilla tavoilla, joita Map-rajapinta ja sen toteutukset tarjoavat. Tässä on useita tapoja iteroida Map:in läpi:

Iterointi avainten yli (keySet()): keySet()-metodi palauttaa joukon kaikkia avaimia Map:issa. Tätä joukkoa voidaan käyttää avainten läpikäyntiin ja vastaavien arvojen hakemiseen.

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

Arvojen läpikäynti (values()): values()-metodi palauttaa kokoelman kaikista Map-rakenteen arvoista. Tätä kokoelmaa voidaan käyttää arvojen läpikäyntiin.

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

Avaimen ja arvon parien läpikäynti (entrySet()): entrySet()-metodi palauttaa joukon Map.Entry-olioita, jotka edustavat avain-arvo-pareja. Tämä mahdollistaa parien läpikäynnin suoraan.

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

Tarkastellaan tätä hieman tarkemmin. Aluksi tämä saattaa vaikuttaa äärimmäisen monimutkaiselta ymmärtää, mutta sinun ei tarvitse perehtyä siihen, miten se toimii, sillä syntaksi on aina sama.

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

entry-olion avulla voit samanaikaisesti päästä käsiksi sekä avaimeen että arvoon Map:issa. Nyt ratkaistaan aiemmin annettu tehtävä käyttämällä entry setiä: hae kaikki opiskelijat, joiden arvosana on yli 7. Tätä varten käytetään tarkistusta entry.getValue()-kutsulla, ja kun sopiva opiskelija löytyy, tallennetaan hänen avaimensa ennalta luotuun ArrayList-rakenteeseen:

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

Näin voit käydä läpi Map-rakenteen ja löytää halutun listan opiskelijoista, jotka läpäisivät kokeen!

Entry set on erittäin hyödyllinen työkalu, sillä se mahdollistaa useita tapoja iteraatioon Map-rakenteen yli silmukassa, tarjoten pääsyn sekä avaimiin että arvoihin.

Seuraavassa luvussa perehdymme siihen, miten HashMap, jota käytimme tässä luvussa aktiivisesti, itse asiassa toimii!

Oliko kaikki selvää?

Kiitos palautteestasi!

Osio 3. Luku 1

Kysy tekoälyä

Kysy mitä tahansa tai kokeile jotakin ehdotetuista kysymyksistä aloittaaksesi keskustelumme

Pyyhkäise näyttääksesi valikon

Käsittelemme Map-rajapintaa Javassa. Map-rajapinta kuuluu Java Collections -kehykseen ja määrittelee menetelmät tietojen käsittelyyn avain-arvo-pareina.

Tarkastellaan määritelmää:

Aloitetaan määrittelystä ja menetelmistä:

Main.java


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

Tässä näet, että geneerisissä tai timanttisulkeissa määritellään kaksi arvoa:

Arvo K vastaa avaimen tietotyyppiä;
Arvo V vastaa arvon tietotyyppiä.

Näin ollen, kun määrittelemme tämän tietorakenteen, ilmoitamme avain-arvo-parien tietotyypit.

Seuraavaksi tarkastellaan Map-rajapinnassa määriteltyjä metodeja.

Metodit

V put(K key, V value): liittää annetun arvon annettuun avaimeen tässä Map:ssa. Jos Map sisälsi aiemmin avaimelle liitoksen, vanha arvo korvataan.

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): palauttaa arvon, johon määritetty avain on liitetty, tai null, jos tässä Map-rakenteessa ei ole avainta vastaavaa arvoa.

Tässä määritetään avain, jolla haetaan vastaava arvo.

Haetaan arvo, jonka avain on 2:

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): palauttaa true, jos Map sisältää määritetyn avaimen;
boolean containsValue(Object value): palauttaa true, jos Map sisältää yhden tai useamman avaimen, joka on liitetty määritettyyn arvoon.

Tarkastellaan esimerkkiä:

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

boolean isEmpty(): palauttaa true, jos tämä Map ei sisällä avain-arvo-pareja;
V remove(Object key): poistaa määritetyn avaimen mukaisen parin tästä Map-rakenteesta, jos se on olemassa, ja palauttaa aiemman arvon.

Kuten muissakin tietorakenteissa, myös Map-rakenteesta voi poistaa alkioita.

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

Näin ollen voimme poistaa alkioita avaimen perusteella.

Perusmenetelmät Mapin hallintaan

Seuraavaksi on menetelmiä, jotka ovat sinulle jo tuttuja, ja luettelen ne ilman esimerkkejä. Mutta jäljellä on myös mielenkiintoisia menetelmiä.

Aloitetaan perusteista:

void clear(): poistaa kaikki alkiot Map-rakenteesta;
int size(): palauttaa avain-arvo-parien määrän tässä Map-rakenteessa;
void putAll(Map<? extends K, ? extends V> m): kopioi kaikki annetun Map-rakenteen avain-arvo-parit tähän Map-rakenteeseen.

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

Tässä saatiin kokoelma arvoja Map-rakenteesta. Nyt voimme siirtää tämän kokoelman ArrayList-rakenteeseen:

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

Alustimme ArrayList-kokoelman käyttämällä arvoja Map-rakenteesta.

Tarkastellaan tätä metodia:

Set<K> keySet(): palauttaa Set-näkymän tämän Map-rakenteen sisältämistä avaimista.

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

Näin ollen voimme myös hakea joukon kaikkia avaimia Map-rakenteesta.

Vaikuttaa siltä, että olemme käsitelleet metodit. Tarkastellaan nyt Map-rakenteen käyttöä sekä käytännön esimerkkejä:

Mapin käyttö

Avain-arvo -rakenne soveltuu moniin käytännön tarkoituksiin. Tarkastellaan yksinkertaisinta näistä rakenteista: opiskelijoiden arvostelujärjestelmää.

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

Kuvitellaan nyt, että tehtävänä on hakea Miken ja Alicen arvosanat ja vertailla niitä. Tämä onnistuu helposti yllä opituilla menetelmillä. Toteutetaan tämä koodissa:

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ääristä operaattoria ja compareTo()-kääreluokan Integer-metodia käytettiin. Jos et ymmärrä, miten tämä toimii, se voidaan selittää seuraavasti:

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

Tarkastellaanpa nyt tilannetta, jossa pyydetään keräämään kaikki opiskelijat, joiden arvosana on yli 7 (pois lukien 7). Tästä tulee mielenkiintoista, ja selitän nyt, miten se tehdään!

Iterointi Mapin läpi

Elementtien läpikäynti Map:issa Javassa voidaan tehdä useilla tavoilla, joita Map-rajapinta ja sen toteutukset tarjoavat. Tässä on useita tapoja iteroida Map:in läpi:

Iterointi avainten yli (keySet()): keySet()-metodi palauttaa joukon kaikkia avaimia Map:issa. Tätä joukkoa voidaan käyttää avainten läpikäyntiin ja vastaavien arvojen hakemiseen.

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

Arvojen läpikäynti (values()): values()-metodi palauttaa kokoelman kaikista Map-rakenteen arvoista. Tätä kokoelmaa voidaan käyttää arvojen läpikäyntiin.

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

Avaimen ja arvon parien läpikäynti (entrySet()): entrySet()-metodi palauttaa joukon Map.Entry-olioita, jotka edustavat avain-arvo-pareja. Tämä mahdollistaa parien läpikäynnin suoraan.

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

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

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

Näin voit käydä läpi Map-rakenteen ja löytää halutun listan opiskelijoista, jotka läpäisivät kokeen!

Entry set on erittäin hyödyllinen työkalu, sillä se mahdollistaa useita tapoja iteraatioon Map-rakenteen yli silmukassa, tarjoten pääsyn sekä avaimiin että arvoihin.

Seuraavassa luvussa perehdymme siihen, miten HashMap, jota käytimme tässä luvussa aktiivisesti, itse asiassa toimii!

Oliko kaikki selvää?

Kiitos palautteestasi!

Osio 3. Luku 1

Mikä on Map?

Metodit

Perusmenetelmät Mapin hallintaan

Mapin käyttö

Iterointi Mapin läpi

1. Mikä rajapinta Javassa edustaa avain-arvo -parien kokoelmaa?

2. Kuinka iteroidaan kaikki avaimet `Map`-rakenteessa for-each-silmukalla?

3. `values()`-metodin tarkoitus `Map`-rakenteessa?

4. Mitä metodia käytetään tarkistamaan, onko tietty avain olemassa `Map`-rakenteessa?

5. Mikä menetelmä poistaa avain-arvo-parin `Map`-rakenteesta Javassa?

Mikä on Map?

Metodit

Perusmenetelmät Mapin hallintaan

Mapin käyttö

Iterointi Mapin läpi

1. Mikä rajapinta Javassa edustaa avain-arvo -parien kokoelmaa?

2. Kuinka iteroidaan kaikki avaimet `Map`-rakenteessa for-each-silmukalla?

3. `values()`-metodin tarkoitus `Map`-rakenteessa?

4. Mitä metodia käytetään tarkistamaan, onko tietty avain olemassa `Map`-rakenteessa?

5. Mikä menetelmä poistaa avain-arvo-parin `Map`-rakenteesta Javassa?

Mikä on Map?

Metodit

Perusmenetelmät Mapin hallintaan

Mapin käyttö

Iterointi Mapin läpi

1. Mikä rajapinta Javassa edustaa avain-arvo -parien kokoelmaa?

2. Kuinka iteroidaan kaikki avaimet Map-rakenteessa for-each-silmukalla?

3. values()-metodin tarkoitus Map-rakenteessa?

4. Mitä metodia käytetään tarkistamaan, onko tietty avain olemassa Map-rakenteessa?

5. Mikä menetelmä poistaa avain-arvo-parin Map-rakenteesta Javassa?

Mikä on Map?

Metodit

Perusmenetelmät Mapin hallintaan

Mapin käyttö

Iterointi Mapin läpi

1. Mikä rajapinta Javassa edustaa avain-arvo -parien kokoelmaa?

2. Kuinka iteroidaan kaikki avaimet Map-rakenteessa for-each-silmukalla?

3. values()-metodin tarkoitus Map-rakenteessa?

4. Mitä metodia käytetään tarkistamaan, onko tietty avain olemassa Map-rakenteessa?

5. Mikä menetelmä poistaa avain-arvo-parin Map-rakenteesta Javassa?

2. Kuinka iteroidaan kaikki avaimet `Map`-rakenteessa for-each-silmukalla?

3. `values()`-metodin tarkoitus `Map`-rakenteessa?

4. Mitä metodia käytetään tarkistamaan, onko tietty avain olemassa `Map`-rakenteessa?

5. Mikä menetelmä poistaa avain-arvo-parin `Map`-rakenteesta Javassa?

2. Kuinka iteroidaan kaikki avaimet `Map`-rakenteessa for-each-silmukalla?

3. `values()`-metodin tarkoitus `Map`-rakenteessa?

4. Mitä metodia käytetään tarkistamaan, onko tietty avain olemassa `Map`-rakenteessa?

5. Mikä menetelmä poistaa avain-arvo-parin `Map`-rakenteesta Javassa?