java phase 1 - JavaSE-Day19, end of collection

Two column set

(1) Common functions of Map interface

         1. Overview

         Map < K, V > is a generic interface, which is the top-level interface of the two column set, and defines the functions and traversal methods of all the two column sets

         Double column set: it is a container used to store data of multiple key value pairs. Double column: one column is a key and the other column is a value. Keys and values appear in pairs.

         Map Chinese here is the meaning of mapping

         Key Value pair: a pair of data in a one-to-one mapping relationship. Mapping means that one Value can find another Value. In the Map set, it means that the Value can be found through the key Value

         2. Map storage key value pair characteristics

         ① It stores key value pair data

         ② Unordered set

         ③ The key must be unique. The key value cannot be repeated, and the value value can be repeated.

         3. Common methods in Map interface

 

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

public class Demo01 {
    public static void main(String[] args) {
        Map<String,String> map = new HashMap<>();
        map.put("name","fsf");
        map.put("age","19");
        //add to
        map.put("gender","man");
        System.out.println(map);
        map.put("name","tom");
        System.out.println(map);
        //delete
        //Returns the deleted element
        System.out.println(map.remove("name"));
        //Get the corresponding value
        System.out.println(map.get("gender"));
        //Include a key
        System.out.println(map.containsKey("aaa"));
        //Determine whether a Value is included
        System.out.println(map.containsValue("19"));
        //Returns the number of elements
        System.out.println(map.size());
        //empty
        map.clear();
        //Judge whether it is empty
        System.out.println(map.isEmpty());
    }
}

(2) Traversal mode of Map collection

         1. Key traversal (key value finding traversal)

         The Map set cannot be traversed directly. The Map set is transformed into a single column set (a single column set storing all the key values). The key value pair data of the Map set is obtained indirectly by traversing the single column set

         method:

         keySet(): get all the keys to form a set

         get (K key): obtain the corresponding value through the key

         Steps:

         ① Get all the keys in the Map set through the keySet method and store them in the set

         ② Traverse the set set to get each key value

         ③ Map set get (K key) to get the corresponding value

 

code:

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

public class Demo01 {
    public static void main(String[] args) {
        Map<String,Integer> map = new HashMap<>();
        map.put("max",100);
        map.put("mid",50);
        map.put("min",30);
        Set<String> keys = map.keySet();
        System.out.println(keys);
        for (String key : keys) {
            System.out.println(key+"=="+map.get(key));
        }
    }
}

         2. Value traversal (not map traversal)

         Method: values (): you can get all the values in the set to form a separate set

         You can only get all the values. You can't find the corresponding key through the value. You can only get the value of the map. You can't traverse the key value pair

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;

public class Demo02 {
    public static void main(String[] args) {
        Map<String,String> map = new HashMap<>();
        map.put("1","Zhang San");
        map.put("2","Li Si");
        map.put("3","Wang Wu");
        map.put("4","Zhao Liu");
        Collection<String> c = map.values();
        for (String s : c) {
            System.out.println(s);
        }
    }
}

         3. Key value pair traversal

         method:

         entrySet (): the method of converting each key value pair of the double column set into an Entry object, and then putting the Entry into the set set ----- the Map set

         Entry is an interface defined inside the Map interface. We don't need to care about how to generate the interface implementation class and call the Map collection          The entrySet method generates an entry interface implementation class object according to the key value pair.

         Method of Entry object:

         getKey(): get the key value of the Entry object (actually the key value of the Map object) ------ Entry interface method

         getValue (): get the value of the Entry object (actually the value of the map collection) -- the method of the Entry interface

         Steps:

         ① The map Set is transformed into the Set set of Entry objects through the entrySet method

         ② Traverse the Set set to get each Entry object

         ③ Get the key value and value value respectively through the getKey and getValue methods of Entry

 

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

public class Demo03 {
    public static void main(String[] args) {
        Map<String,String> map = new HashMap<>();
        map.put("1","Zhang San");
        map.put("2","Li Si");
        map.put("3","Wang Wu");
        map.put("4","Zhao Liu");
        //Call entrySet() to return the data stored in a Set set and encapsulate it into an entry object according to the key value of the Map Set
        Set<Map.Entry<String, String>> set = map.entrySet();
        //Traverse set set
        for (Map.Entry<String, String> en : set) {
            String key = en.getKey();
            String value = en.getValue();
            System.out.println(key+"==="+value);
        }
    }

}

(3) Introduction to common implementation classes of Map

         HashMap < K, V >: the hash table structure is used to store data, and the access order of elements cannot be guaranteed to be consistent.

         To ensure the uniqueness and non repetition of the Key, if the user-defined type data is used as the Key value, the hashCode () method and equals () method of the Key need to be rewritten to ensure the uniqueness and non repetition. JDK provides types that do not need to be overridden.

         The difference between HashMap and Hashtable

         1. The timing is different

                 HashMap appears in jdk1.2

                 Hashtable is jdk1.0

         2. Thread safety is different

                 HashMap is thread unsafe

                 Hashtable is thread safe

         3. Different efficiency

                 HashMap is efficient

                 Hashtable is thread safe

         4. Different requirements for storing data

                 HashMap supports null values and null keys

                 Hashtable does not support null data

         5. HashMap and Hashtable have the same API.

                 Relationship between HashMap and HashSet

                 The bottom layer of HashSet is built by HashMap

                 The unique principle of the stored value element of HashSet is the unique principle of the stored key value of HashMap

         When you create a HashSet set, you actually create a HashMap set

 

 

When the add method of the HashSet set adds elements, the bottom layer calls the put method of the HashMap to add them to the Map set

When adding, if the key has been stored in the HashMap, the value value in the newly added key value pair will be used to overwrite the original key value value

 

 

         practice:

         Enter a string on the keyboard and count the number of occurrences of each character

         For example: enter aaaabbccddd!@#@#$@#$%cc66ff

         Print out: a   yes   four   Number, b   yes   two   Number, c   yes   four   Number, d   yes   three   One,!   yes   one   One@   yes   three   One$   yes   two   Number,%   yes   one   6, 6   yes   2, f   yes   two   individual

package com.offcn.demo03;

import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Scanner;

public class Demo01 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String s = sc.nextLine();
        HashMap<Character,Integer> map = new HashMap<>();
        for (int i = 0; i < s.length(); i++) {
            if(map.containsKey(s.charAt(i))){
                Integer a = map.get(s.charAt(i));
                a++;
                map.put(s.charAt(i),a);
            }else {
                map.put(s.charAt(i),1);
            }
        }
        StringBuilder sb = new StringBuilder();
        for (Map.Entry<Character,Integer> en : map.entrySet()){
            sb.append(en.getKey()+"yes").append(en.getValue()+"individual");

        }
        System.out.println(sb);
    }
}

LinkedHashMap

         LinkedHashMap < K, V >: there is a subclass LinkedHashMap under HashMap, which uses hash table structure + linked list structure to store data. Through the linked list structure, the access order of elements can be ensured to be consistent; The hash table structure can ensure that the key is unique and not repeated, and the key needs to be rewritten

         hashCode() method, equals() method.

         Features: an ordered Map collection with unique key values can be stored, and the key value is null

import java.util.LinkedHashMap;

public class Demo01 {
    public static void main(String[] args) {
        LinkedHashMap<String,String> map = new LinkedHashMap<>();
        map.put("1","Zhang San");
        map.put("2","Li Si");
        map.put("3","Wang Wu");
        map.put("3","Zhao Liu");
        map.put(null,null);
        System.out.println(map);
    }
}

TreeMap (understand)

         The collection can be sorted according to the natural order of the key values of the stored key value pairs, or according to the Comparator provided when creating the Map collection, depending on the construction method used.

         Natural sorting: the type of key should implement the Comparable interface

         Comparator sorting: creating a TreeMap object is to pass in a comparator and sort the key s according to the rules of the comparator

Collections tool class

(1) Use and precautions of variable parameters

         1. Overview

         Variable parameters are also called variable number of parameters. If they are used as formal parameters of a method, the number of method parameters is variable,

         Usage scenario: the parameter type of the method has been determined, and the number is uncertain. We can use variable parameters

         [parameter list deformation of methods with multiple formal parameters of the same type] (int a, int b, int c, int d,) -- > (int... A)

         2. Format

         Modifier return value type method name (data type 1, parameter name 1, data type 2, parameter name 2, data type n... Parameter name n){

                 The variable parameter name is in the method body, and it is operated as an array name

        }

         When calling a method with variable parameters, 0~n arguments can be passed in to assign values to the variable parameters

         3. Precautions

                 1. The variable parameter name here is actually an array name

                 2. If a method has multiple parameters, including variable parameters, the variable parameters should be placed last, otherwise the compilation will report an error

                 3. Only one variable parameter can be used in a method, otherwise the compilation will report an error

package com.offcn.demo05;

public class Demo01 {
    public static void main(String[] args) {
        System.out.println(getSum(10,10,10,10,10,10,10));
        printNum(1.0,2.0f,1,2,3,4,5);
    }
    public static int getSum(int... a){
        int sum = 0;
        for (int i = 0; i < a.length; i++) {
            sum += a[i];
        }
        return sum;
    }
    public static void printNum(double a,float b,int... c){
        System.out.println(a);
        System.out.println(b);
        for (int i = 0; i < c.length; i++) {
            System.out.println(c[i]);
        }
    }
}

(2) Collections common features

         1. Overview

         Collections class is a tool class that encapsulates many common methods of operating collections. It can operate not only single column collections, but also double column collections

                 1. Cannot create object

                 2. The contents in the class are static (static attributes and static methods)

         2. Common methods

 

package com.offcn.demo05;

import java.util.ArrayList;
import java.util.Collections;

public class Demo02 {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(100);
        list.add(59);
        list.add(10);
        list.add(79);
        list.add(15);
        list.add(45);
        System.out.println(list);
        Collections.sort(list);
        System.out.println(list);

        Collections.reverse(list);
        System.out.println(list);

        Collections.shuffle(list);
        System.out.println(list);


    }
}

Tags: Java

Posted on Thu, 14 Oct 2021 17:39:10 -0400 by *Lynette