Map集合

Map集合

Map接口的特点：

1. 用于存储任意键值对（Key--Value）
2. 键：无序，无下标，不允许重复（唯一）
3. 值：无序，无下标，允许重复

package com.zhang.oop.Coll;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class Demo09 {
    public static void main(String[] args) {
        Map<String,String> map = new HashMap<>();
        //添加元素
        map.put("cn","中国");
        map.put("usa","美国");
        map.put("jpa","日本");
        //keySet（）遍历
        Set<String> keyset = map.keySet();
        for (String s : keyset) {
            System.out.println(s+"------"+map.get(s));
        }
        //entrySet（）遍历
        Set<Map.Entry<String,String>> entries = map.entrySet();
        for (Map.Entry<String, String> entry : entries) {
            System.out.println(entry);
        }
    }
}

HashMap使用

package com.zhang.oop.Coll;
import java.util.HashMap;
import java.util.Map;
public class Demo10 {
    public static void main(String[] args) {
        HashMap<Person,String> map = new HashMap<>();
        Person p1 = new Person("张三",20);
        Person p2 = new Person("李四",44);
        Person p3 = new Person("王五",23);
        //添加信息
        map.put(p1,"中");
        map.put(p2,"sc");
        map.put(p3,"ds");
        map.put(new Person("王五",23),"fg");//添加重复信息可覆盖,重写equals和hashcode方法
        System.out.println(map);
        //keySet（）遍历
        for (Person person : map.keySet()) {
            System.out.println(person+"==="+map.get(person));
        }
        //entrySet（）遍历
        for (Map.Entry<Person, String> entry : map.entrySet()) {
            System.out.println(entry.getKey()+"----"+entry.getValue());
        }
    }
}

HashMap面试题

1. HashMap的底层数据结构是什么

JDK1.7中由数组+链表组成，数组是HashMap的主体，链表为了解决哈希冲突

JDK1.8中由数组+链表+红黑树组成。链表超过8且数组长度超过64才会转红黑树。当前数组长度小于64，会优先进行数组扩容，以减少搜索时间。

2. 为什么在解决 hash 冲突的时候，不直接用红黑树？而选择先用链表，再转红黑树?

   因为红黑树需要左旋，右旋，变色操作来保持平衡，单链表不需要。当元素小于8的时候，做查询操作，链表结构已经能保证查询性能。大于8的时候，红黑树搜索时间复杂度log2n，单链表n，所以需要红黑树来加快查询速度，但是新增检点的效率变慢

3. 不用红黑树，用二叉查找树可以吗？

   可以，但是在特殊情况下二叉查找树会变成一条线性结构，和原来的链表结构一样。遍历查找会很慢

4. 为什么链表改为红黑树的阈值时是8？

   因为容器中节点分布在hash桶中的频率遵循泊松分布。链表中元素个数为8的概率很小了。

Collections工具类

package com.zhang.oop.Coll;
import java.util.*;
public class Demo11 {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(23);
        list.add(12);
        list.add(22);
        list.add(2);
        //sort排序(从小到大)
        System.out.println(list);
        Collections.sort(list);
        System.out.println(list);
        //binarySearch二分查找
        int i = Collections.binarySearch(list,22);
        System.out.println(i);
        //copy复制
        List<Integer> dest = new ArrayList<>();
        for (int j = 0; j <list.size(); j++) {
            dest.add(0);
        }
        Collections.copy(dest,list);
        System.out.println(dest);
        //reverse反转
        Collections.reverse(list);
        System.out.println(list);
        //shuffle打乱
        Collections.shuffle(list);
        System.out.println(list);
        //List构成数组
        Integer[] arr = list.toArray(new Integer[10]);
        System.out.println(arr.length);
        System.out.println(Arrays.toString(arr));
        //数组转成集合
        String[] name = {"zhang","li","wang"};
        //集合是一个受限集合，不能添加和删除
        List<String> list1 = Arrays.asList(name);
        System.out.println(list1);
        //把基本类型数组转成集合时，需要修改为包装类型
        Integer[] nums = {12,22,32,11,2,32};
        List<Integer> list2 = Arrays.asList(nums);
        System.out.println(list2);
    }
}