Java集合框架

唯杭主义者

已于 2023-08-10 14:49:43 修改

阅读量90

点赞数

文章标签： java 开发语言

于 2023-08-08 16:50:12 首次发布

本文链接：https://blog.csdn.net/weixin_65081564/article/details/132170057

版权

1 集合框架概述

1. 集合和数组的区别

数组的弊端

数组初始化以后，长度就不可变了，不便于扩展
数组中提供的属性和方法少，不便于进行添加、删除、插入等操作，且效率不高。同时无法直接获取存储元素的个数
数组存储的数据是有序的、可以重复的。 ---->存储数据的特点单一
Java 集合类可以用于存储数量不等的多个对象，还可用于保存具有映射关系的关联数组。

2. 集合使用场景

在这里插入图片描述

3. 集合类关系图

在这里插入图片描述

2 Collection接口

简介

Collection 接口是 List、 Set 和 Queue 接口的父接口，该接口里定义的方法既可用于操作 Set 集合，也可用于操作 List 和 Queue 集合。
JDK不提供此接口的任何直接实现，而是提供更具体的子接口(如： Set和List)实现。
在 Java5 之前， Java 集合会丢失容器中所有对象的数据类型，把所有对象都当成 Object 类型处理；从 JDK 5.0 增加了泛型以后， Java 集合可以记住容器中对象的数据类型。

接口方法

添加
- add(Object obj)
- addAll(Collection coll)
获取有效元素的个数
- int size()
清空集合
- void clear()
是否是空集合
- boolean isEmpty()
是否包含某个元素
- boolean contains(Object obj)：是通过元素的equals方法来判断是否是同一个对象
- boolean containsAll(Collection c)：也是调用元素的equals方法来比较的。拿两个集合的元素挨个比较。
删除
- boolean remove(Object obj) ：通过元素的equals方法判断是否是要删除的那个元素。只会删除找到的第一个元素
- boolean removeAll(Collection coll)：取当前集合的差集
取两个集合的交集
- boolean retainAll(Collection c)：把交集的结果存在当前集合中，不影响c
集合是否相等
- boolean equals(Object obj)
转成对象数组
- Object[] toArray()
遍历
- iterator()：返回迭代器对象，用于集合遍历

Collection的使用

    @Test
    public void test1() {
        Collection c1 = new ArrayList();

        //添加元素
        c1.add("hello");
        c1.add("world");
        c1.add("tom");
        c1.add("jarray");
        c1.add(123); //自动装箱int->Integer
        c1.add(456);

        //添加自定义对象
        c1.add(new User("马云", 45));
        c1.add(new User("马化腾", 35));

        //删除对象
        c1.remove("tom");
//        c1.clear(); //清空


        System.out.println("isEmpty = " + c1.isEmpty());

        String s1 = new String("hello");
        System.out.println("contains = " +  c1.contains(s1)); //true，比较内容

        System.out.println(c1);

    }

contains方法：
调用equals，比较内容，因为string实现了equals比较，所以String比较内容使用User自定义equals，查看contains结果

User.java

    @Override
    public boolean equals(Object o) {
        System.out.println("User equals()....");
//        return super.equals(o);
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        User user = (User) o;

        if (age != user.age) return false;
        return name != null ? name.equals(user.name) : user.name == name;
    }

测试代码

        //添加自定义对象
        User u1 = new User("马云", 45);
        User u2 = new User("马云", 45);
        User u3 = new User("马云", 45);
        c1.add(u1);
        c1.add(u2);
        c1.add(new User("马化腾", 35));
        System.out.println(c1.size());
        System.out.println("contains马云 = " + c1.contains(u3)); //调用equals，比较内容,返回true

3 Iterator迭代器接口

简介：
● Iterator对象称为迭代器(设计模式的一种)，主要用于遍历 Collection 集合中的元素。
● GOF给迭代器模式的定义为：提供一种方法访问一个容器(container)对象中各个元素，而又不需暴露该对象的内部细节。迭代器模式，就是为容器而生。类似于“公交车上的售票员”、“火车上的乘务员”、 “空姐” 。
● Collection接口继承了java.lang.Iterable接口，该接口有一个iterator()方法，那么所有实现了Collection接口的集合类都有一个iterator()方法，用以返回一个实现了Iterator接口的对象。
● Iterator 仅用于遍历集合， Iterator 本身并不提供承装对象的能力。如果需要创建Iterator 对象，则必须有一个被迭代的集合。
● 集合对象每次调用iterator()方法都得到一个全新的迭代器对象，默认游标都在集合的第一个元素之前。

案例

    @Test
    public void test2() {
        Collection c1 = new ArrayList();

        //添加元素
        c1.add("hello");
        c1.add("world");
        c1.add("tom");
        c1.add("jarray");
        c1.add(123); //自动装箱int->Integer
        c1.add(456);

        //添加自定义对象
        c1.add(new User("马云", 45));
        c1.add(new User("马化腾", 35));

//        Iterator it = c1.iterator();
//
//        Object obj =  it.next();
//        System.out.println(obj);
//
//        obj =  it.next();
//        System.out.println(obj);

        //iterator循环集合
        Iterator it = c1.iterator();
        while (it.hasNext()) {
            Object obj = it.next();

            if ("tom".equals(obj)) {
                it.remove();
            }

            System.out.println(obj);
        }

        System.out.println(c1);
    }

    /**
     * 增强for循环，底层是Iterator循环
     */
    @Test
    public void test3() {
        Collection c1 = new ArrayList();

        //添加元素
        c1.add("hello");
        c1.add("world");
        c1.add("tom");
        c1.add("jarray");
        c1.add(123); //自动装箱int->Integer
        c1.add(456);

        //添加自定义对象
        c1.add(new User("马云", 45));
        c1.add(new User("马化腾", 35));

        for (Object obj : c1) {
            System.out.println(obj);
        }

        //idea的模板 ctrl + j显示所有的模板
        //iter：增强for循环的模板

        List c2 = new ArrayList();
        c2.add("a");
        c2.add("b");
        c2.add(1);
        c2.add(3);
        c2.add(2);

        //iter
        for (Object o : c2) {
            System.out.println(o);
        }

        //itar
        // FIXME: 2023/8/7 这里有个错误，回头改
        // TODO: 2023/8/7  这里有个bug，回头改
        for (int i = 0; i < c2.size(); i++) {
            System.out.println(c2.get(i));
        }

    }

4 List接口

简介
● 鉴于Java中数组用来存储数据的局限性，我们通常使用List替代数组
● List集合类中元素有序、且可重复，集合中的每个元素都有其对应的顺序索引。
● List容器中的元素都对应一个整数型的序号记载其在容器中的位置，可以根据序号存取容器中的元素。
● JDK API中List接口的实现类常用的有： ArrayList、 LinkedList和Vector。
List接口方法
List除了从Collection集合继承的方法外， List 集合里添加了一些根据索引来操作集合元素的方法。
● void add(int index, Object ele):在index位置插入ele元素boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来
● Object get(int index):获取指定index位置的元素
● int indexOf(Object obj):返回obj在集合中首次出现的位置
● int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置
● Object remove(int index):移除指定index位置的元素，并返回此元素
● Object set(int index, Object ele):设置指定index位置的元素为ele
● List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的子集合

    @Test
    public void test1() {
        List list = new ArrayList();

        list.add("aaa");
        list.add("bbb");
        list.add("aaa");
        list.add("aaa");
        list.add(0, 111);
        list.add(0, 222);
        list.add(0, 333);

        //get
        System.out.println(list.get(3));

        //indexOf
        System.out.println(list.indexOf("aaa"));
        System.out.println(list.lastIndexOf("aaa"));

        //remove
        list.remove(0);
        list.remove("aaa");

        System.out.println(list);

        System.out.println(list.subList(0, 3));

    }

4.1 ArrayList

ArrayList 是窑量可以改变的非线程安全集合。内部实现使用数组进行存储，集合扩容时会创建更大的数组空间，把原有数据复制到新数组中。 ArrayList 支持对元素的快速随机访问，但是插入与删除时速度通常很慢，因为这个过程很有可能需要移动其他元素。

● ArrayList 是 List 接口的典型实现类、主要实现类
● 本质上， ArrayList是对象引用的一个”变长”数组
● ArrayList的JDK1.8之前与之后的实现区别？
○ JDK1.7： ArrayList像饿汉式，直接创建一个初始容量为10的数组
○ JDK1.8： ArrayList像懒汉式，一开始创建一个长度为0的数组，当添加第一个元素时再创建一个始容量为10的数组
● Arrays.asList(…) 方法返回的 List 集合，既不是 ArrayList 实例，也不是Vector 实例。 Arrays.asList(…) 返回值是一个固定长度的 List 集合

4.2 LinkedList

LinkedList 的本质是双向链表。与 Array List 相比， LinkedList 的插入和删除速度更快，但是随机访问速度很慢。测试表明，对于 IO 万条的数据，与 ArrayList 相比，随机提取元素时存在数百倍的差距。除继承 AbstractList 抽象类外， LinkedList 还实现了另一个接口 Deque ，即 double-ended queue。这个接口同时具有队列和枝的性质。LinkedList 包含 3 个重要的成员 size 、first、 last 。 size 是双向链表中节点的个数。first 和 last 分别指向第一个和最后一个节点的引用。 LinkedList 的优点在于可以将零散的内存单元通过附加引用的方式关联起来，形成按链路顺序序查找的线性结构，内存利用率较高。
新增方法：
● void addFirst(Object obj)
● void addLast(Object obj)
● Object getFirst()
● Object getLast()
● Object removeFirst()
● Object removeLast()

LinkedList：双向链表，内部没有声明数组，而是定义了Node类型的first和last，用于记录首末元素。同时，定义内部类Node，作为LinkedList中保存数据的基本结构。 Node除了保存数据，还定义了两个变量：

prev变量记录前一个元素的位置
next变量记录下一个元素的位置

案例

    /**
     * 1. 有序：插入顺序
     * 2. 允许重复
     * 3. 底层是数组，默认大小10，每次扩容1.5倍
     *      - jdk1.7：默认大小10
     *      - jdk1.8 默认大小0，第一次使用时初始化成10
     * 4：添加和删除，性能差，随机遍历性能好
     */
    @Test
    public void test2() {
        List list = new ArrayList();

        list.add("ccc");
        list.add("ccc");
        list.add("bbb");
        list.add("aaa");

        User u1 = new User("马云", 45);
        User u2 = new User("马化腾", 38);
        list.add(u1);
        list.add(u1);
        list.add(u2);

        //方式1
        for (Object o : list) {
            System.out.println(o);
        }
        System.out.println("-------------");
        //方式2
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        System.out.println("-------------");
        for (Iterator iterator = list.iterator(); iterator.hasNext(); ) {
            Object obj =  iterator.next();
            System.out.println(obj);
        }
    }

    /**
     * 1. 底层原理：基于双向链表实现
     * 2. 插入和删除块，遍历性能差
     * 3. 可以直接操作头和尾
     * 4. 有序（插入顺序），容许重复
     */
    @Test
    public void test3() {
        LinkedList list = new LinkedList();

        list.add("ccc");
        list.add("ccc");
        list.add("bbb");
        list.add("aaa");

        User u1 = new User("马云", 45);
        User u2 = new User("马化腾", 38);
        list.add(u1);
        list.add(u1);
        list.add(u2);

        list.addFirst("1111");
        list.addLast("2222");

        System.out.println(list.getLast());

        //方式1
        for (Object o : list) {
            System.out.println(o);
        }

    }

4.3 Vector

● Vector 是一个古老的集合， JDK1.0就有了。大多数操作与ArrayList相同，区别之处在于Vector是线程安全的。
● 在各种list中，最好把ArrayList作为缺省选择。当插入、删除频繁时，使用LinkedList； Vector总是比ArrayList慢，所以尽量避免使用。
● 新增方法：
○ void addElement(Object obj)
○ void insertElementAt(Object obj,int index)
○ void setElementAt(Object obj,int index)
○ void removeElement(Object obj)
○ void removeAllElements()

面试题：
请问ArrayList/LinkedList/Vector的异同？谈谈你的理解？ ArrayList底层是什么？扩容机制？ Vector和ArrayList的最大区别?

● ArrayList和LinkedList的异同二者都线程不安全，相对线程安全的Vector，执行效率高。此外， ArrayList是实现了基于动态数组的数据结构， LinkedList基于链表的数据结构。对于随机访问get和set， ArrayList觉得优于LinkedList，因为LinkedList要移动指针。对于新增和删除操作add(特指插入)和remove， LinkedList比较占优势，因为ArrayList要移动数据。
● ArrayList和Vector的区别Vector和ArrayList几乎是完全相同的,唯一的区别在于Vector是同步类(synchronized)，属于强同步类。因此开销就比ArrayList要大，访问要慢。正常情况下,大多数的Java程序员使用ArrayList而不是Vector,因为同步完全可以由程序员自己来控制。 Vector每次扩容请求其大小的2倍空间，而ArrayList是1.5倍。 Vector还有一个子类Stack。

5 Set接口

Set 是不允许出现重复元素的集合类型。 Set 体系最常用的是 Hash Set 、 TreeSet和 LinkedHashSet 三个集合类。 HashSet 从源码分析是使用 HashMap 来实现的，只是Value 固定为一个静态对象，使用 Key 保证集合元素的唯性，但它不保证集合元素的顺序。 TreeSet 也是如此，从源码分析是使用 TreeMap 来实现的，底层为树结构，在添加新元素到集合中时，按照某种比较规则将其插入合适的位置，保证插入后的集合仍然是有序的。 LinkedHashSet 继承自 HashSet ，具有 HashSet 的优点，内部使用链表维护了元素插入顺序。

5.1 HashSet

简介

● HashSet 是 Set 接口的典型实现，大多数时候使用 Set 集合时都使用这个实现类。

● HashSet 按 Hash 算法来存储集合中的元素，因此具有很好的存取、查找、删除性能。

● HashSet 具有以下特点：
○ 不能保证元素的排列顺序
○ HashSet 不是线程安全的
○ 集合元素可以是 null

案例1：基本使用

    /**
     * 基本使用
     * 1. 无序
     * 2. 没有重复
     */
    @Test
    public void test1() {
        List list = new ArrayList();
        list.add("ccc");
        list.add("ccc");
        list.add("bbb");
        list.add("aaa");
        list.add("aaa");
        list.add("eee");
        list.add("fff");
        list.add("ggg");
        list.add("hhh");
        list.add("mmm");

        System.out.println(list);

        System.out.println("--------------");

        Set set = new HashSet();

        set.add("ccc");
        set.add("ccc");
        set.add("bbb");
        set.add("aaa");
        set.add("aaa");
        set.add("aaa");
        set.add("eee");
        set.add("fff");
        set.add("ggg");
        set.add("hhh");
        set.add("mmm");

        System.out.println(set);
    }

    @Test
    public void test2() {
        Set set = new HashSet();

        set.add("ccc");
        set.add("ccc");
        set.add("bbb");
        set.add("aaa");
        set.add("aaa");
        set.add("aaa");
        set.add("eee");
        set.add("fff");
        set.add("ggg");
        set.add("hhh");
        set.add("mmm");

        //方式1 增强for循环
        for (Object o : set) {
            System.out.println(o);
        }
        System.out.println("----------");
        //方式2 Iterator
        Iterator it = set.iterator();
        while (it.hasNext()) {
            Object obj =  it.next();
            System.out.println(obj);
        }

    }

原理：
● HashSet底层是HashMap实现的，只要用key，value存储一个静态的new Object
在这里插入图片描述
● HashSet 集合判断两个元素相等的标准：两个对象通过 hashCode() 方法比较相等，并且两个对象的 equals() 方法返回值也相等。
● 对于存放在Set容器中的对象，对应的类一定要重写equals()和hashCode(Objectobj)方法，以实现对象相等规则。即： “相等的对象必须具有相等的散列码” 。
● 向HashSet中添加元素的过程：

当向 HashSet 集合中存入一个元素时， HashSet 会调用该对象的 hashCode() 方法来得到该对象的 hashCode 值，然后根据 hashCode 值，通过某种散列函数决定该对象在 HashSet 底层数组中的存储位置。（这个散列函数会与底层数组的长度相计算得到在数组中的下标，并且这种散列函数计算还尽可能保证能均匀存储元素，越是散列分布，该散列函数设计的越好）
如果两个元素的hashCode()值相等，会再继续调用equals方法，如果equals方法结果为true，添加失败；如果为false，那么会保存该元素，但是该数组的位置已经有元素了，那么会通过链表的方式继续链接。
如果两个元素的 equals() 方法返回 true，但它们的 hashCode() 返回值不相等， hashSet 将会把它们存储在不同的位置，但依然可以添加成功。

在这里插入图片描述

//下面不同的字符串就有相同的hashCode
 System.out.println("ABCDEa123abc".hashCode());  // 165374702
 System.out.println("ABCDFB123abc".hashCode()); //  165374702

HashSet底层也是HashMap，初始容量为16，当如果使用率超过0.75，（16*0.75=12）就会扩大容量为原来的2倍。（16扩容为32，依次为64,128…等）

重写hashCode和equals原则
(1) hashCode
● 在程序运行时，同一个对象多次调用 hashCode() 方法应该返回相同的值。
● 当两个对象的 equals() 方法比较返回 true 时，这两个对象的 hashCode()方法的返回值也应相等。
● 对象中用作 equals() 方法比较的 Field，都应该用来计算 hashCode 值。
(2) equals
● 当一个类有自己特有的“逻辑相等”概念,当改写equals()的时候，总是要改写hashCode()，根据一个类的equals方法（改写后），两个截然不同的实例有可能在逻辑上是相等的，但是，根据Object.hashCode()方法，它们仅仅是两个对象。
● 因此，违反了“相等的对象必须具有相等的散列码”。
● 结论：复写equals方法的时候一般都需要同时复写hashCode方法。通常参与计算hashCode的对象的属性也应该参与到equals()中进行计算。

案例实现：
User.java

public class User {

    private String name;
    private int age;

    public User() {
    }

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        System.out.println("User equals()....");
//        return super.equals(o);
        if (this == o) return true; //内存地址相同返回true
        if (o == null || getClass() != o.getClass()) return false;

        User user = (User) o;

        if (age != user.age) return false;
        return name != null ? name.equals(user.name) : user.name == name;
    }

    /**
     *      * 注：**为什么hashCode中，用31这个数子？
     *      *
     *      * - 选择系数的时候要选择尽量大的系数。因为如果计算出来的hash地址越大，所谓的“冲突”就越少，查找起来效率也会提高。（减少冲突）
     *      * - 并且31只占用5bits,相乘造成数据溢出的概率较小。
     *      * - 31可以 由i*31== (i<<5)-1来表示,现在很多虚拟机里面都有做相关优化。 （提高算法效率）
     *      * - 31是一个素数，素数作用就是如果我用一个数字来乘以这个素数，那么最终出来的结果只能被素数本身和被乘数还有1来整除！ (减少冲突)
     * @return
     */
    @Override
    public int hashCode() { //return name.hashCode() + age;
        int result = name != null ? name.hashCode() : 0;
        result = 31 * result + age;
        return result;
    }


}

测试代码：

    /**
     * HashSet存入数据的过程
     * 1. 得到对象的hashCode，hashCode%16，决定落到那个槽位(默认16个槽位）Entry[16]
     * 2. 再次添加对象，如果对象的hashCode和第一次添加的相同，执行equals
     * 3. 如果equals返回true，hashCode相同，equals相同，添加失败
     * 4. 如果eques返回false，hashCode相同，形成一个链表
     *
     *
     */
    @Test
    public void test4() {
        Set set = new HashSet();
        User u1 = new User("马云", 45);
        User u2 = new User("马云", 45);
        User u3 = new User("马化腾", 40);
        User u4 = new User("马化腾", 40);
        User u5 = new User("奥巴马", 50);
        User u6 = new User("马云", 45);


        set.add(u1);
        set.add(u2);
        set.add(u3);
        set.add(u4);
        set.add(u5);
        set.add(u6);

        for (Object o : set) {
            System.out.println(o);
        }
    }

5.2 LinkedHashSet

● LinkedHashSet 是 HashSet 的子类
● LinkedHashSet 根据元素的 hashCode 值来决定元素的存储位置，但它同时使用双向链表维护元素的次序，这使得元素看起来是以插入顺序保存的。
● LinkedHashSet插入性能略低于 HashSet，但在迭代访问 Set 里的全部元素时有很好的性能。
● LinkedHashSet 不允许集合元素重复。
● LinkedHashSet 底层结构
在这里插入图片描述
案例：

public class LinkedHashSetDemo1 {

    /**
     * LinkedHashSet特点
     * - 不能重复
     * - 有序（跟插入顺序有关）
     * - 双向链表
     * @param args
     */
    public static void main(String[] args) {
        LinkedHashSet set = new LinkedHashSet();
        set.add("zzz");
        set.add("zzz");
        set.add("zzz");
        set.add("yyy");
        set.add("yyy");
        set.add("xxx");
        set.add("xxx");
        set.add("fff");
        set.add("eee");
        set.add("www");
        set.add("111");
        set.add("222");
        set.add("333");
        set.add("666");
        set.add("555");
        set.add("444");

        for (Object o : set) {
            System.out.println(o);
        }
    }

}

5.3 TreeSet

简介：
● TreeSet 是 SortedSet 接口的实现类， TreeSet 可以确保集合元素处于排序状态。
● TreeSet的特点
○ 有序（内容有序）
○ 不能有重复
● 新增的方法如下： (了解)
○ Comparator comparator()：返回定制排序器
○ Object first()：返回此集合中当前的第一个（最低）元素。
○ Object last()：返回此集合中当前的最后一个（最高）元素。
○ Object lower(Object e)：返回此集合中的最大元素严格小于给定元素，如果没有这样的元素，则 null 。
○ Object higher(Object e)
○ SortedSet subSet(fromElement, toElement)
○ SortedSet headSet(toElement)
○ SortedSet tailSet(fromElement)
案例：

public class TreeSetDemo1 {

    /**
     * TreeSet的特点
     * - 有序（通过内容排序），通过排序器Comparable进行排序
     * - 不能重复
     */
    @Test
    public void test1() {
        TreeSet set = new TreeSet();

        set.add("zzz");
        set.add("zzz");
        set.add("zzz");
        set.add("yyy");
        set.add("yyy");
        set.add("xxx");
        set.add("xxx");
        set.add("fff");
        set.add("eee");
        set.add("www");
        set.add("111");
        set.add("222");
        set.add("333");
        set.add("666");
        set.add("555");
        set.add("444");

        //得到第一个
        System.out.println(set.first());

        //得到最后一个
        System.out.println(set.last());

//        for (Object o : set) {
//            System.out.println(o);
//        }

    }

}

● TreeSet 两种排序方法：自然排序和定制排序。默认情况下， TreeSet 采用自然排序。
● TreeSet底层使用红黑树结构存储数据，特点：有序，查询速度比List快

在这里插入图片描述

自然排序：

自然排序： TreeSet 会调用集合元素的 compareTo(Object obj) 方法来比较元素之间的大小关系，然后将集合元素按升序(默认情况)排列
如果试图把一个对象添加到 TreeSet 时，则该对象的类必须实现 Comparable接口。
实现 Comparable 的类必须实现 compareTo(Object obj) 方法，两个对象即通过compareTo(Object obj) 方法的返回值来比较大小。
Comparable 的典型实现：
- BigDecimal、 BigInteger 以及所有的数值型对应的包装类：按它们对应的数值大小进行比较
- Character：按字符的 unicode值来进行比较
- Boolean： true 对应的包装类实例大于 false 对应的包装类实例
- String：按字符串中字符的 unicode 值进行比较
- Date、 Time：后边的时间、日期比前面的时间、日期大
向TreeSet 中添加元素时，只有第一个元素无须比较compareTo()方法，后面添加的所有元素都会调用compareTo()方法进行比较。
因为只有相同类的两个实例才会比较大小，所以向 TreeSet 中添加的应该是同一个类的对象。
对于 TreeSet 集合而言，它判断两个对象是否相等的唯一标准是：两个对象通过 compareTo(Object obj) 方法比较返回值。
当需要把一个对象放入 TreeSet 中，重写该对象对应的 equals() 方法时，应保证该方法与 compareTo(Object obj) 方法有一致的结果：如果两个对象通过equals() 方法比较返回 true，则通过 compareTo(Object obj) 方法比较应返回 0。否则，让人难以理解。

0：相等，添加失败
-1：小，放到左子树
1：大，放到右子树

案例：

public class User implements Comparable {

    private String name;
    private int age;

    public User() {
    }

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    //按照姓名从大到小排列,年龄从小到大排列
    @Override
    public int compareTo(Object o) {
        if(o instanceof User){
            User user = (User)o;
//            return -this.name.compareTo(user.name);
//            int compare = -this.name.compareTo(user.name);
            int compare = this.name.compareTo(user.name);
            if(compare != 0){
                return compare;
            }else{
                return Integer.compare(this.age,user.age);
            }
        }else{
            throw new RuntimeException("输入的类型不匹配");
        }

    }

}

public class TreeSetDemo1 {

    @Test
    public void test1() {
        System.out.println("cc".compareTo("ccc"));

//        System.out.println(Integer.compare(3, 2));
    }

    public static void main(String[] args) {
        User u1 = new User("aaa", 35);
        User u2 = new User("bbb", 36);
        User u3 = new User("ccc", 83);
        User u4 = new User("ccc", 30);
        User u5 = new User("ccc", 74);
        User u6 = new User("eee", 39);
        User u7 = new User("fff", 40);
        User u8 = new User("ggg", 40);
        User u9 = new User("ggg", 40);

        TreeSet set = new TreeSet();
        set.add(u1);
        set.add(u2);
        set.add(u3);
        set.add(u4);
        set.add(u5);
        set.add(u6);
        set.add(u7);
        set.add(u8);
        set.add(u9);


        for (Object o : set) {
            System.out.println(o);
        }


    }
}

6 Map接口

简介：
Map 集合是以 Key-Value 键值对作为存储元素实现的晗希结构， Key 按某种晗希函数计算后是唯一的， Value 则是可以重复的。 Map 类提供三种 Collection 视图，在集合框架图中， Map 指向 Collection 的箭头仅表示两个类之间的依赖关系。可以使用keySet（）查看所有的 K町，使用 values（）查看所有的 Value ，使用 ent可Set（）查看所有的键值对。最早用于存储键值对的 Hashtable 因为性能瓶颈已经被淘汰，而如今广泛使用的 HashMap ，线程是不安全的。 ConcurrentHashMap 是线程安全的，在 JDK8 中进行了锁的大幅度优化，体现出不错的性能。在多线程并发场景中，优先推荐使用ConcurrentHashMap ，而不是 HashMap 。 TreeMap 是 Key 有序的 Map 类集合。

● Map与Collection并列存在。用于保存具有映射关系的数据:key-value
● Map 中的 key 和 value 都可以是任何引用类型的数据
● Map 中的 key 用Set来存放，不允许重复，即同一个 Map 对象所对应的类，须重写hashCode()和equals()方法
● key 和 value 之间存在单向一对一关系，即通过指定的 key 总能找到唯一的、确定的 value
● Map接口的常用实现类： HashMap、 TreeMap、 LinkedHashMap和Properties。其中， HashMap是 Map 接口使用频率最高的实现类
● Map的基本结构如下：
在这里插入图片描述

常用方法：
● 添加、删除、修改操作：
○ Object put(Object key,Object value)：将指定key-value添加到(或修改)当前map对象中
○ void putAll(Map m):将m中的所有key-value对存放到当前map中
○ Object remove(Object key)：移除指定key的key-value对，并返回value
○ void clear()：清空当前map中的所有数据
● 元素查询的操作：
○ Object get(Object key)：获取指定key对应的value
○ boolean containsKey(Object key)：是否包含指定的key
○ boolean containsValue(Object value)：是否包含指定的value
○ int size()：返回map中key-value对的个数
○ boolean isEmpty()：判断当前map是否为空
○ boolean equals(Object obj)：判断当前map和参数对象obj是否相等
● 元视图操作的方法：
○ Set keySet()：返回所有key构成的Set集合
○ Collection values()：返回所有value构成的Collection集合
○ Set entrySet()：返回所有key-value对构成的Set集合

基本使用案例：

public class MapDemo {

    /**
     * - 存储结构 <key, value> -> entry
     * - key无序，不能重复,可以为null
     * - value 能重复
     */
    @Test
    public void test1() {
        Map map = new HashMap<>();
        //存
        map.put("aaaa", 11);
        map.put("aaaa", 1111);
        map.put("bbbb", 22);
        map.put("cccc", 33);
        map.put("dddd", 44);
        map.put("eeee", 55);
        map.put("eeee", 5555);
        map.put("ffff", 666);
        map.put("gggg", 666);
        map.put("hhhh", 666);
        map.put("3333", 666);
        map.put("4444", 666);
        map.put("1111", 666);
        map.put("2222", 666);
        map.put(null, 666);

        map.remove("2222");
//        map.clear();

        //取值
        System.out.println(map.get("2222"));
        System.out.println(map.get("aaaa"));
        System.out.println(map.containsKey("dddd"));

        //keySet values, entry

        System.out.println(map.keySet()); //key组成的集合Set

        System.out.println(map.values()); //value组成的集合Collection

        Set<Map.Entry> entries = map.entrySet(); //[<key,value>,...]

        //循环entries
        for (Map.Entry entry : entries) {
            System.out.println(entry.getKey() + "\t" + entry.getValue());
        }

    }

    /**
     * 迭代
     */
    @Test
    public void test2() {
        Map map = new HashMap<>();
        //存
        map.put("aaaa", 11);
        map.put("aaaa", 1111);
        map.put("bbbb", 22);
        map.put("cccc", 33);
        map.put("dddd", 44);
        map.put("eeee", 55);

        Set entries = map.entrySet();
        //方式1：使用Entry循环
        for (Object obj : entries) {
            Map.Entry entry = (Map.Entry) obj;
            System.out.println(entry.getKey() +  "\t" + entry.getValue());
        }
        System.out.println("-----------------------------");
        Iterator it = entries.iterator();
        while (it.hasNext()) {
            Map.Entry entry = (Map.Entry) it.next();
            System.out.println(entry.getKey() +  "\t" + entry.getValue());
        }

        System.out.println("-----------------------------");
        //方式2使用KeySet循环
        Set keys = map.keySet();
        for (Object key : keys) {
            System.out.println(key + "\t" + map.get(key));
        }

    }

}

6.1 HashMap

简介
● 允许使用null键和null值，与HashSet一样，不保证映射的顺序。
● 所有的key构成的集合是Set:无序的、不可重复的。所以， key所在的类要重写：equals()和hashCode()
● 所有的value构成的集合是Collection:无序的、可以重复的。所以， value所在的类要重写： equals()
● 一个key-value构成一个entry
● 所有的entry构成的集合是Set:无序的、不可重复的
● HashMap 判断两个 key 相等的标准是：两个 key 通过 equals() 方法返回 true，hashCode 值也相等。
● HashMap 判断两个 value相等的标准是：两个 value 通过 equals() 方法返回 true。

JDK1.7前存储结构
在这里插入图片描述

JDK 7及以前版本： HashMap是数组+链表结构(即为链地址法)

● HashMap的内部存储结构其实是数组和链表的结合。当实例化一个HashMap时，系统会创建一个长度为Capacity的Entry数组，这个长度在哈希表中被称为容量(Capacity)，在这个数组中可以存放元素的位置我们称之为“桶” (bucket)，每个bucket都有自己的索引，系统可以根据索引快速的查找bucket中的元素。

● 每个bucket中存储一个元素，即一个Entry对象，但每一个Entry对象可以带一个引用变量，用于指向下一个元素，因此，在一个桶中，就有可能生成一个Entry链。而且新添加的元素作为链表的head。

● 添加元素的过程：向HashMap中添加entry1(key， value)，需要首先计算entry1中key的哈希值(根据key所在类的hashCode()计算得到)，此哈希值经过处理以后，得到在底层Entry[]数组中要存储的位置i。如果位置i上没有元素，则entry1直接添加成功。如果位置i上已经存在entry2(或还有链表存在的entry3， entry4)，则需要通过循环的方法，依次比较entry1中key和其他的entry。如果彼此hash值不同，则直接添加成功。如果hash值相同，继续比较二者是否equals。如果返回值为true，则使用entry1的value去替换equals为true的entry的value。如果遍历一遍以后，发现所有的equals返回都为false,则entry1仍可添加成功。 entry1指向原有的entry元素。

● HashMap的扩容：当HashMap中的元素越来越多的时候， hash冲突的几率也就越来越高，因为数组的长度是固定的。所以为了提高查询的效率，就要对HashMap的数组进行扩容，而在HashMap数组扩容之后，最消耗性能的点就出现了：原数组中的数据必须重新计算其在新数组中的位置，并放进去，这就是resize。

● 那么HashMap什么时候进行扩容呢？当HashMap中的元素个数超过数组大小(数组总大小length,不是数组中个数size)loadFactor 时，就会进行数组扩容， loadFactor 的默认值(DEFAULT_LOAD_FACTOR)为0.75，这是一个折中的取值。也就是说，默认情况下，数组大小(DEFAULT_INITIAL_CAPACITY)为16，那么当HashMap中元素个数超过160.75=12（这个值就是代码中的threshold值，也叫做临界值）的时候，就把数组的大小扩展为 2*16=32，即扩大一倍，然后重新计算每个元素在数组中的位置，而这是一个非常消耗性能的操作，所以如果我们已经预知HashMap中元素的个数，那么预设元素的个数能够有效的提高HashMap的性能。

JDK 8存储结构

JDK 8版本发布以后： HashMap是数组+链表+红黑树实现。
在这里插入图片描述
● HashMap的内部存储结构其实是数组+链表+树的结合。当实例化一个HashMap时，会初始化initialCapacity和loadFactor，在put第一对映射关系时，系统会创建一个长度为initialCapacity的Node数组，这个长度在哈希表中被称为容量(Capacity)，在这个数组中可以存放元素的位置我们称之为“桶” (bucket)，每个bucket都有自己的索引，系统可以根据索引快速的查找bucket中的元素。

● 每个bucket中存储一个元素，即一个Node对象，但每一个Node对象可以带一个引用变量next，用于指向下一个元素，因此，在一个桶中，就有可能生成一个Node链。也可能是一个一个TreeNode对象，每一个TreeNode对象可以有两个叶子结点left和right，因此，在一个桶中，就有可能生成一个TreeNode树。而新添加的元素作为链表的last，或树的叶子结点。

● HashMap扩容：当HashMap中的元素个数超过数组大小(数组总大小length,不是数组中个数size)loadFactor 时，就会进行数组扩容， loadFactor 的默认值(DEFAULT_LOAD_FACTOR)为0.75，这是一个折中的取值。也就是说，默认情况下，数组大小(DEFAULT_INITIAL_CAPACITY)为16，那么当HashMap中元素个数超过160.75=12（这个值就是代码中的threshold值，也叫做临界值）的时候，就把数组的大小扩展为 2*16=32，即扩大一倍，然后重新计算每个元素在数组中的位置，而这是一个非常消耗性能的操作，所以如果我们已经预知HashMap中元素的个数，那么预设元素的个数能够有效的提高HashMap的性能。

● HashMap树化和链化：当HashMap中的其中一个链的对象个数如果达到了8个，此时如果capacity没有达到64，那么HashMap会先扩容解决，如果已经达到了64，那么这个链会变成树，结点类型由Node变成TreeNode类型。当然，如果当映射关系被移除后，下次resize方法时判断树的结点个数低于6个，也会把树再转为链表。

● 扩容和树化举个例子：
○ 初始情况下，hashmap 的capacity为16，因子为0.75。
○ 当hashmap桶内元素小于等于8，且size小于12时，不进行扩容和树化的操作。
○ 当hashmap桶内元素为9，因为capacity为16，因此不进行树化，而选择扩容，将capacity扩容为32。
○ 当hashmap桶内元素为10，因为capacity为32，因此不进行树化，而选择扩容，将capacity扩容为64。
○ 当hashmap桶内元素大于10，由于capacity已经达到64，此时进行树化。
○ 最后当HashMap中元素个数超过48（64*0.75=48），进行扩容

● JDK1.8HashMap新变化
○ HashMap map = new HashMap();//默认情况下，先不创建长度为16的数组
○ 当首次调用map.put()时，再创建长度为16的数组
○ 数组为Node类型，在jdk7中称为Entry类型
○ 形成链表结构时，新添加的key-value对在链表的尾部（七上八下）
○ 当数组指定索引位置的链表长度>8时，且map中的数组的长度> 64时，此索引位置上的所有key-value对使用红黑树进行存储。

HashMap源码中的重要常量
● DEFAULT_INITIAL_CAPACITY : 默认16，HashMap的默认容量
● MAXIMUM_CAPACITY ：默认2^30， HashMap的最大支持容量
● DEFAULT_LOAD_FACTOR：默认0.75， HashMap的默认加载因子
● TREEIFY_THRESHOLD：默认8 Bucket中链表长度大于该默认值，转化为红黑树
● UNTREEIFY_THRESHOLD：默认6，Bucket中红黑树存储的Node小于该默认值，转化为链表
● MIN_TREEIFY_CAPACITY：默认64，桶中的Node被树化时最小的hash表容量。（当桶中Node的数量大到需要变红黑树时，若hash表容量小于MIN_TREEIFY_CAPACITY时，此时应执行resize扩容操作这个MIN_TREEIFY_CAPACITY的值至少是TREEIFY_THRESHOLD的4倍。）
● table：存储元素的数组，总是2的n次幂
● entrySet：存储具体元素的集合
● size： HashMap中存储的键值对的数量
● modCount： HashMap扩容和结构改变的次数。
● threshold：扩容的临界值， =容量*填充因子
● loadFactor：填充因子
HashMap源码中的重要方法
● resize：扩容
● treeifyBin：树化
● untreeify：链化
扩容
● 默认HashMap产生，capacity默认容量0，第一次使用时，扩容成16
● 当元素个数超过12，会扩容resize
● 每次扩容一倍
树化
● TREEIFY_THRESHOLD：树化的阈值，默认8
● UNTREEIFY_THRESHOLD：链化的阈值，默认6
● MIN_TREEIFY_CAPACITY：最小树化的容量，默认64，如果元素个数没有超过这个阈值（64），即使链超过8，会先进行扩容，超过64才进行树化
● 比如下面所有元素的hashCode相同
○ 第一个元素，扩容到16
○ 第二个元素，形成链，链里面2个元素
○ …一直到链中有8个元素
○ 第9个元素，执行resize扩容到32
○ 第10个元素，执行resize扩容到64
○ 第11个元素，执行treeifyBin()方法树化
■ Node(next) 链
■ TreeNode（left，right）红黑树
链化
● 链的数量小于6，执行untreeify方法变成链

User.java

public class User {

    private String name;
    private int age;

    public User() {
    }

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

//    @Override
//    public boolean equals(Object o) {
//        System.out.println("User equals()....");
        return super.equals(o);
//        if (this == o) return true; //内存地址相同返回true
//        if (o == null || getClass() != o.getClass()) return false;
//
//        User user = (User) o;
//
//        if (age != user.age) return false;
//        return name != null ? name.equals(user.name) : user.name == name;
//    }

    /**
     *      * 注：**为什么hashCode中，用31这个数子？
     *      *
     *      * - 选择系数的时候要选择尽量大的系数。因为如果计算出来的hash地址越大，所谓的“冲突”就越少，查找起来效率也会提高。（减少冲突）
     *      * - 并且31只占用5bits,相乘造成数据溢出的概率较小。
     *      * - 31可以 由i*31== (i<<5)-1来表示,现在很多虚拟机里面都有做相关优化。 （提高算法效率）
     *      * - 31是一个素数，素数作用就是如果我用一个数字来乘以这个素数，那么最终出来的结果只能被素数本身和被乘数还有1来整除！ (减少冲突)
     * @return
     */
    @Override
    public int hashCode() { //return name.hashCode() + age;
        int result = name != null ? name.hashCode() : 0;
        result = 31 * result + age;
        return result;
    }


}

public class TreeifyDemo1 {

    public static void main(String[] args) {
        Map map = new HashMap();
        User u1 = new User("马云", 45);
        User u2 = new User("马云", 45);
        User u3 = new User("马云", 45);
        User u4 = new User("马云", 45);
        User u5 = new User("马云", 45);
        User u6 = new User("马云", 45);
        User u7 = new User("马云", 45);
        User u8 = new User("马云", 45);
        User u9 = new User("马云", 45);
        User u10 = new User("马云", 45);
        User u11 = new User("马云", 45);
        User u12 = new User("马云", 45);

        map.put(u1, "a");
        map.put(u2, "a");
        map.put(u3, "a");
        map.put(u4, "a");
        map.put(u5, "a");
        map.put(u6, "a");
        map.put(u7, "a");
        map.put(u8, "a");
        map.put(u9, "a");
        map.put(u10, "a");
        map.put(u11, "a");
        map.put(u12, "a");


        map.remove(u12);
        map.remove(u11);
        map.remove(u10);
        map.remove(u9);
        map.remove(u8);
        map.remove(u7);
        map.remove(u6);
        map.remove(u5);
        map.remove(u4);
        map.remove(u3);
        map.remove(u2);
        map.remove(u1);


        System.out.println(map);

    }
}

哈希取模算法
● 调用对象的hashCode()，确定数组中的槽位，确定数组中的槽位，采用的哈希取模算法
● put(key) -> (n-1) & hash
● 要求容量必须是2的n次方
面试题：HashMap的容量，为什么必须是2的n次幂

HashMap使用n-1 & hash得到槽位地址，这个运算n必须是2的n次幂，结论当容量是2的n次幂的时候(16,32…）hash % n = (n-1) & hash，因为位运算性能高

如果初始容量不是2的n次幂，HashMap调用tableSizeFor自动转换成大于这个数最小的2的n次幂

6.2 LinkedHashMap

● LinkedHashSet和LinedHashMap的关系，从逻辑上这两个集合实现方式完全一致，只是LinkedHashSet使用LinkedHashMap实现，只有key，而value是一个静态的空对象
● 底层使用链表实现
● 有顺序（插入顺序），没有重复的集合

    public static void main(String[] args) {
        LinkedHashSet set = new LinkedHashSet();
        set.add("zzz");
        set.add("zzz");
        set.add("zzz");
        set.add("yyy");
        set.add("yyy");
        set.add("xxx");
        set.add("xxx");
        set.add("fff");
        set.add("eee");
        set.add("www");
        set.add("111");
        set.add("222");
        set.add("333");
        set.add("666");
        set.add("555");
        set.add("444");

        for (Object o : set) {
            System.out.println(o);
        }
    }

在这里插入图片描述

6.3 TreeMap

● TreeSet使用TreeMap实现，只是value使用静态空对象，只是用key实现TreeSet
● TreeMap存储 Key-Value 对时，需要根据 key-value 对进行排序。TreeMap 可以保证所有的 Key-Value 对处于有序状态。
● TreeSet底层使用红黑树结构存储数据
● TreeMap 的 Key 的排序：
○ 自然排序： TreeMap 的所有的 Key 必须实现 Comparable 接口，而且所有的 Key 应该是同一个类的对象，否则将会抛出 ClasssCastException
○ 定制排序：创建 TreeMap 时，传入一个 Comparator 对象，该对象负责对TreeMap 中的所有 key 进行排序。此时不需要 Map 的 Key 实现Comparable 接口
● TreeMap判断两个key相等的标准：两个key通过compareTo()方法或者compare()方法返回0，1，-1
○ 0：对象相等，添加失败
○ -1：比对象小，添加到左边
○ 1：比对象打，添加到右边

自然排序
● 类实现Comparable接口，进行排序

public class User implements Comparable {

    private String name;
    private int age;

    public User() {
    }

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    //按照姓名从大到小排列,年龄从小到大排列
    @Override
    public int compareTo(Object o) {
        if(o instanceof User){
            User user = (User)o;
//            return -this.name.compareTo(user.name);
//            int compare = -this.name.compareTo(user.name);
            int compare = this.name.compareTo(user.name);
            if(compare != 0){
                return compare;
            }else{
                return Integer.compare(this.age,user.age);
            }
        }else{
            throw new RuntimeException("输入的类型不匹配");
        }

    }

}

public class TreeMapDemo1 {


    public static void main(String[] args) {
        User u1 = new User("ggg", 35);
        User u2 = new User("ggg", 35);
        User u3 = new User("ccc", 83);
        User u4 = new User("ccc", 30);
        User u5 = new User("ccc", 74);
        User u6 = new User("eee", 39);
        User u7 = new User("fff", 40);
        User u8 = new User("aaa", 40);
        User u9 = new User("bbb", 40);

        TreeMap map = new TreeMap();
        map.put(u1, "a");
        map.put(u2, "a");
        map.put(u3, "a");
        map.put(u4, "a");
        map.put(u5, "a");
        map.put(u6, "a");
        map.put(u7, "a");
        map.put(u8, "a");
        map.put(u9, "a");


        for (Object o : map.entrySet()) {
            System.out.println(o);
        }


    }
}

定制排序
● 使用Comparator，插入TreeSet定制排序器
● 定制排序器和自然排序都存在是，定制优先

public class User implements Comparable {

    private String name;
    private int age;

    public User() {
    }

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    //按照姓名从大到小排列,年龄从小到大排列
    @Override
    public int compareTo(Object o) {
        if(o instanceof User){
            User user = (User)o;
//            return -this.name.compareTo(user.name);
//            int compare = -this.name.compareTo(user.name);
            int compare = this.name.compareTo(user.name);
            if(compare != 0){
                return compare;
            }else{
                return Integer.compare(this.age,user.age);
            }
        }else{
            throw new RuntimeException("输入的类型不匹配");
        }

    }


}

public class TreeMapDemo1 {


    public static void main(String[] args) {
        User u1 = new User("ggg", 35);
        User u2 = new User("ggg", 35);
        User u3 = new User("ccc", 83);
        User u4 = new User("ccc", 30);
        User u5 = new User("ccc", 74);
        User u6 = new User("eee", 39);
        User u7 = new User("fff", 40);
        User u8 = new User("aaa", 40);
        User u9 = new User("bbb", 40);

        Comparator com = new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                if(o1 instanceof User && o2 instanceof User){
                    User u1 = (User) o1;
                    User u2 = (User) o2;

                    return -Integer.compare(u1.getAge(), u2.getAge());

//                    int compare = u1.getName().compareTo(u2.getName());
//                    if(compare != 0){
//                        return compare;
//                    }else{
//                        return Integer.compare(u1.getAge(), u2.getAge());
//                    }
                }else{
                    throw new RuntimeException("输入的类型不匹配");
                }
            }
        };

        TreeMap map = new TreeMap(com);
        map.put(u1, "a");
        map.put(u2, "a");
        map.put(u3, "a");
        map.put(u4, "a");
        map.put(u5, "a");
        map.put(u6, "a");
        map.put(u7, "a");
        map.put(u8, "a");
        map.put(u9, "a");


        for (Object o : map.entrySet()) {
            System.out.println(o);
        }


    }
}

6.4 Hashtable

● Hashtable是个古老的 Map 实现类， JDK1.0就提供了。不同于HashMap，Hashtable是线程安全的。
● Hashtable实现原理和HashMap相同，功能相同。底层都使用哈希表结构，查询速度快，很多情况下可以互用。
● 与HashMap不同， Hashtable 不允许使用 null 作为 key 和 value
● 与HashMap一样， Hashtable 也不能保证其中 Key-Value 对的顺序
● Hashtable判断两个key相等、两个value相等的标准，与HashMap一致。

public class HashTableDemo1 {

    public static void main(String[] args) {
        Hashtable map = new Hashtable();
        map.put("aaaa", 11);
        map.put("aaaa", 1111);
        map.put("bbbb", 22);
        map.put("cccc", 33);
        map.put("dddd", 44);
        map.put("eeee", 55);
        map.put("eeee", 5555);
        map.put("ffff", 666);
        map.put("gggg", 666);
        map.put("hhhh", 666);
        map.put("3333", 666);
        map.put("4444", 666);
        map.put("1111", 666);
        map.put("2222", 666);
//        map.put(null, 666); //不能存null

        for (Object key : map.entrySet()) {
            System.out.println(key + " " + map.get(key));
        }


    }
}

6.5 Properties

Properties 类是 Hashtable 的子类，该对象用于处理属性文件
由于属性文件里的 key、 value 都是字符串类型，所以 Properties 里的 key和 value 都是字符串类型
存取数据时，建议使用setProperty(String key,String value)方法和getProperty(String key)方法

user.dir = 项目目录

username=root
password=123456
jdbc.url=jdbc:mysql://localhost:3306/test
jdbc.driver=com.mysql.driver.Driver

public class PropertiesDemo1 {

    public static void main(String[] args) throws IOException {
        Properties properties = new Properties();
//        FileInputStream in  = new FileInputStream("F:\\work\\lxs\\49_java_basic\\01-Java-基础\\9-集合\\code\\java-demo9\\jdbc.properties");
        //文件在user.dir目录下，可以使用下面相对目录
        FileInputStream in  = new FileInputStream("jdbc.properties");
        properties.load(in);

        System.out.println(properties.getProperty("username"));
        System.out.println(properties.getProperty("password"));
        System.out.println(properties.getProperty("jdbc.url"));
        System.out.println(properties.getProperty("jdbc.driver"));
        in.close();

    }
}

7 Collections工具类

● Collections 是一个操作 Set、 List 和 Map 等集合的工具类
● Collections 中提供了一系列静态的方法对集合元素进行排序、查询和修改等操作，还提供了对集合对象设置不可变、对集合对象实现同步控制等方法
● 排序操作：（均为static方法）
○ reverse(List)：反转 List 中元素的顺序
○ shuffle(List)：对 List 集合元素进行随机排序
○ sort(List)：根据元素的自然顺序对指定 List 集合元素按升序排序
○ sort(List， Comparator)：根据指定的 Comparator 产生的顺序对 List 集合元素进行排序
○ swap(List， int， int)：将指定 list 集合中的 i 处元素和 j 处元素进行交换
● 查找、替换
○ Object max(Collection)：根据元素的自然顺序，返回给定集合中的最大元素
○ Object max(Collection， Comparator)：根据 Comparator 指定的顺序，返回给定集合中的最大元素
○ Object min(Collection)
○ Object min(Collection， Comparator)
○ int frequency(Collection， Object)：返回指定集合中指定元素的出现次数
○ void copy(List dest,List src)：将src中的内容复制到dest中
○ boolean replaceAll(List list， Object oldVal， Object newVal)：使用新值替换List 对象的所有旧值
● Collections 类中提供了多个 synchronizedXxx() 方法，该方法可使将指定集合包装成线程同步的集合，从而可以解决多线程并发访问集合时的线程安全问题
在这里插入图片描述

public class CollectionsDemo1 {

    @Test
    public void test1() {
        List list = new ArrayList();

        list.add("zzz");
        list.add("xxx");
        list.add("yyy");
        list.add("mmm");
        list.add("nnn");
        list.add("aaa");
        list.add("aaa");
        list.add("111");
        list.add("111");
        list.add("222");
        list.add("333");
        list.add("444");
//        list.add(555);
//        list.add(666);
//        list.add(new Date());



        System.out.println(list);

        Collections.reverse(list); //反转
        System.out.println("reverse =" + list);

        Collections.shuffle(list); //随机排序
        System.out.println("shuffle =" + list);

        //自然排序必须类型一致
        Collections.sort(list); //自然排序
        System.out.println("sort =" + list);

        Comparator com = new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                String s1 = (String) o1;
                String s2 = (String) o2;
                return -s1.compareTo(s2);
            }
        };

        Collections.sort(list, com); //定制排序
        System.out.println("sort =" + list);

        Collections.swap(list, 0, 1); //0,1交换
        System.out.println("sort =" + list);

        System.out.println("max=" + Collections.max(list)); //自然排序最大

        System.out.println("frequency=" + Collections.frequency(list, "aaa")); //自然排序最大

        List syncList = Collections.synchronizedList(list);  //返回线程安全的集合
        syncList.add("666");
    }

}