HashMap

JDK1.8 之前 HashMap 由数组+链表组成的，数组是 HashMap 的主体，链表则是主要为了解决哈希冲突而存在的（“拉链法”解决冲突）。
JDK1.8 以后在解决哈希冲突时有了较大的变化，当链表长度大于阈值（默认为 8）
（将链表转换成红黑树前会判断，如果当前数组的长度小于 64， 那么会选择先进行数组扩容，而不是转换为红黑树）时，将链表转化为红黑树，以减少搜索时间

数据类型（HashMap.Node类型）

static class Node<K,V> implements Map.Entry<K,V> {
 
        final int hash;   //哈希值
        final K key;
        V value;    
        Node<K,V> next;  //下一个节点

/**       key 不可以重复(将替换原来的，v也会替换)   value可以重复，允许存在null键和null值
          *底层数组+链表+红黑树
          *没有实现线程同步，因此线程不安全
         * */
}

遍历集合中的k-v

package com.jihe.map.hashMap;

import java.util.*;

public class HashMapTest_01 {

    public static void main(String[] args) {
        People p1 = new People("王",20000,21);
        People p2 = new People("白",10000,11);
        People p3 = new People("李",30000,31);
        HashMap map = new HashMap();
        new HashSet();
        map.put(p1.getId(),p1);
        map.put(p2.getId(),p2);
        map.put(p3.getId(),p3);
        System.out.println("------第一组①111-----");
        /**  通过entrySet() 和  迭代器 取k-v  */
        Set set = map.entrySet();
        Iterator iterator = set.iterator();
        while (iterator.hasNext()) {
            Object o =  iterator.next();
            Map.Entry goal=(Map.Entry)o;
            People value = (People)goal.getValue();//取出valu，并判断工资是否大于180000
            if (value.getSal()>18000)
            System.out.println(goal);//若工资大于18000，则输出k-v
        }
        System.out.println("------第一组②222-----");
        /**  通过entrySet() 和  增强for循环 取k-v  */
        for (Object kv : set) {
            Map.Entry kv1 = (Map.Entry) kv; //将kv转型成Map.Entry
            Object v= kv1.getValue();//Map.Entry有获取key和value的方法
            People value = (People) v;//进行转型，判断
            if (value.getSal()>18000)
                System.out.println(kv);
        }
        System.out.println("------第二组①111-----");
        /** 增强for循环
         *  先取出所有的key 通过key取出对应的value  */
        Set setKey = map.keySet();
        for (Object key : setKey) {
            Object o = map.get(key);
            People p=(People)o;
            if (p.getSal()>18000)
            System.out.println(key+"-"+map.get(key));//map.get(key)通过key取values
        }
        System.out.println("------第二组②222-----");
        /**迭代器
         * 利用key进行迭代values*/
        Iterator iterator1 = setKey.iterator();
        while (iterator1.hasNext()) {
            Object key =  iterator1.next();//获取每一个key
           People o = (People)map.get(key);//利用key得到values，并进行向下转型，判断工资大于180000的
if (o.getSal()>18000)
    System.out.println(key+"-"+map.get(key));
        }
        System.out.println("------第三组①111-----");
        /** 把所有values取出 再进行判断  */
        Collection values = map.values();
        //增强for循环
        Iterator iterator2 = values.iterator();
        for (Object value : values) {
            People v = (People) value;//将每一个value转型，并判断
            if (v.getSal()>18000)
                System.out.println(value);
        }
        System.out.println("------第三组②222-----");
        //利用迭代器，找出每一个value，并判断
        Iterator iterator3 = values.iterator();
        while (iterator3.hasNext()) {
            Object value =  iterator3.next();
            People v = (People) value;//将每一个value转型，并判断
            if (v.getSal()>18000)
                System.out.println(value);

        }
    }
}
class  People{
    private  String name;
    private  int sal;
    private  int id;

    public String getName() {
        return name;
    }

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

    public int getSal() {
        return sal;
    }

    public void setSal(int sal) {
        this.sal = sal;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public People(String name, int sal, int id) {
        this.name = name;
        this.sal = sal;
        this.id = id;
    }

    @Override
    public String toString() {
        return "People{" +
                "name:'" + name + '\'' +
                ", sal:" + sal +
                ", id:" + id +
                '}';
    }
}