java集合框架---Map集合

1. Map
   是一个接口，将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。
   键相同，值覆盖，当你第一次存储这个键值对时，返回的是null
   当你第二次存储相同的键，但是值不同，就会发生键相同，值覆盖，返回的是这个键第一次的旧值
2. HashMap的功能概述

a:添加功能 
   	V put(K key,V value):添加元素。这个其实还有另一个功能?替换
   		如果键是第一次存储，就直接存储元素，返回null
   		如果键不是第一次存在，就用值把以前的值替换掉，返回以前的值
   b:删除功能
   	void clear():移除所有的键值对元素
   	V remove(Object key)：根据键删除键值对元素，并把值返回
   c:判断功能
   	boolean containsKey(Object key)：判断集合是否包含指定的键
   	boolean containsValue(Object value):判断集合是否包含指定的值
   	boolean isEmpty()：判断集合是否为空
   d:获取功能
   	Set<Map.Entry<K,V>> entrySet(): 返回一个键值对的Set集合
   	V get(Object key):根据键获取值
   	Set<K> keySet():获取集合中所有键的集合
   	Collection<V> values():获取集合中所有值的集合
   e:长度功能
   	int size()：返回集合中的键值对的对数

//功能测试
import java.util.HashMap;
import java.util.Map;

public class test {
    public static void main(String[] args) {

        HashMap<String, String> map = new HashMap<>();
        map.put("1","1");
        map.put("2","2");
        map.put("3","3");
        map.put("4","4");
        map.put("5","5");
        String remove = map.remove("1");
        System.out.println(remove);
        map.clear();
        boolean empty = map.isEmpty();
        int size = map.size();
        boolean b = map.containsKey("1");
        boolean b1 = map.containsValue("1");
        System.out.println(empty);
        System.out.println(size);
        System.out.println(map);
        System.out.println(b);
        System.out.println(b1);
    }
}

3. HashMap集合遍历
   1） 键找值
   把键找出来统一看作一个整体取出来，放到一个集合中，遍历键的集合，获取到每一个值

   V get(Object key)  ，得到键就是找到了对应的值，键找值
   Set<K> keySet()  获取键的集合
   Collection<V> values()   获取值的集合
   

import java.util.Collection;
import java.util.HashMap;
import java.util.Set;

public class test1 {
    public static void main(String[] args) {
        HashMap<String, String> map = new HashMap<>();
        map.put("1","1");
        map.put("2","2");
        map.put("3","3");
        map.put("4","4");
        map.put("5","5");
        Set<String> strings = map.keySet();
        for (String key : strings) {
            System.out.println(key+"-------"+map.get(key));
        }
        Collection<String> values = map.values();
        System.out.println(map);
    }
}

2）键值对

	获取所有键值对对象的集合
	遍历键值对对象的集合，获取到每一个键值对对象
	根据键值对对象找键和值
	 /*接口 Map.Entry<K, V>
        K getKey ()
        返回与此项对应的键。
        V getValue ()
        返回与此项对应的值。*/

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

public class test2 {
    public static void main(String[] args) {
        //键值对
        HashMap<String, String> map = new HashMap<>();
        map.put("1","1");
        map.put("2","2");
        map.put("3","3");
        map.put("4","4");
        map.put("5","5");
        Set<Map.Entry<String, String>> entries = map.entrySet();
        for (Map.Entry<String, String> entry : entries) {
            String key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key+"-----"+value);
        }
    }
}

4. LinkedHashMap
   底层的数据结构是链表和哈希表 元素有序 并且唯一
   元素的有序性由 链表数据结构保证
   唯一性由 哈希表数据结构保证
   Map集合的数据结构只和键有关

import java.util.LinkedHashMap;
import java.util.function.BiConsumer;

public class test3 {
    public static void main(String[] args) {
        LinkedHashMap<String, String> map = new LinkedHashMap<>();
        map.put("1","1");
        map.put("2","2");
        map.put("2","1");
        map.put("5","3");
        map.put("4","4");
        map.put("5","5");
        map.forEach(new BiConsumer<String, String>() {
            @Override
            public void accept(String key, String value) {
                System.out.println(key+"-----"+value);
            }
        });
    }
}
结果：
1-----1
2-----1
5-----5
4-----4

5. TreeMap
   键的数据结构是红黑树,可保证键的排序和唯一性
   排序分为自然排序和比较器排序
   线程是不安全的效率比较高

//键的数据结构是红黑树,可保证键的排序和唯一性  
import org.map.demo.Student;

import java.util.TreeMap;
import java.util.function.BiConsumer;

public class test4 {
    public static void main(String[] args) {
        TreeMap<Student, String> treeMap = new TreeMap<>();
        treeMap.put(new Student("张三", 23), "s001");
        treeMap.put(new Student("张三", 23), "s002");
        treeMap.put(new Student("张三", 23), "哈哈哈哈");
        treeMap.put(new Student("张三3333", 230), "s001");
        treeMap.put(new Student("张三", 23), "呵呵呵呵呵");
        treeMap.put(new Student("lisi", 29), "s001");
        treeMap.forEach(new BiConsumer<Student, String>() {
            @Override
            public void accept(Student student, String s) {
                System.out.println(student.getName()+"----"+student.getAge()+s);
            }
        });
    }
}

Collections.sort(List<T> list)：
直接给定需要排序的list，然后按照自然排序进行排序。
Collections.sort(List<T> list,Comparator<? super T> c)：
这个方法需要提供比较器，然后排序时会根据比较器的实现逻辑进行排序。

6. HashMap和Hashtable的区别
   HashMap和Hashtable的区别: 底层数据结构都一样，都是哈希表
   HashMap: 线程不安全,效率高.允许null值和null键
   Hashtable: 线程安全 , 效率低.不允许null值和null键

        HashMap<String, String> stringStringHashMap = new HashMap<>();
        stringStringHashMap.put(null,null);
        System.out.println(stringStringHashMap);

        Hashtable<Object, Object> objectObjectHashtable = new Hashtable<>();
        objectObjectHashtable.put(null,null);//NullPointerException
        

7. Collections工具类
   针对Collection 集合 Java给我们提供了一个工具类

//常见方法
import java.util.*;

public class test5 {
    public static void main(String[] args) {
        ArrayList<Integer> integers = new ArrayList<>();
        integers.add(20);
        integers.add(30);
        integers.add(50);
        integers.add(60);
        integers.add(40);
        int i = Collections.binarySearch(integers, 30);
        System.out.println(i);
        System.out.println(integers);
        Integer max = Collections.max(integers);
        Integer min = Collections.min(integers);
        Collections.shuffle(integers);
        System.out.println(integers);
    }
}