前言

Collection接口的层次结构图：

一、集合概述

所有的集合类和集合接口都在java.util包下。

• 集合实际上就是一个容器。可以来容纳其它类型的数据，可以一次容纳多个对象。（数组其实就是一个集合。）

• 集合不能直接存储基本数据类型，也不能直接存储java对象，集合当中存储的都是java对象的内存地址。（或者说集合中存储的是引用。）
  

• 在java中每一个不同的集合，底层会对应不同的数据结构。往不同的集合中存储元素，等于将数据放到了不同的数据结构当中。（例如：数组、二叉树、链表、哈希表…以上这些都是常见的数据结构。）

• 在java中集合分为两大类：

一类是单个方式存储元素：
单个方式存储元素，这一类集合中超级父接口：java.util.Collection;
一类是以键值对儿的方式存储元素
以键值对的方式存储元素，这一类集合中超级父接口：java.util.Map;

二、Collection详述

Collection 是 List 和 Set 的父接口

Collection接口中的常用方法：

• boolean add(E e) 向集合中添加元素
• int size();获取集合中的元素个数
• void clear();清空集合
• boolean contains(Object o) 判断当前集合是否含有o元素
• boolean remove(Object o) 删除集合中的元素
• boolean isEmpty() 判断集合是否为空
• Object[] toArray() 把集合转换为数组

示例代码（1）：

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

public class CollectionText {
    public static void main(String[] args) {
        
        Collection collection = new ArrayList();
        //向集合中添加元素
        boolean b1 = collection.add(100);
        boolean b2 = collection.add("你好，java");
        boolean b3 = collection.add("中国");
        System.out.println(b1);
        System.out.println(b2);
        System.out.println(b3);
        //获取集合中的元素个数
        int i1 = collection.size();
        System.out.println(i1);

        //collection.clear();
        //System.out.println(collection.size());

        boolean b = collection.contains(100);
        System.out.println(b);
          //删除集合中的元素
        collection.remove("中国");
        System.out.println(collection.size());
         //判断集合是否为空
        System.out.println(collection.isEmpty());
        collection.clear();
        System.out.println(collection.isEmpty());

        collection.add("我");
        collection.add("是");
        collection.add("中");
        collection.add("国");
        collection.add("人");
        //转换为数组
        Object[] objects=collection.toArray();
        for(int i=0;i<objects.length;i++){
            Object o=objects[i];
            System.out.println(o);
        }
        System.out.println(Arrays.toString(objects));
    }
}

运行结果：

true
true
true
3
true
2
false
true
我
是
中
国
人
[我, 是, 中, 国, 人]

Process finished with exit code 0

注：Collection在使用泛型之前，可存放Object的所有子类，在使用泛型之后，只能存某个具体的类型。

集合的迭代（遍历）

迭代器是一个对象

• 所有Collection以及子类通用，Map集合不能使用。
• 使用迭代器的步骤：

第一步：获取集合对象的迭代器对象
第二部：通过获取的迭代器对象进行迭代（遍历）

• 迭代器（iterator）中的方法：

boolean hasNext(); true:有元素迭代 false：无元素迭代
E next() ；返回迭代的下一个元素

示例代码（2）：

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

public class CollectionText01 {
    public static void main(String[] args) {
        //创建集合
        Collection c1=new ArrayList();
        c1.add(100);
        c1.add("abc");
        c1.add("def");
        c1.add(new Object());
        //第一步：获取集合对象的迭代器对象iterator
        Iterator it=c1.iterator();
        //第二步通过获取的迭代器对象进行集合遍历/迭代。
        while (it.hasNext()){
            Object obj=it.next();
            System.out.println(obj);
        }
    }
}

运行结果：

100
abc
def
java.lang.Object@723279cf

• 迭代器重要规律：

1.集合结果发生改变，迭代器需要重新获取
2.迭代过程中不能调用remove()方法删除元素，会出现异常（ConcurrentModificationException）
3.迭代元素的过程中使用迭代器的remove()方法删除元素

示例代码（3）：

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

public class CollectionText05 {
    public static void main(String[] args) {
        Collection c=new ArrayList();
        //ConcurrentModificationException异常！！！
        //Iterator it=c.iterator();

        c.add(1);
        c.add(2);
        c.add(3);
        Iterator it=c.iterator();
        while (it.hasNext()){
            Object o=it.next();
            // 没有更新迭代器
            //c.remove();直接通过集合，没有通知迭代器（导致迭代器快照与原集合状态不同）
            //更新迭代器 。
            it.remove(); //删除的是迭代器指向的当前对象。
            System.out.println(o);
        }
        System.out.println(c.size());
    }
}

运行结果：

1
2
3
0

三、List详述

• List集合存储元素特点：有序，可重复！

他们都是有顺序的，也就是放进去是什么顺序，取出来还是什么顺序，也就是基于线性存储，可以看作是一个可变数组

• List 接口下面主要有三个实现 ArrayList 、LinkedList和Vector

List接口的常用方法：

• void add(int index, E element) 在列表中指定的位置上插入指定的元素
• E get(int index) 根据下标获取元素
• int indexOf(Object o) 返回此列表中指定元素的第一个出现的索引
• int lastIndexOf(Object o) 返回此列表中指定元素的最后一个发生的索引
• E remove(int index) 移除此列表中指定下标的元素
• E set(int index, E element) 用指定元素替换此列表中指定位置的元素

示例代码（4）：

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

public class ListText01 {
    public static void main(String[] args) {
        //创建list类型集合
        List list=new ArrayList();
        //添加元素,将指定的元素到这个列表的末尾
        list.add("a");
        list.add("b");
        list.add("c");

        //在列表中指定的位置上插入指定的元素(效率低！！！)
        list.add(1,"ooo");

        //迭代器
        Iterator it=list.iterator();
        while(it.hasNext()){
            Object o=it.next();
            System.out.println(o);
        }
        System.out.println("=================================");

        //根据下标获取元素
        Object o=list.get(0);
        System.out.println(o);

        //list集合特有的遍历方法！！
        for(int i=0;i<list.size();i++){
            System.out.println( list.get(i));
        }

        // 返回此列表中指定元素的第一个出现的索引
        System.out.println(list.indexOf("b"));
        //返回此列表中指定元素的最后一个发生的索引
        System.out.println(list.lastIndexOf("c"));

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

        //移除此列表中指定位置的元素
        list.remove(1);
        System.out.println(list.size());//3
        //用指定元素替换此列表中指定位置的元素
        list.set(0,"n");
        System.out.println(list.get(0));
    }
}

运行结果：

a
ooo
b
c
==============================
a
a
ooo
b
c
2
3
=============================
3
n

ArrayList类

• ArrayList底层是Object类型的数组。
• ArrayList集合初始化容量10。添加第一个元素时，创建长度为10的空数组。
• 扩容机制：扩容为原容量1.5倍。

ArrayList集合优化：尽可能少的扩容，数组扩容效率低。

• ArrayList集合优缺点：

优点：查询数据比较快，检索效率高
缺点：添加和删除数据比较慢，无法存大数据量（向数组末尾添加元素效率高）

• ArrayList是非线程安全

示例代码（5）：

import java.util.*;

public class ArrayListText01 {
    public static void main(String[] args) {
       //初始化容量为10
        List list1=new ArrayList();
        //初始化容量为20
        List  list2=new ArrayList(20);

        Collection c=new ArrayList();
        c.add("cccc");
        c.add("bvncm");
        c.add("mnkj");

        Iterator it=c.iterator();   
        while (it.hasNext()){
            Object o= it.next();
            System.out.println(o);
        }
    }
}

运行结果：

cccc
bvncm
mnkj

LinkedList类

• LinkedList底层是基于链表数据结构。
• LinkedList集合优缺点：

优点：添加和删除数据比较快，随机增删效率高
缺点：查询数据比较慢，检索效率低。

Vector类

• Vector初始化容量是10.
• 扩容为原容量的2倍。
• Vector底层是数组。
• Vector底层是线程安全的，但是效率低

泛型机制（jdk1.5之后新特性）

• 只在编译时起作用，给编译器参考
• 泛型优缺点：

优点：
1.集合中存储元素类型统一
2.集合中去除掉元素是泛型指定的类型，无需进行向下转型。
缺点：导致集合中元素缺乏多样性

• JDK8新特性：钻石表达式

List<String> list = new ArrayList<>();
	类型自动推断！

示例代码（6）：

使用泛型之前

自定义类：

class Animal{
    public void run(){
        System.out.println("动物在移动！！");
    }
}
class Cat extends Animal{
    public void catchMouse(){
        System.out.println("猫抓老鼠");
    }
}

class Dog extends Animal{
    public void fly(){
        System.out.println("狗在飞");
    }
}

测试类：

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

/**
 * jdk5.0之后的特性：泛型
 */
public class GenericText {
    //使用泛型之前
    public static void main(String[] args) {
        List list = new ArrayList();

        Cat cat = new Cat();
        Dog dog = new Dog();

        list.add(cat);
        list.add(dog);

        Iterator it = list.iterator();

        while (it.hasNext()) {
            Object o = it.next();
            if (o instanceof Animal) {
                ((Animal) o).run();
            }
        }
    }
}

运行结果：

动物在移动！！
动物在移动！！

使用泛型之后

测试类：

public class GenericText {
    public static void main(String[] args) {
        //使用泛型List<Animal>后，表示List集合只能存储Animal类型的元素
        //泛型指定集合中存储的数据类型
        List<Animal> list = new ArrayList<Animal>();

        Cat cat = new Cat();
        Dog dog = new Dog();

        list.add(cat);
        list.add(dog);
        //表示迭代器迭代Animal类型
        Iterator<Animal> it = list.iterator();
        while (it.hasNext()) {
            //使用泛型后，迭代器每一次返回的数据是Animal类型
            Animal a = it.next();
            //无需强转，直接调用
            a.run();
            if (a instanceof Cat) {
                ((Cat) a).catchMouse();
            } else if (a instanceof Dog) {
                ((Dog) a).fly();
            }
        }
    }
}

运行结果：

动物在移动！！
猫抓老鼠
动物在移动！！
狗在飞

一起找不同吧！！！！！

四、Set详述

• Set集合存储元素特点：无序不可重复。

无序表示存进去是这个顺序，取出来就不一定是这个顺序了，另外Set集合中元素没有下标。Set集合中的元素还不能重复。

HashSet类

HashSet 中的数据是无序的不可重复的。HashSet 按照哈希算法存取数据的，具有非常好性能，它的工作原理是这样的，当向 HashSet 中插入数据的时候，他会调用对象的 hashCode 得到该对象的哈希码，然后根据哈希码计算出该对象插入到集合中的位置。

• HashSet不是同步的；
• 集合元素值可以是null；

如果HashSet集合中存入一个元素时，HashSet会调用该对象的hashCode方法来得到该对象的hashCode值，然后根据该hashCode值决定该对象在HashSet中的存储位置。如果有两个元素通过equals方法比较true，但它们的hashCode方法返回的值不相等，HashSet将会把它们存储在不同位置，依然可以添加成功。
HashSet集合判断两个元素的标准是两个对象通过equals方法比较相等，并且两个对象的hashCode方法返回值也相等。

特别是向 HashSet 或 HashMap 中加入数据时必须同时覆盖 equals 和 hashCode 方法，应该养成一种习惯覆盖 equals 的同时最好同时覆盖 hashCode

• Java语法要求：

两个对象 equals 相等，那么它的 hashcode 相等
两个对象 equals 不相等，那么它的 hashcode 并不要求它不相等，但一般建议不相等
hashcode 相等不代表两个对象相等（采用 equals 比较）

哈希表

• 一个元素为链表的数组，综合了数组与链表的优点。

示例代码（7）：

没有重写hashCode和equals之前

自定义类：

public class Student {
    private String name;

    public Student() {

    }

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

    public String getName() {
        return name;
    }

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

测试类：

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

public class HashMapText02 {
    public static void main(String[] args) {
        Student s1 = new Student("zhangsan");
        Student s2 = new Student("zhangsan");

        System.out.println(s1.equals(s2));
        //重写hashCode之前
        System.out.println("s1hashCode值：" + s1.hashCode());
        System.out.println("s2hashCode值：" + s2.hashCode());

        Set<Student> set=new HashSet<>();
        set.add(s1);
        set.add(s2);
        System.out.println(set.size());//2
      }
}

运行结果：

false
s1hashCode值：284720968
s2hashCode值：122883338
2

重写hashCode和equals之后

自定义类：

public class Student {
    private String name;

    public Student() {

    }

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

    public String getName() {
        return name;
    }

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

    //equals方法
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return Objects.equals(name, student.name);
    }

    //hashCode方法
    public int hashCode() {
        return Objects.hash(name);
    }
}

测试类：

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

public class HashMapText02 {
    public static void main(String[] args) {
        Student s1 = new Student("zhangsan");
        Student s2 = new Student("zhangsan");

        System.out.println(s1.equals(s2));
        //重写hashCode之后
        System.out.println("s1hashCode值：" + s1.hashCode());
        System.out.println("s2hashCode值：" + s2.hashCode());

   Set<Student> set=new HashSet<>();
        set.add(s1);
        set.add(s2);
        System.out.println(set.size());//1
    }
}

运行结果：

true
s1hashCode值：-1432604525
s2hashCode值：-1432604525
1

找呀找呀，找不同。

TreeSet类

• TreeSet是SortedSet接口的实现类，TreeSet可以确保集合元素处于排序状态。
• TreeSet 可以对 Set 集合进行排序，默认自然排序（即升序）
• TreeSet 是可排序的
• TreeSet集合对自定义数据可以排序方法：

第一种：Java提供了一个Comparable接口，该接口里定义了一个compareTo(Object obj)方法，该方法返回一个整数值，实现该接口的类必须实现该方法，实现了该接口的类必须实现该方法，实现接口的类就可以比较大小了。当调用一个一个对象调用该方法与另一个对象进行比较obj1.compareTo(obj2)如果返回0表示两个对象相等；如果返回正整数则表明obj1大于obj2,如果是负整数则相反。
第二种：在构造TreeSet或TreeMap集合时给他一个比较器对象。比较规则自己写！！！

• Comparable 与Comparator区别？

当比较规则不会发生改变时或比较规则只用一个时建议实现Comparable接口
当比较规则有多个，并且需要多个比较规则之间进行切换，建议使用与Comparator
编写比较器可以改变规则！！！
Comparator区别符合OCT原则

红黑树（自平衡二叉树）

• TreeSet内部实现的是红黑树，默认整形排序为从小到大。
• 三种遍历方式：前序遍历，中序遍历，后序遍历。（前中后指的是根的位置）
• TreeSet采用中序遍历方式。

示例代码（8）：

import java.util.TreeSet;

public class TreeMapText01 {
    public static void main(String[] args) {
        //
        TreeSet<String> ts=new TreeSet();
        ts.add("zhangsan");
        ts.add("wangwu");
        ts.add("make");
        ts.add("langlang");
        for (String s: ts){
            System.out.println(s);
        }
        System.out.println("=============================");
        TreeSet<Integer> ts2=new TreeSet();
        ts2.add(200);
        ts2.add(300);
        ts2.add(600);
        ts2.add(14);
        for (Integer i:ts2){
            System.out.println(i);
        }
    }
}

运行结果：

langlang
make
wangwu
zhangsan
=============================
14
200
300
600

Process finished with exit code 0

从以上结果可以看出，String类和Integer类都实现了这个接口。
示例代码（9）：

实现Comparable接口

Customer类：

class Customer implements Comparable<Customer>{
    int age;

    public Customer(int age) {
        this.age = age;
    }
    //需要在此方法写比较的逻辑，或者说出比较规则，按照什么进行比较！！
    //比较规则自己定

    public int compareTo(Customer o) {//c1.comperTo(c2);
        //this是c1,o是c2
        //c1与c2比较，就是this与c比较
       // return this.age-o.age;
        return o.age-this.age;
    }

    @Override
    public String toString() {
        return "Customer{" + "age=" + age + '}';
    }
}

测试类：

import java.util.TreeSet;

public class TreeSetText03 {
    public static void main(String[] args) {
        Customer p = new Customer(23);
        Customer p2 = new Customer(100);
        Customer p3 = new Customer(30);
        Customer p4 = new Customer(65);
        Customer p5 = new Customer(46);

        TreeSet<Customer> treeSet = new TreeSet<>();

        treeSet.add(p);
        treeSet.add(p2);
        treeSet.add(p3);
        treeSet.add(p4);
        treeSet.add(p5);
        for (Customer c : treeSet) {
            System.out.println(c);
        }
    }
}

运行结果：

Customer{age=100}
Customer{age=65}
Customer{age=46}
Customer{age=30}
Customer{age=23}

示例代码（10）：

比较器进行排序

WuGui类：

class WuGui {
    int age;

    public WuGui(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "WuGui{" +
                "age=" + age +
                '}';
    }
}

比较器：

//单独在这里编写一个比较器
//比较实现java.util.Comparator接口。（Comparable是java.lang包下的，Comparator接口是java.util包下）

class WuguiComparator implements Comparator<WuGui> {

    public int compare(WuGui o1, WuGui o2) {
        return o1.age - o2.age;
    }
}

测试类：

import java.util.Comparator;
import java.util.TreeSet;

public class TreeSetText05 {
    public static void main(String[] args) {
        //创建TreeSet时，需要使用比较器
        //TreeSet<WuGui> wuGuis=new TreeSet<>();这样不行，没有通过构造方法构造一个比较器进去
        //给构造方法添加一个比较器
        TreeSet<WuGui> wuGuis = new TreeSet<>(new WuguiComparator());
        wuGuis.add(new WuGui(200));
        wuGuis.add(new WuGui(30));
        wuGuis.add(new WuGui(50));
        wuGuis.add(new WuGui(10));
        wuGuis.add(new WuGui(100));

        for (WuGui w : wuGuis) {
            System.out.println(w);
        }
    }
}

运行结果：

WuGui{age=10}
WuGui{age=30}
WuGui{age=50}
WuGui{age=100}
WuGui{age=200}

改进上面测试类（使用匿名内部类）代码如下：

public class TreeSetText05 {
    public static void main(String[] args) {
  //第三种！！ //使用匿名内部类的方式  这个类没有名字，直接new接口！！
        TreeSet<WuGui> wuGuis = new TreeSet<>(new Comparator<WuGui>() {
            @Override
            public int compare(WuGui o1, WuGui o2) {
                return o1.age - o2.age;
            }
        });
        wuGuis.add(new WuGui(200));
        wuGuis.add(new WuGui(30));
        wuGuis.add(new WuGui(50));
        wuGuis.add(new WuGui(10));
        wuGuis.add(new WuGui(100));

        for (WuGui w : wuGuis) {
            System.out.println(w);
        }
    }
}

推荐阅读：

十三、Java异常处理机制详解（建议收藏保存）
先不要知道它是为什么，得先知道它能干什么！！！！！

你们的支持是我分享和进步的动力，一起加油，一起努力，一起秃见成效！！
今天的分享就到这里啦！！~感谢大家的观看，希望对大家有帮助的话麻烦给个丝滑三连击。（点赞＋转发+关注）