Java集合（完整版）

集合框架

Collection集合

概念：对象的容器，定义了对多个对象进行操作的常用方法。可以实现数组的功能

和数组的区别：

数组的长度固定，集合长度不固定
数组可以存储基本类型和引用类型，集合只能存储引用类型

Collection体系集合

如图所示：

在这里插入图片描述

Collection：该体系结构的跟接口，代表一组对象，称为“集合”

List接口特点：有序，有下标，元素可重复

Set接口特点：无序，无下标，元素不可重复

Collection父接口

特点：代表一组任意类型的对象，无序，无下标，不能重复

方法：

boolean add (Object obj) // 添加一个对象
boolean addAll (Collection c) // 将一个集合中的所有对象添加到此集合中
void clear () // 清空此集合中的所有对象
boolean contains (Object o) // 检查此集合中是否包含o对象
boolean equals (Object o) // 比较此集合是否与指定对象相等
boolean isEmpty () // 判断此集合是否为空
boolean remove (Object o) // 在此集合中移除o对象
int size () // 返回此集合中的元素个数

Object [ ] toArray () // 将此集合转换成数组

下面是保存字符串的代码验证：

package com.collection.Demo01;

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

public class Demo01 {

    public static void main(String[] args) {

        // 创建集合
        // 一、 保存字符串
        Collection collection = new ArrayList();
        // 1. 添加元素
        collection.add("苹果");
        collection.add("西瓜");
        collection.add("榴莲");
        System.out.println("添加之后的元素个数：" + collection.size());  // 添加之后的元素个数：3
        System.out.println(collection);  // [苹果, 西瓜, 榴莲]
        // 2. 删除元素
        // collection.remove("榴莲");
        // collection.remove("西瓜");
        // System.out.println("删除之后剩余的元素个数："+ collection.size());  // 删除之后剩余的元素个数：1
       // 2.1 清空元素
//        collection.clear();
//        System.out.println("清空元素剩余：" + collection.size());  // 清空元素剩余：0

        // 3. 遍历元素
        // 3.1 使用增强for
        System.out.println("----------3.1 使用增强for-------------");
        for (Object obj:collection
             ) {
            System.out.println(obj);
        }
        /*
        ----------3.1 使用增强for-------------
        苹果
        西瓜
        榴莲
         */
        // 3.2 使用迭代器（迭代器是专门用来遍历集合的一种方式）
        // hasNext(); 有没有下一个元素
        // next(); 获取下一个元素
        // remove(); 删除当前元素
        System.out.println("----------3.2 使用迭代器-------------");
        Iterator it = collection.iterator();
        while(it.hasNext()){
            String s = (String)it.next();
            System.out.println(s);
            // 不能使用collection删除方法
            // collection.remove(s);  // ConcurrentModificationException   并发修改异常
            // it.remove();     // 迭代器提供的方法
        }
        System.out.println("剩余的元素个数: "+ collection.size());
        /*
        ----------3.2 使用迭代器-------------
        苹果
        西瓜
        榴莲
        剩余的元素个数: 3
         */
        // 4. 判断
        System.out.println(collection.contains("xigua"));  // false
        System.out.println(collection.contains("西瓜"));  // true
        System.out.println(collection.isEmpty());  // false     判断是否为空// null空 为 true ; not null非空 为 false

    }


}

下面是保存学生信息的代码实现：

学生类 Student：

package com.collection.Demo01;

/**
 * 学生类
 */
public class Student {
    private String name ;
    private int age ;

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

    public Student() {

    }

    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 "学生信息：[name=" + name + ",age="+age + "]";
    }

    @Override	// 重写方法
    public boolean equals(Object obj) {
        // 1 判断是不是同一个对象
        if (this==obj){
            return true;
        }
        // 2 判断是否为空
        if (obj==null){
            return false;
        }
        // 3 判断是否是Student类型
        if(obj instanceof Student){
            Student s = (Student) obj;
            // 4 比较属性
            if (this.name.equals(s.getName())&&this.age==s.getAge()){
                return true;
            }
        }
        // 5 不满足条件返回false
        return false;
    }
}

代码验证：

package com.collection.Demo01;

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

public class Demo02 {
    public static void main(String[] args) {
        // 新建 Collection 对象
        Collection collection = new ArrayList();
        Student s1 = new Student("张三",18);
        Student s2 = new Student("李四",17);
        Student s3 = new Student("王五",19);
        // 1. 添加数据
        collection.add(s1);
        collection.add(s2);
        collection.add(s3);
        System.out.println("元素个数：" + collection.size());  // 元素个数：3
        System.out.println(collection);  // [学生信息：[name=张三,age=18], 学生信息：[name=李四,age=17], 学生信息：[name=王五,age=19]]
        // 2. 删除数据
        // collection.remove(s2);
        // collection.remove(new Student("王五",19));  // 并没有删除
        // collection.clear();
        // System.out.println("删除之后的剩余元素：" + collection.size());  // 删除之后的剩余元素：0    // 只是删掉了地址


        // 3. 遍历

        // 3.1 增强for
        System.out.println("--------增强for------");
        for (Object obj:collection) {
                Student s = (Student) obj;
            System.out.println(s.toString());
        }
        /*
        --------增强for------
        学生信息：[name=张三,age=18]
        学生信息：[name=李四,age=17]
        学生信息：[name=王五,age=19]
         */

        // 3.2 迭代器
        // hasNext();   next();   remove();     迭代过程中不能使用collection的删除方法
        System.out.println("--------迭代器------");
        Iterator it = collection.iterator();
        while (it.hasNext()){
            Student s = (Student)it.next();
            System.out.println(s);
        }
        /*
        --------迭代器------
        学生信息：[name=张三,age=18]
        学生信息：[name=李四,age=17]
        学生信息：[name=王五,age=19]
         */

        // 4. 判断
        System.out.println(collection.contains(s1));  // true
        System.out.println(collection.isEmpty());  // false

    }
}

List子接口

特点：有序，有下标，元素可以重复

方法：

void add (int index,Object o) // 在index位置插入对象
boolean addAll (int index,Collection c) 将一个集合中的元素添加到此集合中的index 位置
Object get (int index) // 返回集合中指定位置的元素
List subList (int fromIndex,int toIndex) // 返回fromIndex和toIndex之间的集合元素

下面是字符串案例：

package com.collection.list;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

public class Demo01 {
    public static void main(String[] args) {
        // 先创建集合对象
        List list = new ArrayList();
        // 1. 添加元素

        list.add("小米");
        list.add("华为");
        list.add(0,"苹果");
        System.out.println("元素个数：" + list.size());  // 元素个数：3
        System.out.println(list.toString());  // [苹果, 小米, 华为]
        // 2. 删除元素
        // list.remove("华为");
        // list.remove(1);
        // System.out.println("删除之后还剩余：" + list.size());  // 删除之后还剩余：1
        // System.out.println(list);  // [苹果]
        // 3. 遍历
        // 3.1 使用for遍历
        System.out.println("--------使用for遍历--------");
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        /*
        --------使用for遍历--------
        苹果
        小米
        华为
         */
        // 3.2 使用增强for
        System.out.println("--------使用增强for--------");
        for (Object obj:list
             ) {
            System.out.println(obj);
        }
        /*
        --------使用增强for--------
        苹果
        小米
        华为
         */
        // 3.3 使用迭代器
        Iterator it = list.iterator();
        System.out.println("--------使用迭代器--------");
        while (it.hasNext()){
            System.out.println(it.next());
        }
        /*
        --------使用迭代器--------
        苹果
        小米
        华为
         */
        // 3.4 使用列表迭代器，和Iterator的区别: ListIterator可以向前或者向后遍历，添加，删除，修改元素
        ListIterator lit = list.listIterator();
        System.out.println("--------使用列表迭代器==从前往后--------");
        while(lit.hasNext()){
            System.out.println(lit.nextIndex()+":" +lit.next());
        }
        /*
        --------使用列表迭代器==从前往后--------
        0:苹果
        1:小米
        2:华为
         */
        System.out.println("--------使用列表迭代器==从后往前--------");
        while (lit.hasPrevious()){
            System.out.println(lit.previousIndex()+": "+lit.previous());
        }
        /*
        2: 华为
        1: 小米
        0: 苹果
         */
        // 4. 判断
        System.out.println(list.contains("苹果"));  // true
        System.out.println(list.isEmpty());  // false
        // 5.获取位置
        System.out.println(list.indexOf("苹果"));  // 0
        System.out.println(list.indexOf("华为"));  // 2
    }
}

下面是数字，基本类型（自动装箱）:

package com.collection.list;

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

public class Demo02 {
    public static void main(String[] args) {
        // 创建集合
        List list = new ArrayList();
        // 1. 添加数字数据（自动装箱）
        list.add(10);
        list.add(20);
        list.add(30);
        list.add(40);
        list.add(50);
        System.out.println("元素个数："+list.size());  // 元素个数：5
        System.out.println(list);  // [10, 20, 30, 40, 50]
        // 2. 删除操作
        // list.remove(2);
        // list.remove(new Integer(20));
        // list.remove((Object) 40);
        // System.out.println("删除元素：" + list.size());  // 删除元素：2
        // System.out.println(list);  // [10, 50]
        // 3. 补充方法：subList  返回子集合，左闭右开区间  [ )
        List subList = list.subList(1,4);
        System.out.println(subList);  // [20, 30, 40]


    }
}

下面是学生信息：

学生类同上：

package com.collection.list;

import com.collection.Demo01.Student;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.ListIterator;

public class Demo03 {
    public static void main(String[] args) {
        // 创建集合
        ArrayList arrayList = new ArrayList();
        // 1. 添加元素
        Student s1 = new Student("源氏",18);
        Student s2 = new Student("艾什",18);
        Student s3 = new Student("狂鼠",19);
        arrayList.add(s1);
        arrayList.add(s2);
        arrayList.add(s3);
        System.out.println("元素个数："+arrayList.size());  // 元素个数：3
        System.out.println(arrayList);  // [学生信息：[name=源氏,age=18], 学生信息：[name=艾什,age=18], 学生信息：[name=狂鼠,age=19]]
        // 2. 删除元素
        // arrayList.remove(new Student("狂鼠",19));  // equals(this==obj)
        // arrayList.remove(s2);
        // System.out.println("删除之后：" + arrayList.size());  // 删除之后：1
        // System.out.println(arrayList);  // [学生信息：[name=源氏,age=18]]
        // 3. 遍历元素  ⭐
        // 使用迭代器
        System.out.println("----------使用迭代器----------");
        Iterator it = arrayList.iterator();
        while (it.hasNext()){
            Student s = (Student) it.next();
            System.out.println(s.toString());
        }
        /*
        ----------使用迭代器----------
        学生信息：[name=源氏,age=18]
        学生信息：[name=艾什,age=18]
        学生信息：[name=狂鼠,age=19]
         */
        // 使用列表迭代器
        ListIterator lit = arrayList.listIterator();
        System.out.println("----------使用列表迭代器==顺序----------");
        while (lit.hasNext()){
            Student s = (Student) lit.next();
            System.out.println(s.toString());
        }
        /*
        ----------使用列表迭代器==顺序----------
        学生信息：[name=源氏,age=18]
        学生信息：[name=艾什,age=18]
        学生信息：[name=狂鼠,age=19]
         */
        System.out.println("----------使用列表迭代器==逆序----------");
        while (lit.hasPrevious()){
            Student s = (Student) lit.previous();
            System.out.println(s.toString());
        }
        /*
        ----------使用列表迭代器==逆序----------
        学生信息：[name=狂鼠,age=19]
        学生信息：[name=艾什,age=18]
        学生信息：[name=源氏,age=18]
         */
        // 4. 判断
        System.out.println(arrayList.contains(new Student("狂鼠",19)));  // true
        System.out.println(arrayList.contains(s2));  // true
        System.out.println(arrayList.isEmpty());  // false
        // 5. 查找
        System.out.println(arrayList.indexOf(new Student("狂鼠",19)));  // 2
        System.out.println(arrayList.indexOf(new Student("源氏",19)));  // -1  // 年龄应为18 ，没有查找到返回-1



    }
}

List 实现类

ArrayList [重点]:

数组结构实现，查询快，增删慢

JDK1.2版本，运行效率快，线程不安全
Vector：

数组结构实现，查询快，增删慢

JDK1.0版本，运行效率慢，线程安全
LinkedList:

链表结构实现，增删快，查询慢

ArrayList

源码分析：

DEFAULT_CAPACITY = 10 ; 默认容量

注意：如果没有向集合中添加任何元素时，容量为0；

添加一个元素之后，容量为10；

每次扩容的大小是原来的1.5倍

elementDate 存放元素的数组

size 实际元素个数

add () 添加元素

Vector

Vector简介

Vector 是矢量队列，它是JDK1.0版本添加的类。继承于AbstractList，实现了List, RandomAccess, Cloneable这些接口。
Vector 继承了AbstractList，实现了List；所以，它是一个队列，支持相关的添加、删除、修改、遍历等功能。
Vector 实现了RandmoAccess接口，即提供了随机访问功能。RandmoAccess是java中用来被List实现，为List提供快速访问功能的。在Vector中，我们即可以通过元素的序号快速获取元素对象；这就是快速随机访问。
Vector 实现了Cloneable接口，即实现clone()函数。它能被克隆。

和ArrayList不同，Vector中的操作是线程安全的。

(01) Vector实际上是通过一个数组去保存数据的。当我们构造Vecotr时；若使用默认构造函数，则Vector的默认容量大小是10。
(02) 当Vector容量不足以容纳全部元素时，Vector的容量会增加。若容量增加系数 >0，则将容量的值增加“容量增加系数”；否则，将容量大小增加一倍。
(03) Vector的克隆函数，即是将全部元素克隆到一个数组中。

package com.collection.vector;

import java.util.Enumeration;
import java.util.Vector;

public class Demo01 {

    public static void main(String[] args) {
        // 创建集合
        Vector vector = new Vector();
        // 1. 添加元素
        vector.add("苹果");
        vector.add("草莓");
        vector.add("葡萄");
        System.out.println("元素个数："+vector.size());  // 元素个数：3
        System.out.println(vector);  // [苹果, 草莓, 葡萄]
        // 2. 删除元素
        // vector.remove(0);
        // vector.remove("葡萄");
        // vector.clear();
        // System.out.println("元素个数：" + vector.size());  // 元素个数：0
        // 3. 遍历
        // 使用枚举器
        Enumeration en = vector.elements();
        while (en.hasMoreElements()){
            String str = (String)en.nextElement();
            System.out.println(str);
        }
        /*
        苹果
        草莓
        葡萄
         */
        // 4. 判断
        System.out.println(vector.contains("葡萄"));  // true
        System.out.println(vector.isEmpty());  // false
        // 5. 其他方法
        System.out.println(vector.firstElement());  // 苹果
        System.out.println(vector.lastElement());  // 葡萄
        System.out.println(vector.elementAt(1));  // 草莓
    }
}

LinkedList

LinkedList官方文档
LinkedList的底层是双向链表结构，由于链表没有将元素存储在连续的空间中，而是存储在单独的节点中，然后通过引用将节点连接起来了，因此在任意位置插入或者删除元素时，不需要搬移元素，效率比较高。

注意：

LinkedList实现了List接口
LinkedList的底层使用了双向链表
LinkedList没有实现RandomAccess接口，因此LinkedList不支持随机访问
LinkedList的任意位置插入和删除元素时效率比较高，时间复杂度为O(1)
LinkedList比较适合任意位置插入的场景

package com.collection.vector;

import java.util.Enumeration;
import java.util.Vector;

public class Demo01 {

    public static void main(String[] args) {
        // 创建集合
        Vector vector = new Vector();
        // 1. 添加元素
        vector.add("苹果");
        vector.add("草莓");
        vector.add("葡萄");
        System.out.println("元素个数："+vector.size());  // 元素个数：3
        System.out.println(vector);  // [苹果, 草莓, 葡萄]
        // 2. 删除元素
        // vector.remove(0);
        // vector.remove("葡萄");
        // vector.clear();
        // System.out.println("元素个数：" + vector.size());  // 元素个数：0
        // 3. 遍历
        // 使用枚举器
        Enumeration en = vector.elements();
        while (en.hasMoreElements()){
            String str = (String)en.nextElement();
            System.out.println(str);
        }
        /*
        苹果
        草莓
        葡萄
         */
        // 4. 判断
        System.out.println(vector.contains("葡萄"));  // true
        System.out.println(vector.isEmpty());  // false
        // 5. 其他方法
        System.out.println(vector.firstElement());  // 苹果
        System.out.println(vector.lastElement());  // 葡萄
        System.out.println(vector.elementAt(1));  // 草莓
    }
}

ArrayList和LinkedList的区别
ArrayList的物理存储空间是连续的，LinkedList物理上不一定连续。
ArrayList支持随机访问，LinkedList不支持随机访问。
ArrayList在插入和删除的时候时间复杂度O(N)，LinkedList时间复杂度O(1)；所以LinkedList适合频繁插入和删除的场景。
ArrayList空间不够需要动态扩容，LinkedList不需要。

泛型

Java泛型是JDK1.5中引入的一个新特性，其本质是参数化类型，把类型作为参数传递

常见形式有：泛型类、泛型接口、泛型方法

语法： T 称为类型占位符，表示一种引用类型

好处：1 提高代码的重（chong）用性

2 防止类型转换异常，提高代码的安全性

下面是泛型类：

package com.collection.generic;

public class Generic<T> {
    // 泛型类：Generic<T>
    // 语法： 类名<T>
    // T是类型占位符，表示一种引用类型，如果编写多个使用逗号隔开

    // 使用泛型 T
    // 1. 创建变量
    // 泛型不能实例化
    T t ;

    // 2. 泛型作为方法的参数
    public void show(T t){
        System.out.println("泛型作为方法的参数：" + t);
    }

    // 3. 泛型作为方法的返回值
    public T getT(){
        // return (T)("泛型作为方法的返回值" + t);
         return t;
    }
}

下面是泛型方法：

package com.collection.generic;


/**
 *
 * 泛型方法
 * 语法：<T>返回值类型
 *
 */
public class GenericMethod {
    // 泛型方法
    public <T> T show(T t){
        System.out.println("泛型方法 "+ t);
        return t;
    }
}

下面是泛型接口：

接口
package com.collection.generic;

/**
 * 泛型接口
 * 语法：接口名<T>
 * 注意：不能创建静态常量
 * @param <T>
 */
public interface GenericService<T> {
    String name = "张三";

    T server(T t);
}

package com.collection.generic;

public class GenericServiceImpl implements GenericService<String>{

    @Override
    public String server(String t) {
        System.out.println(t);
        return t;
    }
}

package com.collection.generic;

public class GenericServiceImpl2<T> implements GenericService<T>{

    @Override
    public T server(T t) {
        System.out.println(t);
        return t;
    }
}

泛型测试：

package com.collection.generic;

public class TestGeneric {
    public static void main(String[] args) {
        // 使用泛型类创建对象
        /*
        注意：
        1. 泛型只能使用引用类型
        2. 不同泛型类型对象之间不能相互赋值
         */
        Generic<String> generic = new Generic<String>();
        generic.t = "Java";
        generic.show("我爱学习Java，大家加油！");  // 泛型作为方法的参数：我爱学习Java，大家加油！
        String string = generic.getT();
        System.out.println(string);  // Java

        Generic<Integer> generic1 = new Generic<>();
        generic1.t = 18;
        generic1.show(180);  // 泛型作为方法的参数：180
        Integer integer = generic1.getT();
        System.out.println(integer);  // 18

        // 泛型接口
        GenericService gs = new GenericServiceImpl();
        gs.server("java");  // java

        GenericService gs2 = new GenericServiceImpl2();
        gs2.server(10086);  // 10086

        // 泛型方法
        GenericMethod gm = new GenericMethod();
        gm.show("java is best!");  // 泛型方法 java is best!
        gm.show(10086);  // 泛型方法 10086
        gm.show(3.1415926);  // 泛型方法 3.1415926

    }
}

泛型集合

概念：参数化类型、类型安全的集合、强制集合元素的类型必须一致

特点：

编译时即可检查，而非运营时抛出异常
访问时，不必类型转换（拆箱）
不同泛型之间引用不能相互赋值，泛型不存在多态

Set子接口

Set 接口是Collection的子接口，相当于数学上的集合
特点：
- 不允许元素重复，添加相同的元素，返回false
- 无序，无下标。不会记录元素的先后添加顺序
- 判断俩个元素是否相等用的是equals方法
方法：全部继承自Collection中的方法

Set实现类

HashSet 是Set 最长用的接口，底层使用Hash（散列）算法，查询和插入速度较快
HashSet 判断俩个对象是否相等，equals比较
对象的HashCode值决定了在Hash表中的位置
1. 判断添加对象和集合元素对象HashCode值
  1. 不等：直接将新添加对象存储导对应位置
  2. 相等：再继续判断新对象和集合中对象的具体值：
    1. HashCode 相同，equals true ，则是同一个对象，则不保存hashtable中
    2. HashCode 相同，equals false，存储到同槽的链表上

基于HashCode计算元素存放位置
当存入元素的哈希码相同时，会调用equals进行确认，如果为true 则拒绝后者存入

测试Set接口的使用：

package com.collection.set;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

/**
 *
 * 测试Set接口的使用
 * 特点：无序、无下标 且 不能重复
 *
 */
public class Demo01 {
    public static void main(String[] args) {
        // 创建集合
        Set<String> set = new HashSet<>();
        // 1. 添加数据
        set.add("苹果");
        set.add("小米");
        set.add("华为");
        // set.add("华为");  // 不能重复的
        System.out.println("元素个数: "+ set.size());  // 元素个数: 3
        System.out.println(set.toString());  // [苹果, 华为, 小米]  // 是无序的

        // 2. 删除数据
        // set.remove("华为");
        // System.out.println(set);  // [苹果, 小米]

        // 3. 遍历  ⭐
        // 3.1 使用增强for
        System.out.println("--------使用增强for---------");
        for (Object obj:set
             ) {
            System.out.println(obj);
        }
        /*
        --------使用增强for---------
        苹果
        华为
        小米
         */
        // 3.2 使用迭代器
        System.out.println("--------使用迭代器---------");
        Iterator<String> it = set.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
        /*
        --------使用迭代器---------
        苹果
        华为
        小米
         */
        // 4. 判断
        System.out.println(set.contains("苹果"));  // true
        System.out.println(set.isEmpty());  // false


    }
}

HashSet集合的使用 1 ：

package com.collection.set;

import java.util.HashSet;
import java.util.Iterator;

/**
 *
 * HashSet集合的使用
 * 存储结构：哈希表（数组＋链表＋红黑树）
 */
public class Demo02 {
    public static void main(String[] args) {
        // 新建集合
        HashSet<String> hashSet = new HashSet<>();
        // 1. 添加元素
        hashSet.add("源氏");
        hashSet.add("闪光");
        hashSet.add("狂鼠");
        hashSet.add("艾什");
        hashSet.add("小美");
        // hashSet.add("小美");  // 重复的不添加
        System.out.println("元素个数："+hashSet.size());  // 元素个数：5
        System.out.println(hashSet.toString());  // [狂鼠, 源氏, 艾什, 小美, 闪光]
        // 2. 删除
        // hashSet.remove("源氏");
        // System.out.println(hashSet.toString());  // [狂鼠, 艾什, 小美, 闪光]
        // hashSet.clear();
        // System.out.println(hashSet);  // []
        // 3. 遍历
        // 3.1 使用增强for
        System.out.println("------使用增强for--------");
        for (String s:hashSet
             ) {
            System.out.println(s);
        }
        /*
        ------使用增强for--------
        狂鼠
        源氏
        艾什
        小美
        闪光
         */
        // 3.2 使用迭代器
        System.out.println("------使用迭代器--------");
        Iterator it = hashSet.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
        /*
        ------使用迭代器--------
        狂鼠
        源氏
        艾什
        小美
        闪光
         */
        // 4. 判断
        System.out.println(hashSet.contains("死神"));  // false
        System.out.println(hashSet.contains("源氏"));  // true
        System.out.println(hashSet.isEmpty());   // false

    }
}

HashSet集合的使用 2 :

package com.collection.set;

import java.util.HashSet;
import java.util.Iterator;

/**
 * HashSet集合的使用
 * 存储结构：哈希表（数组＋链表＋红黑树）
 * 存储过程：
 *      1. 根据hashcode计算保存的位置，如果此位置为空，则直接保存，如果不为空则执行第二步
 *      2. 再执行equals方法，如果equals方法为true，则认为是重复，否则，形成链表
 */

public class Demo03 {
    public static void main(String[] args) {
        // 创建集合
        HashSet<Person> people = new HashSet<>();
        // 1. 添加数据
        Person p1 = new Person("源氏",18);
        Person p2 = new Person("艾什",19);
        Person p3 = new Person("闪光",20);
        Person p4 = new Person("狂鼠",21);

        people.add(p1);
        people.add(p2);
        people.add(p3);
        people.add(p4);
        // people.add(p4);  // 重复 不添加
        people.add(new Person("狂鼠",21));  // 重写了hashcode方法与equals方法
        System.out.println("元素个数："+ people.size());  // 元素个数：4
        System.out.println(people.toString());  // [Person{name='闪光', age=20}, Person{name='艾什', age=19}, Person{name='源氏', age=18}, Person{name='狂鼠', age=21}]

        // 2. 删除
        // people.remove(p1);
        // people.remove(new Person("狂鼠",21));  // 因为重写hashcode方法与equals方法，所以也可以
        // System.out.println("删除后："+people.size());  // 删除后：2
        // System.out.println(people);  // [Person{name='闪光', age=20}, Person{name='艾什', age=19}]

        // 3. 遍历  ⭐
        // 3.1 使用增强for
        System.out.println("------使用增强for--------");
        for (Person person:people
             ) {
            System.out.println(person.toString());
        }
        /*
        ------使用增强for--------
        Person{name='闪光', age=20}
        Person{name='艾什', age=19}
        Person{name='源氏', age=18}
        Person{name='狂鼠', age=21}
         */
        // 3.2 使用迭代器
        System.out.println("------使用迭代器--------");
        Iterator<Person> it = people.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
        /*
        ------使用迭代器--------
        Person{name='闪光', age=20}
        Person{name='艾什', age=19}
        Person{name='源氏', age=18}
        Person{name='狂鼠', age=21}
         */
        // 4. 判断
        System.out.println(people.contains(new Person("狂鼠",21)));  // true
        System.out.println(people.contains(p2));  // true
        System.out.println(people.isEmpty());  // false

    }
}

Person类

package com.collection.set;

import java.util.Objects;

public class Person {
    private String name ;
    private int age;

    public Person() {

    }

    public Person(String name, int age) {
        super();
        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 "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    // 快捷键 快速 重写equals 和 hashCode 方法
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age && Objects.equals(name, person.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
    
    
//    @Override
//    public boolean equals(Object o) {
//        if (this == o)
//        {
//            return true;
//        }
//        if (o == null ){
//            return false;
//        }
//        if (o instanceof Person){
//            Person p = (Person) o;
//            if (this.name.equals(p.getName())&&this.age==p.getAge()){
//                return true;
//            }
//        }
//        return false;
//    }
//
//    @Override
//    public int hashCode() {
//        int n1 = this.name.hashCode();
//        int n2 = this.age;
//        return n1+n2;
//    }

}

TreeSet

基于排序顺序实现元素不重复
实现了SortedSet接口，对集合元素自动排序
元素对象的类型必须实现Comparable接口，指定排序规则
通过CompareTo方法确定是否为重复元素

下面是TreeSet的使用

package com.collection.treeset;

import java.util.Iterator;
import java.util.TreeSet;
/**
 * TreeSet 的使用
 * 存储结构：红黑树
 */
public class Demo01 {
    public static void main(String[] args) {
        // 创建集合
        TreeSet<String> treeSet = new TreeSet<>();
        // 1. 添加元素
        treeSet.add("xyz");
        treeSet.add("abc");
        treeSet.add("java");
        treeSet.add("c++");
        treeSet.add("java");  // 元素重复不添加
        System.out.println("元素个数："+treeSet.size());  // 元素个数：4
        System.out.println(treeSet.toString());  // [abc, c++, java, xyz]
        // 2. 删除元素
//        treeSet.remove("java");
//        treeSet.remove("c++");
//        System.out.println("删除元素："+ treeSet.size());  // 删除元素：2
//        System.out.println(treeSet.toString());  // [abc, xyz]
        // 3. 遍历
        // 3.1 使用增强for
        System.out.println("---------使用增强for--------");
        for (String s: treeSet) {
            System.out.println(s);
        }
        /*
        ---------使用增强for--------
        abc
        c++
        java
        xyz
         */
        // 3.2 使用迭代器
        System.out.println("---------使用迭代器--------");
        Iterator<String> it = treeSet.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
        /*
        ---------使用迭代器--------
        abc
        c++
        java
        xyz
         */
        // 4. 判断
        System.out.println(treeSet.contains("java"));  // true
        System.out.println(treeSet.contains("php"));  // false
        System.out.println(treeSet.isEmpty());  // false
    }
}

使用TreeSet保存数据

package com.collection.treeset;

import com.collection.set.Person;
import java.util.Iterator;
import java.util.TreeSet;
/**
 * 使用TreeSet保存数据
 * 要求：
 *  元素必须要实现Comparable接口，compareTo();方法返回值为0，认为是重复元素
 */
public class Demo02 {

    public static void main(String[] args) {
        // 创建集合
        TreeSet<Person> persons = new TreeSet<>();
        // 1. 添加元素
        Person p1 = new Person("java",18);
        Person p2 = new Person("php",19);
        Person p3 = new Person("c++",20);
        Person p4 = new Person("xyz",21);
        Person p5 = new Person("java",1970);
        persons.add(p1);
        persons.add(p2);
        persons.add(p3);
        persons.add(p4);
        persons.add(p5);
        System.out.println("元素个数：" + persons.size());  // 元素个数：5
        System.out.println(persons);  // [Person{name='c++', age=20}, Person{name='java', age=18}, Person{name='java', age=1970}, Person{name='php', age=19}, Person{name='xyz', age=21}]
        // 2. 删除
//        persons.remove(p2);
//        persons.remove(new Person("xyz",21));
//        System.out.println("删除元素："+persons.size());   // 删除元素：3
//        System.out.println(persons.toString());  //  [Person{name='c++', age=20}, Person{name='java', age=18}, Person{name='java', age=1970}]

        // 3. 遍历
        // 3.1 使用增强for
        System.out.println("---------使用增强for--------");
        for (Person p: persons
             ) {
            System.out.println(p);
        }
        /*
        ---------使用增强for--------
        Person{name='c++', age=20}
        Person{name='java', age=18}
        Person{name='java', age=1970}
        Person{name='php', age=19}
        Person{name='xyz', age=21}
         */
        // 3.2 使用迭代器
        System.out.println("---------使用迭代器--------");
        Iterator<Person> it = persons.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
        /*
        ---------使用迭代器--------
        Person{name='c++', age=20}
        Person{name='java', age=18}
        Person{name='java', age=1970}
        Person{name='php', age=19}
        Person{name='xyz', age=21}
         */
        // 4. 判断
        System.out.println(persons.contains(p1));  // true
        System.out.println(persons.contains(new Person("javase",1970)));  // false
        System.out.println(persons.isEmpty());  // false

    }
}




引用了Person类，重写 compareTo(); 方法
// 先按姓名比，然后再按年龄比
    @Override
    public int compareTo(Person o) {
        int n1 = this.getName().compareTo(o.getName());
        int n2 = this.age-o.getAge();
        return  n1==0?n2:n1;
    }

TreeSet集合的使用

package com.collection.treeset;

import com.collection.set.Person;
import java.util.Comparator;
import java.util.TreeSet;
/**
 * TreeSet 集合的使用
 * Comparator ： 实现比较定制 （他是一个比较器）
 * Comparable ： 可比较的
 */
public class Demo03 {
    // 创建集合
    public static void main(String[] args) {
        TreeSet<Person> persons = new TreeSet<>(new Comparator<Person>() {  // new Comparator<Person>() 匿名内部类
            @Override
            public int compare(Person o1, Person o2) {
                int n1 = o1.getAge() - o2.getAge();
                int n2 = o1.getName().compareTo(o2.getName());
                return n1 == 0 ? n2 : n1 ;
            }
        });

        Person p1 = new Person("java",24);
        Person p2 = new Person("php",26);
        Person p3 = new Person("c++",20);
        Person p4 = new Person("xyz",17);
        Person p5 = new Person("abc",17);
        persons.add(p1);
        persons.add(p2);
        persons.add(p3);
        persons.add(p4);
        persons.add(p5);
        System.out.println(persons);

    }
}


结果：
        [Person{name='xyz', age=17}, Person{name='c++', age=20}, Person{name='java', age=24}, Person{name='php', age=26}]
        先比较的age，再比较name
        添加p5之后 ，age相同，比较name
        [Person{name='abc', age=17}, Person{name='xyz', age=17}, Person{name='c++', age=20}, Person{name='java', age=24}, Person{name='php', age=26}]

案例：

要求：使用TreeSet集合实现字符串按照长度进行排序

helloworld zhangsan lisi xian beijing nanjing haerbin

Comparator 接口实现定制比较

代码实现：

package com.collection.treeset;


import java.util.Comparator;
import java.util.TreeSet;
/**
 * 案例：
 * 要求：使用TreeSet集合实现字符串按照长度进行排序
 * helloworld   zhangsan    lisi    xian    beijing   nanjing   haerbin
 * Comparator 接口实现定制比较
 */
public class Demo04 {
    public static void main(String[] args) {
        // 创建集合 并指定比较规则
        TreeSet<String> treeSet = new TreeSet<>(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                int n1 = o1.length() - o2.length();
                int n2 = o1.compareTo(o2);
                return n1 == 0 ? n2 : n1;
            }
        });

        // 添加数据
        treeSet.add("helloworld");
        treeSet.add("zhangsan");
        treeSet.add("lisi");
        treeSet.add("xian");
        treeSet.add("beijing");
        treeSet.add("nanjing");
        treeSet.add("haerbin");
        System.out.println(treeSet.toString());

    }
}

结果：
        先比较长度，长度相同，则比较name
        [lisi, xian, beijing, haerbin, nanjing, zhangsan, helloworld]

Map集合

Map体系集合

在这里插入图片描述

Map接口的特点：
1.用于存储任意键值对（Key–Value）
2.键：无序、无下标、不允许重复（唯一）
3.值：无序、无下标、允许重复

Map 父接口

特点：

存储一对数据（Key–Value），无序、无下标，键不可重复，值可重复

方法：

V put (K key , V value) // 将对象存入到集合中，关联键值。key重复则覆盖原值
Object get (Object key) // 根据键获取对应的值
Set // 返回所有key
Collection values ( ) // 返回包含所有值的Collection集合
Set <Map.Entry<K,V>> // 键值匹配的Set集合

代码演示：

package com.collection.map;


import java.util.HashMap;
import java.util.Map;
import java.util.Set;

/**
 * Map 接口的使用
 * 特点：
 * 1. 存储 键值对 （一对一对的数据）
 * 2. 键 不能重复，值 可以重复
 * 3. 无序 没有下标
 */
public class Demo01 {
    public static void main(String[] args) {
        // 创建 Map 集合
        Map<String,String> map = new HashMap<>();
        // 1. 添加元素
        map.put("cn" , "中国");
        map.put("uk" , "英国");
        map.put("usa" , "美国");
        map.put("cn" , "zhongguo");  // k 相同，覆盖掉 v
        System.out.println("元素个数：" + map.size());  // 元素个数：3
        System.out.println(map.toString());  // {usa=美国, uk=英国, cn=zhongguo}

        // 2. 删除
        // map.remove("usa","美国");
        // map.remove("usa");
        // System.out.println("删除："+map.size());  // 删除：2
        // System.out.println(map);  // {uk=英国, cn=zhongguo}

        // 3. 遍历
        // 3.1 使用 keySet();
        System.out.println("-----------keySet()---------");
        Set<String> keySet = map.keySet();
        for (String key:map.keySet()
             ) {
            System.out.println(key+"-----"+map.get(key));
        }
        /*
        -----------keySet()---------
        usa-----美国
        uk-----英国
        cn-----zhongguo
         */
        // 3.2 使用 entrySet();
        System.out.println("-----------entrySet()---------");
        Set<Map.Entry<String, String>> entries = map.entrySet();
        for (Map.Entry<String,String> entry:
             map.entrySet()) {
            System.out.println(entry.getKey()+"-----"+entry.getValue());
        }
        /*
        -----------entrySet()---------
        usa-----美国
        uk-----英国
        cn-----zhongguo
         */

        // 4. 判断
        System.out.println(map.containsKey("cn"));  // true
        System.out.println(map.containsValue("意大利"));  // false
    }
}

HashMap集合

在Java中，HashMap 是一个常用的数据结构，它实现了Map接口，允许我们通过键值对的形式存储和快速查找数据。HashMap的底层是基于哈希表（hash table）的实现，它的高效性和灵活性使其在各种编程场景中广受欢迎。

HashMap是Map接口的一个实现类（HashMap实现了Map的接口），它具有Map的特点。HashMap的底层是哈希表结构。

在 JDK 1.2版本中，线程不安全，运行效率快；允许用null 作为 key 或 value

下面是代码展示：

package com.collection.map;


import java.util.HashMap;
import java.util.Map;
import java.util.Set;

/**
 * HashMap集合的使用
 * 存储结构：哈希表（数组+链表+红黑树）
 * 使用key 可以hashcode和equals作为重复
 */
public class Demo02 {
    public static void main(String[] args) {
        // 创建集合
        HashMap<Student, String> students= new HashMap<Student,String>();
        // 刚创建 hashMap之后没有添加元素  table = null   size = 0 目的：节省空间
        // 1. 添加元素
        Student s1 = new Student("小李", 00001);
        Student s2 = new Student("小王", 00002);
        Student s3 = new Student("小赵", 00003);
        Student s4 = new Student("小孙", 00004);
        students.put(s1,"北京");
        students.put(s2,"天津");
        students.put(s3,"南京");
        students.put(s4,"上海");
        // students.put(s4,"杭州");  // 不会新添加，会覆盖
        System.out.println("元素个数："+students.size());  // 元素个数：4
        System.out.println(students);  // {Student{name='小赵', stId=3}=南京, Student{name='小王', stId=2}=天津, Student{name='小李', stId=1}=北京, Student{name='小孙', stId=4}=杭州}
        // 2. 删除
//        students.remove(s1);
//        students.remove(new Student("小孙", 00004));
//        System.out.println("删除之后："+students.size());  // 删除之后：3
//        System.out.println(students);  // {Student{name='小赵', stId=3}=南京, Student{name='小王', stId=2}=天津, Student{name='小孙', stId=4}=上海}
        // 3. 遍历
        // 3.1 使用 keySet();
        System.out.println("-----------使用 keySet()---------------");
        Set<Student> keySet = students.keySet();
        for (Student s:
             keySet) {
            System.out.println(s+"----"+students.get(s));
        }
        /*
        -----------使用 keySet()---------------
        Student{name='小赵', stId=3}-----南京
        Student{name='小王', stId=2}-----天津
        Student{name='小李', stId=1}-----北京
        Student{name='小孙', stId=4}-----上海
         */
        // 3.2 使用 entrySet();
        System.out.println("-----------使用entrySet()--------------");
        Set<Map.Entry<Student, String>> entries = students.entrySet();
        for (Map.Entry<Student, String> s :
                entries) {
            System.out.println(s.getKey()+"-----"+s.getValue());
        }
        /*
        -----------使用entrySet()--------------
        Student{name='小赵', stId=3}-----南京
        Student{name='小王', stId=2}-----天津
        Student{name='小李', stId=1}-----北京
        Student{name='小孙', stId=4}-----上海
         */

        // 4. 判断
        System.out.println(students.containsKey(s1));  // true
        System.out.println(students.containsKey(new Student("小赵", 00003)));  // true
        System.out.println(students.containsValue("新疆"));  // false
        System.out.println(students.isEmpty());  // false

    }
}

学生类：

package com.collection.map;

import java.util.Objects;

public class Student implements Comparable<Student>{
    private String name ;
    private int stId;

    public Student() {

    }

    public Student(String name, int stId) {
        this.name = name;
        this.stId = stId;
    }

    public String getName() {
        return name;
    }

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

    public int getStId() {
        return stId;
    }

    public void setStId(int stId) {
        this.stId = stId;
    }

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

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return stId == student.stId && Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, stId);
    }

    @Override
    public int compareTo(Student o) {
        int n = this.stId - o.getStId();
        return n;
    }

}

源码分析：

源码分析:
    1. static final int DEFAULT_INTTIAL_CAPACITY = 1 << 4 ;
    hashMap的初始容量大小
    2. static final int MAXIMUM_CAPACITY = 1 << 30 ;
    hashMap的数组最大容量
    3. static final float DEFAULT_LOAD_FACTOR = 0.75f ;
    默认加载因子
    4. static final int TREEIFY_THRESHOLD = 8 ;
    JDK 1.8 当链表长度大于8时,调整成红黑树
    5. static final int UNTREEIFY_THRESHOLD = 6 ;
    JDK 1.8 当链表长度大于6时,调整成链表
    6. static final int MIN_TREEIFY_CAPACITY = 64 ;
    JDK 1.8 当链表长度大于8时,并且集合元素个数大于等于64时,调整成红黑树
    7. transient Node<K,V>[] table ;
    哈希表中的数组
    8. size ;
    元素个数

总结：

1. HashMap刚创建时,table是null,为了节省空间,当添加第一个元素时,table容量调整为16
2. 当元素个数大于阈值(16*0.75=12)时,会进行扩容,扩容后大小为原来的2倍。目的是减少调整元素的个数
3. jdk 1.8 当每个链表长度大于8,并且数组元素个数大于等于64时,会调整为红黑树,目的是提高执行效率
4. jdk 1.8 当链表长度小于6时,调整成链表
5. jdk 1.8 以前是链表头插入,1.8 以后是尾插入

Hashtable与Properties

Hashtable :

JDK1.0版本，线程安全，运行效率慢，不允许null作为key或是value

Properties：

Hashtable 的子类，要求key和value都是String。通常用于配置文件的读取

TreeMap

实现了SortedMap接口（是Map的子接口），可以对key自动排序

代码演示：

package com.collection.map;


import java.util.Map;
import java.util.TreeMap;

/**
 * TreeMap 的使用
 * 存储结构： 红黑树
 */
public class Demo03 {
    public static void main(String[] args) {
        // 新建集合 （也可以使用定制）
        TreeMap<Student, String> treeMap = new TreeMap<>();
        // 1. 添加元素
        Student s1 = new Student("小李", 00001);
        Student s2 = new Student("小王", 00002);
        Student s3 = new Student("小赵", 00003);
        Student s4 = new Student("小孙", 00004);
        treeMap.put(s1,"北京");
        treeMap.put(s2,"上海");
        treeMap.put(s3,"广州");
        treeMap.put(s4,"深圳");
        // treeMap.put(s3,"香港");  // 无法插入数据，但会把value值替换掉
        System.out.println("元素个数："+treeMap.size());  // 元素个数：4
        System.out.println(treeMap);  // {Student{name='小李', stId=1}=北京, Student{name='小王', stId=2}=上海, Student{name='小赵', stId=3}=香港, Student{name='小孙', stId=4}=深圳}

        // 2. 删除
//        treeMap.remove(s1);
//        treeMap.remove(new Student("小孙", 00004));
//        System.out.println("删除之后："+treeMap.size());  // 删除之后：2
//        System.out.println(treeMap);  // {Student{name='小王', stId=2}=上海, Student{name='小赵', stId=3}=广州}

        // 3. 遍历
        // 3.1 使用 keySet();
        System.out.println("-------使用 keySet()---------");
        for (Student key:
             treeMap.keySet()) {
            System.out.println(key+"-----"+treeMap.get(key));
        }
        /*
        -------使用 keySet()---------
        Student{name='小李', stId=1}-----北京
        Student{name='小王', stId=2}-----上海
        Student{name='小赵', stId=3}-----广州
        Student{name='小孙', stId=4}-----深圳
         */
        // 3.2 使用 entrySet();
        System.out.println("-------使用 entrySet()---------");
        for (Map.Entry<Student, String> entry :
                treeMap.entrySet()) {
            System.out.println(entry.getKey()+"----"+entry.getValue());
        }
        /*
        -------使用 entrySet()---------
        Student{name='小李', stId=1}----北京
        Student{name='小王', stId=2}----上海
        Student{name='小赵', stId=3}----广州
        Student{name='小孙', stId=4}----深圳
         */
        // 4. 判断
        System.out.println(treeMap.containsKey(s2));  // true
        System.out.println(treeMap.containsKey(new Student("小王", 00002)));  // true
        System.out.println(treeMap.containsValue("南京"));  // false
        System.out.println(treeMap.isEmpty());  // false
    }
}

Collections工具类

概念：集合工具类，定义了除了存取以外的集合常用方法

方法：

public static void reverse (List<?> list) // 反转集合中元素的顺序
public static void shuffer (List<?> list) // 随机重置集合元素的顺序
public static void sort (List<?> list) // 升序顺序（元素类型必须实现Comparable接口）

代码演示：

package com.collection.map;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

/**
 * Collections工具类的使用
 */
public class Demo04 {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(58);
        list.add(41);
        list.add(77);
        list.add(26);
        list.add(18);

        // sort 排序
        System.out.println("----------sort---------");
        System.out.println("排序之前："+list);  // 排序之前：[58, 41, 77, 26, 18]
        Collections.sort(list);
        System.out.println("排序之后："+list);  // 排序之后：[18, 26, 41, 58, 77]

        // binarySearch 二分查找
        System.out.println("--------binarySearch----------");
        int i = Collections.binarySearch(list,25);  // -2
        int i1 = Collections.binarySearch(list,58);  // 3
        System.out.println(i);
        System.out.println(i1);

        // copy 复制
        System.out.println("------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);  // [18, 26, 41, 58, 77]

        // reverse 反转
        System.out.println("-------reverse-------------");
        Collections.reverse(list);
        System.out.println("反转之后："+list);  // 反转之后：[77, 58, 41, 26, 18]

        // shuffle 打乱
        System.out.println("--------shuffle--------");
        Collections.shuffle(list);
        System.out.println("打乱之后："+list);  // 打乱之后：[41, 77, 58, 26, 18]

        // 补充：
        // list转数组
        System.out.println("--------list转数组-------");
        Integer[] arr = list.toArray(new Integer[2]);
        Integer[] arr1 = list.toArray(new Integer[10]);
        System.out.println(arr.length);  // 5
        System.out.println(Arrays.toString(arr));  // [77, 41, 58, 26, 18]
        System.out.println(Arrays.toString(arr1));  // [18, 41, 58, 26, 77, null, null, null, null, null]

        // 数组转集合
        System.out.println("---------数组转集合----------");
        String[] names = {"张三","李四","王五","赵六"};
        // 集合是一个受限集合，不能添加和删除
        List<String> list2 = Arrays.asList(names);
        // list2.add("小李");  UnsupportedOperationException
        // list2.remove(2);  UnsupportedOperationException
        System.out.println(list2);  // [张三, 李四, 王五, 赵六]
        // 把基本类型数组转成集合时，需要修改为包装类型
        Integer[] nums = {100,200,300,400,500,600};
        List<Integer> list3 = Arrays.asList(nums);
        System.out.println(list3);  // [100, 200, 300, 400, 500, 600]

    }
}