集合

Java集合体系

Java 集合可分为 Collection 和 Map 两大体系：

Collection 接口：用于存储一个一个的数据，也称单列数据集合
- List 子接口：用来存储有序的、可以重复的数据（主要用来替换数组，"动态"数组）
  - 实现类：ArrayList(主要实现类)、LinkedList、Vector
- Set 子接口：用来存储无序的、不可重复的数据（类似于高中讲的"集合"）
  - 实现类：HashSet(主要实现类)、LinkedHashSet、TreeSet
Map 接口：用于存储具有映射关系“key-value对”的集合，即一对一对的数据，也称双列数据集合(类似于高中的函数、映射。(x1,y1),(x2,y2) ---> y = f(x) )
- HashMap(主要实现类)、LinkedHashMap、TreeMap、Hashtable、Properties
JDK 提供的集合 AP I位于java.util包内
图示：集合框架全图
简图1：Collection接口继承树

20240316220425

简图2：Map接口继承树

20240316220434

Collection接口及方法

JDK不提供此接口的任何直接实现，而是提供更具体的子接口（如：Set和List）去实现
Collection 接口是 List和Set接口的父接口，该接口里定义的方法既可用于操作 Set 集合，也可用于操作 List 集合。方法如下：

添加

（1）add(E obj)：添加元素对象到当前集合中

（2）addAll(Collection other)：添加 other 集合中的所有元素对象到当前集合中，即 this = this ∪ other

注意：add 和 addAll 的区别

import org.junit.Test;

import java.util.ArrayList;
import java.util.Collection;

public class TestCollectionAdd {
    @Test
    public void testAdd(){
        //ArrayList是Collection的子接口List的实现类之一。
        Collection coll = new ArrayList();
        coll.add("小李广");
        coll.add("扫地僧");
        coll.add("石破天");
        System.out.println(coll);
    }

    @Test
    public void testAddAll(){
        Collection c1 = new ArrayList();
        c1.add(1);
        c1.add(2);
        System.out.println("c1集合元素的个数：" + c1.size());//2
        System.out.println("c1 = " + c1);

        Collection c2 = new ArrayList();
        c2.add(1);
        c2.add(2);
        System.out.println("c2集合元素的个数：" + c2.size());//2
        System.out.println("c2 = " + c2);

        Collection other = new ArrayList();
        other.add(1);
        other.add(2);
        other.add(3);
        System.out.println("other集合元素的个数：" + other.size());//3
        System.out.println("other = " + other);
        System.out.println();

        c1.addAll(other);
        System.out.println("c1集合元素的个数：" + c1.size());//5
        System.out.println("c1.addAll(other) = " + c1);

        c2.add(other);
        System.out.println("c2集合元素的个数：" + c2.size());//3
        System.out.println("c2.add(other) = " + c2);
    }
}

注意：coll.addAll(other);与coll.add(other);

20240316220549

判断

（3）int size()：获取当前集合中实际存储的元素个数

（4）boolean isEmpty()：判断当前集合是否为空集合

（5）boolean contains(Object obj)：判断当前集合中是否存在一个与 obj 对象 equals 返回 true 的元素

（6）boolean containsAll(Collection coll)：判断 coll 集合中的元素是否在当前集合中都存在。即 coll 集合是否是当前集合的“子集”

（7）boolean equals(Object obj)：判断当前集合与 obj 是否相等

import org.junit.Test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;

public class TestCollectionContains {
    @Test
    public void test01() {
        Collection coll = new ArrayList();
        System.out.println("coll在添加元素之前，isEmpty = " + coll.isEmpty());
        coll.add("小李广");
        coll.add("扫地僧");
        coll.add("石破天");
        coll.add("佛地魔");
        System.out.println("coll的元素个数" + coll.size());

        System.out.println("coll在添加元素之后，isEmpty = " + coll.isEmpty());
    }

    @Test
    public void test02() {
        Collection coll = new ArrayList();
        coll.add("小李广");
        coll.add("扫地僧");
        coll.add("石破天");
        coll.add("佛地魔");
        System.out.println("coll = " + coll);
        System.out.println("coll是否包含“小李广” = " + coll.contains("小李广"));
        System.out.println("coll是否包含“宋红康” = " + coll.contains("宋红康"));

        Collection other = new ArrayList();
        other.add("小李广");
        other.add("扫地僧");
        other.add("尚硅谷");
        System.out.println("other = " + other);

        System.out.println("coll.containsAll(other) = " + coll.containsAll(other));
    }

    @Test
    public void test03(){
        Collection c1 = new ArrayList();
        c1.add(1);
        c1.add(2);
        System.out.println("c1集合元素的个数：" + c1.size());//2
        System.out.println("c1 = " + c1);

        Collection c2 = new ArrayList();
        c2.add(1);
        c2.add(2);
        System.out.println("c2集合元素的个数：" + c2.size());//2
        System.out.println("c2 = " + c2);

        Collection other = new ArrayList();
        other.add(1);
        other.add(2);
        other.add(3);
        System.out.println("other集合元素的个数：" + other.size());//3
        System.out.println("other = " + other);
        System.out.println();

        c1.addAll(other);
        System.out.println("c1集合元素的个数：" + c1.size());//5
        System.out.println("c1.addAll(other) = " + c1);
        System.out.println("c1.contains(other) = " + c1.contains(other));
        System.out.println("c1.containsAll(other) = " + c1.containsAll(other));
        System.out.println();

        c2.add(other);
        System.out.println("c2集合元素的个数：" + c2.size());
        System.out.println("c2.add(other) = " + c2);
        System.out.println("c2.contains(other) = " + c2.contains(other));
        System.out.println("c2.containsAll(other) = " + c2.containsAll(other));
    }

}

删除

（8）void clear()：清空集合元素

（9） boolean remove(Object obj) ：从当前集合中删除第一个找到的与 obj 对象 equals 返回 true 的元素

（10）boolean removeAll(Collection coll)：从当前集合中删除所有与 coll 集合中相同的元素。即 this = this - this ∩ coll

（11）boolean retainAll(Collection coll)：从当前集合中删除两个集合中不同的元素，使得当前集合仅保留与 coll 集合中的元素相同的元素，即当前集合中仅保留两个集合的交集，即this = this ∩ coll

注意几种删除方法的区别

import org.junit.Test;

import java.util.ArrayList;
import java.util.Collection;
import java.util.function.Predicate;

public class TestCollectionRemove {
    @Test
    public void test01(){
        Collection coll = new ArrayList();
        coll.add("小李广");
        coll.add("扫地僧");
        coll.add("石破天");
        coll.add("佛地魔");
        System.out.println("coll = " + coll);

        coll.remove("小李广");
        System.out.println("删除元素\"小李广\"之后coll = " + coll);
        
        coll.clear();
        System.out.println("coll清空之后，coll = " + coll);
    }

    @Test
    public void test02() {
        Collection coll = new ArrayList();
        coll.add("小李广");
        coll.add("扫地僧");
        coll.add("石破天");
        coll.add("佛地魔");
        System.out.println("coll = " + coll);

        Collection other = new ArrayList();
        other.add("小李广");
        other.add("扫地僧");
        other.add("尚硅谷");
        System.out.println("other = " + other);

        coll.removeAll(other);
        System.out.println("coll.removeAll(other)之后，coll = " + coll);
        System.out.println("coll.removeAll(other)之后，other = " + other);
    }

    @Test
    public void test03() {
        Collection coll = new ArrayList();
        coll.add("小李广");
        coll.add("扫地僧");
        coll.add("石破天");
        coll.add("佛地魔");
        System.out.println("coll = " + coll);

        Collection other = new ArrayList();
        other.add("小李广");
        other.add("扫地僧");
        other.add("尚硅谷");
        System.out.println("other = " + other);

        coll.retainAll(other);
        System.out.println("coll.retainAll(other)之后，coll = " + coll);
        System.out.println("coll.retainAll(other)之后，other = " + other);
    }

}

其它

（12）Object[] toArray()：返回包含当前集合中所有元素的数组

（13）hashCode()：获取集合对象的哈希值

（14）iterator()：返回迭代器对象，用于集合遍历

public class TestCollectionContains {
    @Test
    public void test01() {
        Collection coll = new ArrayList();

        coll.add("小李广");
        coll.add("扫地僧");
        coll.add("石破天");
        coll.add("佛地魔");
		//集合转换为数组：集合的toArray()方法
        Object[] objects = coll.toArray();
        System.out.println("用数组返回coll中所有元素：" + Arrays.toString(objects));
		
        //对应的，数组转换为集合：调用Arrays的asList(Object ...objs)
        Object[] arr1 = new Object[]{123,"AA","CC"};
        Collection list = Arrays.asList(arr1);
        System.out.println(list);
    }
}

Iterator(迭代器)接口

Iterator接口

在程序开发中，经常需要遍历集合中的所有元素。针对这种需求，JDK 专门提供了一个接口java.util.Iterator。Iterator接口也是 Java 集合中的一员，但它与Collection、Map接口有所不同
- Collection 接口与 Map 接口主要用于存储元素
- Iterator，被称为迭代器接口，本身并不提供存储对象的能力，主要用于遍历 Collection 中的元素
Collection 接口继承了java.lang.Iterable接口，该接口有一个iterator()方法，那么所有实现了 Collection 接口的集合类都有一个iterator()方法，用以返回一个实现了 Iterator 接口的对象
- public Iterator iterator(): 获取集合对应的迭代器，用来遍历集合中的元素的
- 集合对象每次调用iterator()方法都得到一个全新的迭代器对象，默认游标都在集合的第一个元素之前
Iterator 接口的常用方法如下：
- public E next():返回迭代的下一个元素
- public boolean hasNext():如果仍有元素可以迭代，则返回 true
注意：在调用it.next()方法之前必须要调用it.hasNext()进行检测。若不调用，且下一条记录无效，直接调用it.next()会抛出NoSuchElementException异常

举例：

import org.junit.Test;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class TestIterator {
    @Test
    public void test01(){
        Collection coll = new ArrayList();
        coll.add("小李广");
        coll.add("扫地僧");
        coll.add("石破天");

        Iterator iterator = coll.iterator();
        System.out.println(iterator.next());
        System.out.println(iterator.next());
        System.out.println(iterator.next());
        System.out.println(iterator.next()); //报NoSuchElementException异常
    }

    @Test
    public void test02(){
        Collection coll = new ArrayList();
        coll.add("小李广");
        coll.add("扫地僧");
        coll.add("石破天");

        Iterator iterator = coll.iterator();//获取迭代器对象
        while(iterator.hasNext()) {//判断是否还有元素可迭代
            System.out.println(iterator.next());//取出下一个元素
        }
    }
}

迭代器的执行原理

Iterator 迭代器对象在遍历集合时，内部采用指针的方式来跟踪集合中的元素，接下来通过一个图例来演示 Iterator 对象迭代元素的过程：

20240316220920

使用 Iterator 迭代器删除元素：java.util.Iterator迭代器中有一个方法：void remove()

Iterator iter = coll.iterator();//回到起点
while(iter.hasNext()){
    Object obj = iter.next();
    if(obj.equals("Tom")){
        iter.remove();
    }
}

注意：

Iterator 可以删除集合的元素，但是遍历过程中通过迭代器对象的 remove 方法，不是集合对象的 remove 方法
如果还未调用next()或在上一次调用next()方法之后已经调用了remove()方法，再调用remove()都会报IllegalStateException
Collection 已经有remove(xx)方法了，为什么 Iterator 迭代器还要提供删除方法呢？因为迭代器的remove()可以按指定的条件进行删除

例如：要删除以下集合元素中的偶数

import org.junit.Test;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class TestIteratorRemove {
    @Test
    public void test01(){
        Collection coll = new ArrayList();
        coll.add(1);
        coll.add(2);
        coll.add(3);
        coll.add(4);
        coll.add(5);
        coll.add(6);

        Iterator iterator = coll.iterator();
        while(iterator.hasNext()){
            Integer element = (Integer) iterator.next();
            if(element % 2 == 0){
                iterator.remove();
            }
        }
        System.out.println(coll);
    }
}

在 JDK8.0 时，Collection 接口有了 removeIf 方法，即可以根据条件删除

import org.junit.Test;

import java.util.ArrayList;
import java.util.Collection;
import java.util.function.Predicate;

public class TestCollectionRemoveIf {
    @Test
    public void test01(){
        Collection coll = new ArrayList();
        coll.add("小李广");
        coll.add("扫地僧");
        coll.add("石破天");
        coll.add("佛地魔");
        System.out.println("coll = " + coll);

        coll.removeIf(new Predicate() {
            @Override
            public boolean test(Object o) {
                String str = (String) o;
                return str.contains("地");
            }
        });
        System.out.println("删除包含\"地\"字的元素之后coll = " + coll);
    }
}

foreach循环

foreach 循环（也称增强for循环）是 JDK5.0 中定义的一个高级 for 循环，专门用来遍历数组和集合的
foreach 循环的语法格式：

for(元素的数据类型 局部变量 : Collection集合或数组){ 
  	//操作局部变量的输出操作
}
//这里局部变量就是一个临时变量，自己命名就可以

举例：

import org.junit.Test;

import java.util.ArrayList;
import java.util.Collection;

public class TestForeach {
    @Test
    public void test01(){
        Collection coll = new ArrayList();
        coll.add("小李广");
        coll.add("扫地僧");
        coll.add("石破天");
		//foreach循环其实就是使用Iterator迭代器来完成元素的遍历的。
        for (Object o : coll) {
            System.out.println(o);
        }
    }
    @Test
    public void test02(){
        int[] nums = {1,2,3,4,5};
        for (int num : nums) {
            System.out.println(num);
        }
        System.out.println("-----------------");
        String[] names = {"张三","李四","王五"};
        for (String name : names) {
            System.out.println(name);
        }
    }
}

对于集合的遍历，增强 for 的内部原理其实是个 Iterator 迭代器，如下图

20240316221106

它用于遍历 Collection 和数组。通常只进行遍历元素，不要在遍历的过程中对集合元素进行增删操作。
- 练习：判断输出结果为何？

public class ForTest {
    public static void main(String[] args) {
        String[] str = new String[5];
        for (String myStr : str) {
            myStr = "atguigu";
            System.out.println(myStr);
        }
        for (int i = 0; i < str.length; i++) {
            System.out.println(str[i]);
        }
    }
}

List

List接口特点

鉴于 Java 中数组用来存储数据的局限性，我们通常使用java.util.List替代数组
List 集合类中元素有序、且可重复，集合中的每个元素都有其对应的顺序索引
- 举例：List 集合存储数据，就像银行门口客服，给每一个来办理业务的客户分配序号：第一个来的是“张三”，客服给他分配的是0；第二个来的是“李四”，客服给他分配的1；以此类推，最后一个序号应该是“总人数-1”

20240316221134

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 位置的元素
- List subList(int fromIndex, int toIndex):返回从 fromIndex 到 toIndex 位置的子集合
获取元素索引
- int indexOf(Object obj):返回 obj 在集合中首次出现的位置
- int lastIndexOf(Object obj):返回 obj 在当前集合中末次出现的位置
删除和替换元素
- Object remove(int index):移除指定 index 位置的元素，并返回此元素
- Object set(int index, Object ele):设置指定 index 位置的元素为 ele

举例：

import java.util.ArrayList;
import java.util.List;

public class TestListMethod {
    public static void main(String[] args) {
        // 创建List集合对象
        List<String> list = new ArrayList<String>();

        // 往 尾部添加 指定元素
        list.add("图图");
        list.add("小美");
        list.add("不高兴");

        System.out.println(list);
        // add(int index,String s) 往指定位置添加
        list.add(1,"没头脑");

        System.out.println(list);
        // String remove(int index) 删除指定位置元素  返回被删除元素
        // 删除索引位置为2的元素
        System.out.println("删除索引位置为2的元素");
        System.out.println(list.remove(2));

        System.out.println(list);

        // String set(int index,String s)
        // 在指定位置 进行 元素替代（改）
        // 修改指定位置元素
        list.set(0, "三毛");
        System.out.println(list);

        // String get(int index)  获取指定位置元素
        // 跟size() 方法一起用  来 遍历的
        for(int i = 0;i<list.size();i++){
            System.out.println(list.get(i));
        }
        //还可以使用增强for
        for (String string : list) {
            System.out.println(string);
        }
    }
}

注意：在 JavaSE 中 List 名称的类型有两个，一个是java.util.List集合接口，一个是java.awt.List图形界面的组件，别导错包了

List接口主要实现类：ArrayList

ArrayList 是 List 接口的主要实现类
本质上，ArrayList 是对象引用的一个”变长”数组
Arrays.asList(…)方法返回的 List 集合，既不是 ArrayList 实例，也不是 Vector 实例。 Arrays.asList(…)返回值是一个固定长度的 List 集合

20240316221159

List的实现类之二：LinkedList

对于频繁的插入或删除元素的操作，建议使用 LinkedList 类，效率较高。这是由底层采用链表（双向链表）结构存储数据决定的
特有方法：
- void addFirst(Object obj)
- void addLast(Object obj)
- Object getFirst()
- Object getLast()
- Object removeFirst()
- Object removeLast()

List的实现类之三：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()

Set

Set接口概述

Set 接口是 Collection 的子接口，Set 接口相较于 Collection 接口没有提供额外的方法
Set 集合不允许包含相同的元素，如果试把两个相同的元素加入同一个 Set 集合中，则添加操作失败
Set 集合支持的遍历方式和 Collection 集合一样：foreach 和 Iterator
Set 的常用实现类有：HashSet、TreeSet、LinkedHashSet

Set主要实现类：HashSet

HashSet概述

HashSet 是 Set 接口的主要实现类，大多数时候使用 Set 集合时都使用这个实现类
HashSet 按 Hash 算法来存储集合中的元素，因此具有很好的存储、查找、删除性能
HashSet 具有以下特点：
- 不能保证元素的排列顺序
- HashSet 不是线程安全的
- 集合元素可以是 null
HashSet 集合判断两个元素相等的标准：两个对象通过 hashCode() 方法得到的哈希值相等，并且两个对象的 equals()方法返回值为 true
对于存放在 Set 容器中的对象，对应的类一定要重写hashCode()和equals(Object obj)方法，以实现对象相等规则。即：“相等的对象必须具有相等的散列码”
HashSet 集合中元素的无序性，不等同于随机性。这里的无序性与元素的添加位置有关。具体来说：我们在添加每一个元素到数组中时，具体的存储位置是由元素的hashCode()调用后返回的hash值决定的。导致在数组中每个元素不是依次紧密存放的，表现出一定的无序性

HashSet中添加元素的过程：

第1步：当向 HashSet 集合中存入一个元素时，HashSet 会调用该对象的hashCode()方法得到该对象的 hashCode 值，然后根据 hashCode 值，通过某个散列函数决定该对象在 HashSet 底层数组中的存储位置
第2步：如果要在数组中存储的位置上没有元素，则直接添加成功
第3步：如果要在数组中存储的位置上有元素，则继续比较：
- 如果两个元素的 hashCode 值不相等，则添加成功；
- 如果两个元素的hashCode()值相等，则会继续调用equals()方法：
  - 如果equals()方法结果为 false，则添加成功
  - 如果equals()方法结果为 true，则添加失败

第2步添加成功，元素会保存在底层数组中第3步两种添加成功的操作，由于该底层数组的位置已经有元素了，则会通过链表的方式继续链接，存储

举例：

import java.util.Objects;

public class MyDate {
    private int year;
    private int month;
    private int day;

    public MyDate(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        MyDate myDate = (MyDate) o;
        return year == myDate.year &&
                month == myDate.month &&
                day == myDate.day;
    }

    @Override
    public int hashCode() {
        return Objects.hash(year, month, day);
    }

    @Override
    public String toString() {
        return "MyDate{" +
                "year=" + year +
                ", month=" + month +
                ", day=" + day +
                '}';
    }
}

import org.junit.Test;

import java.util.HashSet;

public class TestHashSet {
    @Test
    public void test01(){
        HashSet set = new HashSet();
        set.add("张三");
        set.add("张三");
        set.add("李四");
        set.add("王五");
        set.add("王五");
        set.add("赵六");

        System.out.println("set = " + set);//不允许重复，无序
    }

    @Test
    public void test02(){
        HashSet set = new HashSet();
        set.add(new MyDate(2021,1,1));
        set.add(new MyDate(2021,1,1));
        set.add(new MyDate(2022,2,4));
        set.add(new MyDate(2022,2,4));


        System.out.println("set = " + set);//不允许重复，无序
    }
}

重写 hashCode() 方法的基本原则

在程序运行时，同一个对象多次调用hashCode()方法应该返回相同的值
当两个对象的equals()方法比较返回 true 时，这两个对象的hashCode()方法的返回值也应相等
对象中用作equals()方法比较的 Field，都应该用来计算 hashCode 值

注意：如果两个元素的equals()方法返回 true，但它们的hashCode()返回值不相等，hashSet 将会把它们存储在不同的位置，但依然可以添加成功

重写equals()方法的基本原则

重写 equals 方法的时候一般都需要同时复写 hashCode 方法。通常参与计算 hashCode 的对象的属性也应该参与到equals()中进行计算
推荐：开发中直接调用 Eclipse/IDEA 里的快捷键自动重写equals()和hashCode()方法即可
- 为什么用 Eclipse/IDEA 复写 hashCode 方法，有31这个数字？

首先，选择系数的时候要选择尽量大的系数。因为如果计算出来的hash地址越大，所谓的“冲突”就越少，查找起来效率也会提高。（减少冲突）

其次，31只占用5bits,相乘造成数据溢出的概率较小

再次，31可以 由i*31== (i<<5)-1来表示,现在很多虚拟机里面都有做相关优化（提高算法效率）

最后，31是一个素数，素数作用就是如果我用一个数字来乘以这个素数，那么最终出来的结果只能被素数本身和被乘数还有1来整除！(减少冲突)

Set实现类之二：LinkedHashSet

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

20240316221814

举例：

import org.junit.Test;

import java.util.LinkedHashSet;

public class TestLinkedHashSet {
    @Test
    public void test01(){
        LinkedHashSet set = new LinkedHashSet();
        set.add("张三");
        set.add("张三");
        set.add("李四");
        set.add("王五");
        set.add("王五");
        set.add("赵六");

        System.out.println("set = " + set);//不允许重复，体现添加顺序
    }
}

Set实现类之三：TreeSet

TreeSet概述

TreeSet 是 SortedSet 接口的实现类，TreeSet 可以按照添加的元素的指定的属性的大小顺序进行遍历。
TreeSet底层使用红黑树结构存储数据
新增的方法如下： (了解)
- Comparator comparator()
- Object first()
- Object last()
- Object lower(Object e)
- Object higher(Object e)
- SortedSet subSet(fromElement, toElement)
- SortedSet headSet(toElement)
- SortedSet tailSet(fromElement)
TreeSet 特点：不允许重复、实现排序（自然排序或定制排序）
TreeSet 两种排序方法：自然排序和定制排序。默认情况下，TreeSet 采用自然排序
- 自然排序：TreeSet 会调用集合元素的compareTo(Object obj)方法来比较元素之间的大小关系，然后将集合元素按升序(默认情况)排列
  - 如果试图把一个对象添加到 TreeSet 时，则该对象的类必须实现 Comparable 接口
  - 实现 Comparable 的类必须实现compareTo(Object obj)方法，两个对象即通过compareTo(Object obj)方法的返回值来比较大小
- 定制排序：如果元素所属的类没有实现 Comparable 接口，或不希望按照升序(默认情况)的方式排列元素或希望按照其它属性大小进行排序，则考虑使用定制排序。定制排序，通过 Comparator 接口来实现。需要重写compare(T o1,T o2)方法
  - 利用int compare(T o1,T o2)方法，比较 o1 和 o2 的大小：如果方法返回正整数，则表示 o1 大于 o2；如果返回0，表示相等；返回负整数，表示 o1 小于 o2
  - 要实现定制排序，需要将实现 Comparator 接口的实例作为形参传递给 TreeSet 的构造器
因为只有相同类的两个实例才会比较大小，所以向 TreeSet 中添加的应该是同一个类的对象
对于 TreeSet 集合而言，它判断两个对象是否相等的唯一标准是：两个对象通过 compareTo(Object obj) 或compare(Object o1,Object o2)方法比较返回值。返回值为0，则认为两个对象相等

Map接口

现实生活与开发中，我们常会看到这样的一类集合：用户 ID 与账户信息、学生姓名与考试成绩、IP 地址与主机名等，这种一一对应的关系，就称作映射。Java 提供了专门的集合框架用来存储这种映射关系的对象，即java.util.Map接口

Map接口概述

Map 与 Collection 并列存在。用于保存具有映射关系的数据：key-value
- Collection集合称为单列集合，元素是孤立存在的（理解为单身）
- Map集合称为双列集合，元素是成对存在的(理解为夫妻)
Map 中的 key 和 value 都可以是任何引用类型的数据。但常用 String 类作为 Map 的“键”。
Map 接口的常用实现类：HashMap、LinkedHashMap、TreeMap和``Properties。其中，HashMap是 Map 接口使用频率最高`的实现类

20240316222023

Map中key-value特点

这里主要以 HashMap 为例说明。HashMap 中存储的 key、value 的特点如下：

20240316222043

Map 中的 key用Set来存放，不允许重复，即同一个 Map 对象所对应的类，须重写hashCode()和equals()方法
key 和 value 之间存在单向一对一关系，即通过指定的 key 总能找到唯一的、确定的 value，不同 key 对应的value可以重复。value 所在的类要重写equals()方法
key 和 value 构成一个 entry。所有的 entry 彼此之间是无序的、不可重复的

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 集合

举例：

import java.util.HashMap;

public class TestMapMethod {
    public static void main(String[] args) {
        //创建 map对象
        HashMap map = new HashMap();

        //添加元素到集合
        map.put("黄晓明", "杨颖");
        map.put("李晨", "李小璐");
        map.put("李晨", "范冰冰");
        map.put("邓超", "孙俪");
        System.out.println(map);

        //删除指定的key-value
        System.out.println(map.remove("黄晓明"));
        System.out.println(map);

        //查询指定key对应的value
        System.out.println(map.get("邓超"));
        System.out.println(map.get("黄晓明"));

    }
}

Map的主要实现类：HashMap

HashMap概述

HashMap 是 Map 接口使用频率最高的实现类
HashMap 是线程不安全的。允许添加 null 键和 null 值
存储数据采用的哈希表结构，底层使用一维数组+单向链表+红黑树进行 key-value 数据的存储。与 HashSet 一样，元素的存取顺序不能保证一致
HashMap 判断两个key相等的标准是：两个 key 的 hashCode 值相等，通过equals()方法返回 true
HashMap 判断两个value相等的标准是：两个 value 通过equals()方法返回 true

Map实现类之二：LinkedHashMap

LinkedHashMap 是 HashMap 的子类
存储数据采用的哈希表结构+链表结构，在 HashMap 存储结构的基础上，使用了一对双向链表来记录添加元素的先后顺序，可以保证遍历元素时，与添加的顺序一致
通过哈希表结构可以保证键的唯一、不重复，需要键所在类重写hashCode()方法、equals()方法

public class TestLinkedHashMap {
    public static void main(String[] args) {
        LinkedHashMap map = new LinkedHashMap();
        map.put("王五", 13000.0);
        map.put("张三", 10000.0);
        //key相同，新的value会覆盖原来的value
        //因为String重写了hashCode和equals方法
        map.put("张三", 12000.0);
        map.put("李四", 14000.0);
        //HashMap支持key和value为null值
        String name = null;
        Double salary = null;
        map.put(name, salary);

        Set entrySet = map.entrySet();
        for (Object obj : entrySet) {
        	Map.Entry entry = (Map.Entry)obj;
            System.out.println(entry);
        }
    }
}

Map实现类之三：TreeMap

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

public class TestTreeMap {
    /*
    * 自然排序举例
    * */
    @Test
    public void test1(){
        TreeMap map = new TreeMap();

        map.put("CC",45);
        map.put("MM",78);
        map.put("DD",56);
        map.put("GG",89);
        map.put("JJ",99);

        Set entrySet = map.entrySet();
        for(Object entry : entrySet){
            System.out.println(entry);
        }

    }

    /*
    * 定制排序
    *
    * */
    @Test
    public void test2(){
        //按照User的姓名的从小到大的顺序排列

        TreeMap map = new TreeMap(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 u1.name.compareTo(u2.name);
                }
                throw new RuntimeException("输入的类型不匹配");
            }
        });

        map.put(new User("Tom",12),67);
        map.put(new User("Rose",23),"87");
        map.put(new User("Jerry",2),88);
        map.put(new User("Eric",18),45);
        map.put(new User("Tommy",44),77);
        map.put(new User("Jim",23),88);
        map.put(new User("Maria",18),34);

        Set entrySet = map.entrySet();
        for(Object entry : entrySet){
            System.out.println(entry);
        }
    }
}

class User implements Comparable{
    String name;
    int age;

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

    public User() {
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    /*
    举例：按照age从小到大的顺序排列，如果age相同，则按照name从大到小的顺序排列
    * */
    @Override
    public int compareTo(Object o) {
        if(this == o){
            return 0;
        }

        if(o instanceof User){
            User user = (User)o;
            int value = this.age - user.age;
            if(value != 0){
                return value;
            }
            return -this.name.compareTo(user.name);
        }
        throw new RuntimeException("输入的类型不匹配");
    }
}

Map实现类之四：Hashtable

Hashtable 是 Map 接口的古老实现类，JDK1.0 就提供了。不同于 HashMap，Hashtable 是线程安全的
Hashtable 实现原理和 HashMap 相同，功能相同。底层都使用哈希表结构（数组+单向链表），查询速度快
与 HashMap 一样，Hashtable 也不能保证其中 Key-Value 对的顺序
Hashtable 判断两个 key 相等、两个 value 相等的标准，与HashMap一致
与 HashMap 不同，Hashtable 不允许使用 null 作为 key 或 value

面试题：Hashtable 和 HashMap 的区别

HashMap:底层是一个哈希表（jdk7:数组+链表;jdk8:数组+链表+红黑树）,是一个线程不安全的集合,执行效率高
Hashtable:底层也是一个哈希表（数组+链表）,是一个线程安全的集合,执行效率低

HashMap 集合:可以存储 null 的键、null 的值
Hashtable 集合,不能存储 null 的键、null 的值

Hashtable 和 Vector 集合一样,在 jdk1.2 版本之后被更先进的集合(HashMap,ArrayList)取代了。所以 HashMap 是 Map 的主要实现类，Hashtable 是 Map 的古老实现类。

Hashtable 的子类 Properties（配置文件）依然活跃在历史舞台
Properties 集合是一个唯一和 IO 流相结合的集合

Map实现类之五：Properties

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

@Test
public void test01() {
    Properties properties = System.getProperties();
    String fileEncoding = properties.getProperty("file.encoding");//当前源文件字符编码
    System.out.println("fileEncoding = " + fileEncoding);
}
@Test
public void test02() {
    Properties properties = new Properties();
    properties.setProperty("user","songhk");
    properties.setProperty("password","123456");
    System.out.println(properties);
}

@Test
public void test03() throws IOException {
    Properties pros = new Properties();
    pros.load(new FileInputStream("jdbc.properties"));
    String user = pros.getProperty("user");
    System.out.println(user);
}

Collections工具类

参考操作数组的工具类：Arrays，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)：根据 Comparator 指定的顺序，返回给定集合中的最小元素
int binarySearch(List list,T key)：在 List 集合中查找某个元素的下标，但是 List 的元素必须是 T 或 T 的子类对象，而且必须是可比较大小的，即支持自然排序的。而且集合也事先必须是有序的，否则结果不确定
int binarySearch(List list,T key,Comparator c)：在 List 集合中查找某个元素的下标，但是 List 的元素必须是 T 或 T 的子类对象，而且集合也事先必须是按照c比较器规则进行排序过的，否则结果不确定
int frequency(Collection c，Object o)：返回指定集合中指定元素的出现次数

复制、替换

void copy(List dest,List src)：将 src 中的内容复制到 dest 中
boolean replaceAll(List list，Object oldVal，Object newVal)：使用新值替换 List 对象的所有旧值
提供了多个unmodifiableXxx()方法，该方法返回指定 Xxx 的不可修改的视图。

添加

boolean addAll(Collection c,T... elements)将所有指定元素添加到指定 collection 中。

同步

Collections 类中提供了多个synchronizedXxx()方法，该方法可使将指定集合包装成线程同步的集合，从而可以解决多线程并发访问集合时的线程安全问题：

20240316223044

Java集合体系​

Collection接口及方法​

添加​

判断​

删除​

其它​

Iterator(迭代器)接口​

Iterator接口​

迭代器的执行原理​

foreach循环​

List​

List接口特点​

List接口方法​

List接口主要实现类：ArrayList​

List的实现类之二：LinkedList​

List的实现类之三：Vector​

Set​

Set接口概述​

Set主要实现类：HashSet​

HashSet概述​

HashSet中添加元素的过程：​

重写 hashCode() 方法的基本原则​

重写equals()方法的基本原则​

Set实现类之二：LinkedHashSet​

Set实现类之三：TreeSet​

TreeSet概述​

Map接口​

Map接口概述​

Map中key-value特点​

Map接口的常用方法​

Map的主要实现类：HashMap​

HashMap概述​

Map实现类之二：LinkedHashMap​

Map实现类之三：TreeMap​

Map实现类之四：Hashtable​

Map实现类之五：Properties​

Collections工具类​

常用方法​