Common implementation classes of Map interface: HashMap, TreeMap, LinkedHashMap and Properties. HashMap is the most frequently used implementation class of Map interface.

HashMap class

characteristic

• The bottom layer of HashMap is the hash table structure
• Rely on hashCode method and equals method to ensure the uniqueness of keys
• If the key is to store a custom object, you need to override the hashCode and equals methods

Case requirements

• Create a HashMap collection. The key is student and the value is string. Store multiple elements and traverse.
• It is required to ensure the uniqueness of the key: if the member variable values of the student object are the same, we think it is the same object

Student class

package Demo;

public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Student student = (Student) o;

        if (age != student.age) return false;
        return name != null ? name.equals(student.name) : student.name == null;
    }

    @Override
    public int hashCode() {
        int result = name != null ? name.hashCode() : 0;
        result = 31 * result + age;
        return result;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

package Demo;

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

public class HashMapDemo {
    public static void main(String[] args) {
        //Create a HashMap collection object
        HashMap<Student, String> hm = new HashMap<Student, String>();

        //Create student object
        Student s1 = new Student("Lin Qingxia", 30);
        Student s2 = new Student("Zhang Manyu", 35);
        Student s3 = new Student("Wang Zuxian", 33);
        Student s4 = new Student("Wang Zuxian", 33);

        //Add students to collection
        hm.put(s1, "Xi'an");
        hm.put(s2, "Wuhan");
        hm.put(s3, "Zhengzhou");
        hm.put(s4, "Beijing");


        //The first method: first get all the keys, and then find the corresponding value through each key
        Set<Student> keys = hm.keySet();
        for (Student key : keys) {
            String value = hm.get(key);
            System.out.println(key + "----" + value);
        }

        System.out.println("===================================");

        //The second method: get all key value pair objects first. Then get each key and value inside
        Set<Map.Entry<Student, String>> entries = hm.entrySet();
        for (Map.Entry<Student, String> entry : entries) {
            Student key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key + "----" + value);
        }
        System.out.println("===================================");
        //Third:
        hm.forEach(
                (Student key, String value) -> {
                    System.out.println(key + "----" + value);
                }
        );

    }
}

TreeMap class

Implementation of NavigableMap based on red black tree. The map is sorted according to the natural order of its keys, or according to the Comparator provided when the map was created, depending on the construction method used. If the key stores custom objects, you need to implement the Comparable interface or give the Comparator sorting rules when creating TreeMap objects.

package com.itheima.maptest;

import java.util.Comparator;
import java.util.TreeMap;

/**
 * Requirement: create a TreeMap set. The key is the student object and the value is the native place (String).
 *           Student attribute name and age, sorted by age and traversed.
 */
public class Test1 {
    public static void main(String[] args) {
        TreeMap<Student,String> tm = new TreeMap<>(new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                int result = o1.getAge() - o2.getAge();
                result = result== 0 ? o1.getName().compareTo(o2.getName()) : result;
                return result;
            }
        });

        Student s1 = new Student("xiaohei",23);
        Student s2 = new Student("dapang",22);
        Student s3 = new Student("xiaomei",22);

        tm.put(s1,"Jiangsu");
        tm.put(s2,"Beijing");
        tm.put(s3,"Tianjin");

        tm.forEach(
                (Student key, String value)->{
                    System.out.println(key + "---" + value);
                }
        );
    }
}

LinkedHashMap class

LinkedHashMap is a subclass of HashMap. This implementation differs from HashMap in that it maintains a double linked list that runs on all items. This linked list defines the iterative order, which is usually the order in which keys are inserted into the map (insertion order).

Properties class

The properties class is a subclass of Hashtable. Properties can be saved in or loaded from the stream. Each key and its corresponding value in the attribute list is a string. When accessing data, it is recommended to use setProperty(String key,String value) method and getProperty(String key) method.

Collections tool class

Collections is a tool class that operates on collections such as Set, List, and Map. Collections provides a series of static methods to sort, query and modify collection elements. It also provides methods to Set immutable collection objects and realize synchronous control over collection objects. Common methods are as follows:

• public static <T> boolean addAll(Collection<? Super T > C, t... Elements) adds all specified elements to the specified collection.
• public static <T> int binarySearch(List<? extends Comparable<? Super T > > list, T key) find the subscript of an element in the list set, but the element of the list must be t or a subclass object of T, and must be of comparable size, that is, it supports natural sorting. Moreover, the set must be ordered in advance, otherwise the result is uncertain.
• public static <T> int binarySearch(List<? extends T> list,T key,Comparator<? Super T > c) find the subscript of an element in the list set, but the element of the list must be t or a subclass object of T, and the set must be sorted according to the rules of the c comparator in advance, otherwise the result is uncertain.
• public static <T extends Object & Comparable<? super T>> T max(Collection<? Extensions T > Coll) find the largest element in the coll collection. The objects in the collection must be t or subclass objects of T, and support natural sorting
• public static <T> T max(Collection<? extends T> coll,Comparator<? Super T > COMP) find the largest element in the coll set. The objects in the set must be t or subclass objects of T. find the largest element according to the comparator comp
• public static void reverse(List<?> List) reverses the order of the elements in the specified list.
• public static void shuffle(List<?> List) the elements of the list set are sorted randomly, similar to shuffling
• public static <T extends Comparable<? Super T > > void sort (List < T > List) sorts the elements of the specified List set in ascending order according to the natural order of the elements
• public static <T> void sort(List<T> list,Comparator<? Super T > C) sort the list set elements according to the order generated by the specified comparator
• public static void swap(List<?> List, int i, int j) exchange the elements at I and j in the specified list set
• public static int frequency(Collection<?> c. Object o) returns the number of occurrences of the specified element in the specified collection
• public static <T> void copy(List<? super T> dest,List<? Extensions (T > src) copy the contents of src to dest
• Public static < T > Boolean replaceall (List < T > List, T oldVal, T newVal): replaces all old values of the List object with new values
• The Collections class provides multiple synchronizedXxx() methods, which can wrap the specified collection into a thread synchronized collection, so as to solve the thread safety problem when multiple threads access the collection concurrently
• Multiple unmodifiableXxx() methods are provided in the Collections class, which return the unmodifiable view of the specified Xxx.

Create immutable collection

In the List, Set and Map interfaces, there are of methods that can create an immutable Set

• This collection cannot be added, deleted or modified
• However, it can be combined with the parameterized construction of the set to realize the batch addition of the set

In the Map interface, there is also an ofEntries method to improve the readability of the code

• First, the key value pair will be encapsulated into an Entry object, and then the Entry object will be added to the collection

Example

public class MyVariableParameter4 {
    public static void main(String[] args) {
        // Static < E > List < E > of (E... elements) creates a list collection object with the specified elements
        //Static < E > Set < E > of (E... elements) creates a Set set object with a specified element
        //Static < K, V > Map < K, V > of (E... elements) creates a Map collection object with a specified element

        method1();
        method2();
        method3();
        method4();

    }

    private static void method4() {
        Map<String, String> map = Map.ofEntries(
                Map.entry("zhangsan", "Jiangsu"),
                Map.entry("lisi", "Beijing"));
        System.out.println(map);
    }

    private static void method3() {
        Map<String, String> map = Map.of("zhangsan", "Jiangsu", "lisi", "Beijing", "wangwu", "Tianjin");
        System.out.println(map);
    }

    private static void method2() {
        //There cannot be duplicate elements in the passed parameters.
        Set<String> set = Set.of("a", "b", "c", "d","a");
        System.out.println(set);
    }

    private static void method1() {
        List<String> list = List.of("a", "b", "c", "d");
        System.out.println(list);

        //Batch addition of collections.
        //First, create an immutable collection by calling the List.of method. The formal parameter of the of method is a variable parameter.
        //Create an ArrayList set and add all the data in the immutable set to the ArrayList.
        ArrayList<String> list3 = new ArrayList<>(List.of("a", "b", "c", "d"));
        System.out.println(list3);
    }
}