浅谈Java中的List、Set和Map集合

目录

1. List集合中ArrayList、LinkedList和Vector
2. Set集合中的HashSet、LinkedHashset和TreeSet
3. Map集合中的HashMap、LinkedHashMap和TreeMap

一、List集合

        /**
         * 线程是否安全: 否
         * 执行效率: 增删慢, 查询快
         * 底层结构: 底层结构为数组, 第一次执行add方法的时候会初始化一个长度为10的数组, 当数组位占满时,
         * 按照原先二分之一长度进行扩容
         */
        ArrayList<Integer> arrayList = new ArrayList<>();
        arrayList.add(1);
        arrayList.forEach(System.out::println);

        /**
         * 线程是否安全: 否
         * 执行效率: 增删快, 查询慢
         * 底层结构: 底层为双向链表结构
         */
        LinkedList<Integer> linkedList = new LinkedList<>();
        linkedList.add(2);
        linkedList.forEach(System.out::println);

        /**
         * 线程是否安全: 是
         * 执行效率: 由于是线程安全的, 故执行效率较慢
         * 底层结构: 底层为数组结构, 构造函数可指定数组初始长度和扩容因子, 扩容机制类似于ArrayList,但有所区别
         */
        Vector<Integer> vector = new Vector<>();
        vector.add(3);
        vector.forEach(System.out::println);

二、Set集合

/**
         * 线程是否安全: 否
         * 底层机构: 底层为HashMap结构, key为键, value为同一个Object对象
         */
        HashSet<Integer> hashSet = new HashSet<>();
        hashSet.add(1);
        hashSet.forEach(System.out::println);

        /**
         * 线程是否安全: 否
         * 底层结构: 底层为HashMap结构, key为键, value为同一个Object对象, 同时维护一个双向链表结构
         */
        LinkedHashSet linkedHashSet = new LinkedHashSet();
        linkedHashSet.add(2);
        linkedHashSet.forEach(System.out::println);

        /**
         * 线程是否安全: 否
         * 底层结构: 底层为NavigableMap结构, key为键, value为同一个Object对象
         */
        TreeSet treeSet = new TreeSet();
        treeSet.add(3);
        treeSet.forEach(System.out::println);

三、Map集合

        /**
         * 线程安全: 否
         * 底层结构: 底层为数组结构, 当哈希冲突的时候, 会调用equals方法, 如果返回true, 则直接覆盖
         * 否则对链表进行追加
         */
        HashMap<String, Integer> hashMap = new HashMap<>();
        hashMap.put("1", 1);
        hashMap.forEach(new BiConsumer<String, Integer>() {
            @Override
            public void accept(String s, Integer integer) {
                System.out.println("key=" + s + "  value" + integer);
            }
        });

        /**
         * 线程安全: 否
         * 底层结构: 底层为数组结构, 为了保证数据的顺序性, 同时维护了一个双链表结构
         */
        LinkedHashMap<String, Integer> linkedHashMap = new LinkedHashMap<>();
        linkedHashMap.put("1", 1);
        linkedHashMap.forEach(new BiConsumer<String, Integer>() {
            @Override
            public void accept(String s, Integer integer) {
                System.out.println("key=" + s + "  value" + integer);
            }
        });

        /**
         * 线程安全: 是
         * 底层结构: 底层数据结构砼hashMap, 由于要维护线程安全, 所以执行效率较低
         */
        Hashtable<String, Integer> hashtable = new Hashtable<>();
        hashtable.put("1", 1);
        hashMap.forEach(new BiConsumer<String, Integer>() {
            @Override
            public void accept(String s, Integer integer) {
                System.out.println("key=" + s + "  value" + integer);
            }
        });

        /**
         * 线程安全: 否
         * 底层结构: 底层为二叉树结构, 由于要维护排序, 所以执行效率较低
         */
        TreeMap<String, Integer> treeMap = new TreeMap<>();
        treeMap.put("1", 1);
        treeMap.forEach(new BiConsumer<String, Integer>() {
            @Override
            public void accept(String s, Integer integer) {
                System.out.println("key=" + s + "  value" + integer);
            }
        });

针对Java中的集合, 简要介绍如此, 如详细确定内容中的每一步, 还请查看源码.