public V put(K key, V value) {
        Entry<K,V> t = root;
        if (t == null) {
            compare(key, key); // type (and possibly null) check

            root = new Entry<>(key, value, null);
            size = 1;
            modCount++;
            return null;
        }
        int cmp;
        Entry<K,V> parent;
        // split comparator and comparable paths
        Comparator<? super K> cpr = comparator;
        if (cpr != null) {
            do {
                parent = t;
                cmp = cpr.compare(key, t.key);
                if (cmp < 0)
                    t = t.left;
                else if (cmp > 0)
                    t = t.right;
                else
                    return t.setValue(value);
            } while (t != null);
        }
        else {
            if (key == null)
                throw new NullPointerException();
            @SuppressWarnings("unchecked")
                Comparable<? super K> k = (Comparable<? super K>) key;
            do {
                parent = t;
                cmp = k.compareTo(t.key);
                if (cmp < 0)
                    t = t.left;
                else if (cmp > 0)
                    t = t.right;
                else
                    return t.setValue(value);
            } while (t != null);
        }
        Entry<K,V> e = new Entry<>(key, value, parent);
        if (cmp < 0)
            parent.left = e;
        else
            parent.right = e;
        fixAfterInsertion(e);
        size++;
        modCount++;
        return null;
    }

private static void treeSet(){              //TreeSet

      Catss cat1=new Catss(2,"猫1",1);
      Catss cat2=new Catss(1,"猫2",2);
      Catss cat3=new Catss(3,"猫3",3);
      Catss cat4=new Catss(1,"猫4",4);
      Catss cat5=new Catss(1,"猫4",4);
      //TreeSet存储数据要使用比较器
      TreeSet<Catss> t=new TreeSet<>(new CatComparator());
      t.add(cat1);
      t.add(cat2);
      t.add(cat3);
      t.add(cat4);
      t.add(cat5);
       for (Object f:t){
           System.out.println(f+"输出顺序是按照年龄排序递增(年龄有一样的将会覆盖一个,只输出一个)");//输出顺序是按照年龄排序递增(年龄有一样的将会覆盖一个,只输出一个)
       }
  }

class CatComparator implements Comparator<Catss> {
    @Override
    public int compare(Catss o1, Catss o2) {
        return o1.getAge()-o2.getAge();//根据年龄排序
    }

}

public static void treeMapTest(){
        TreeMap<String, String> treeMap = new TreeMap<>();
        treeMap.put("1","A");
        treeMap.put("4","A");
        treeMap.put("2","B");
        treeMap.put("3","C");
        treeMap.forEach((k,v)->System.out.println("K值:"+k+"----->value值:"+v));
    }

    //K值:1----->value值:A
    //K值:2----->value值:B
    //K值:3----->value值:C
    //K值:4----->value值:A

除此之外，hash表里还有一个“负载极限”，“负载极限”是一个0~1的数值，“负载极限”决定了hash表的最大填满程度。当hash表中的负载因子达到指定的“负载极限”时，hash表会自动成倍地增加容量（桶的数量），并将原有的对象重新分配，放入新的桶内，这称为rehashing。HashSet和HashMap、Hashtable的构造器允许指定一个负载极限，HashSet和HashMap、Hashtable默认的“负载极限”为0.75，这表明当该hash表的3/4已经被填满时，hash表会发生rehashing。“负载极限”的默认值（0.75）是时间和空间成本上的一种折中：较高的“负载极限”可以降低hash表所占用的内存空间，但会增加查询数据的时间开销，而查询是最频繁的操作（HashMap的get()与put()方法都要用到查询）；较低的“负载极限”会提高查询数据的性能，但会增加hash表所占用的内存开销。程序员可以根据实际情况来调整HashSet和HashMap的“负载极限”值。如果开始就知道HashSet和HashMap、Hashtable会保存很多记录，则可以在创建时就使用较大的初始化容量，如果初始化容量始终大于HashSet和HashMap、Hashtable所包含的最大记录数除以负载极限，就不会发生rehashing。使用足够大的初始化容量创建HashSet和HashMap、Hashtable时，可以更高效地增加记录，但将初始化容量设置太高可能会浪费空间，因此通常不要将初始化容量设置得太高 --<<java疯狂讲义>>

public class Map09 {
    public static void main(String[] args){
        hashMap();
    }
    private static void hashMap(){
        Map<Integer,String> map=new HashMap<>();//Map<key,value>
        map.put(1,"key必须保证唯一");
        map.put(2,"无序的");
        map.put(3,"put方法");
        map.put(null,null);
        System.out.println(map.size());
        System.out.println("得到key=2的值:"+map.get(2));
        //第一种遍历 lambda表达式遍历forEach();非常简便
        System.out.println("---------lambda表达式遍历forEach()-----------------------");
        map.forEach((i, s) -> System.out.println("key="+i+"     value:"+s));
        //第二种遍历  entrySet()方法
        System.out.println("---------entrySet()方法使用foreach遍历-----------------------");
        Set<Map.Entry<Integer,String>> entry=map.entrySet();
        for (Map.Entry e:entry){
            System.out.println(e.getKey()+"->"+e.getValue());
        }
        System.out.println("---------entrySet()方法使用Iterator遍历-----------------------");
        Set entries = map.entrySet();
        Iterator iterator = entries.iterator();
        while(iterator.hasNext()){
            Map.Entry entrys = (Map.Entry) iterator.next();
            Object key = entrys.getKey();
            String value = map.get(key);
            System.out.println(key+"        "+value+"-----");
        }
        System.out.println("----------keySet()方法---------------------");
        //第三种 遍历键 keySet()方法
        Set<Integer> key=map.keySet();
        for (Integer i:key){
            String va=map.get(i);
            System.out.println(i+"->"+va);
        }
        //第四种遍历值map.values()
        System.out.println("----------values()方法---------------------");
        Collection<String> vs=map.values();
        for (String str:vs){
            System.out.println(str);
        }

    }
}