Java集合框架

1. 集合框架

1.1 概述

集合本质是容器。容器可以装很多类型的数据。Collection是集合的根类。容器的特性自动扩容。

1.2 集合和数组的区别

存储器	存储数据长度	存储数据类型单一性	存储数据类型的要求
数组	固定	只能存储同类型数据	引用类型、对象类型、基本类型、包装类型
集合	可变	可以存储不同类型数据	引用类型、对象类型、包装类型

1.3 集合特性

• 有序性集合
• 无序性集合
• 元素可重复集合
• 元素不可重复集合
• 不同集合各元素数据结构不同

1.4 集合数据结构及其他补充知识

• 栈（Stack）：main–>main中的a方法–>a中的b方法，在JVM的栈内存区，方法遵循先进后出原则，俗称弹栈。
• 队列（Queue）：先进先出，后进后出。
• 数组（Array）（查询快，增删慢）：长度固定，每个元素都有下标，在内存中是一块连续的内存空间，因为数组元素有
  下标，故查询很快，长度固定，所以添加元素很困难，需要创建新数组。
• 链表（Linked List）（增删快，查询慢）
  • 单向链表：在内存没有连续内存空间，由节点组成，每个节点至少由两部分组成，分别是地址域（指针域）和值域，
    地址域存放下一个节点的地址，值域存放本节点的值，末节点的地址域为null。
  • 双向链表：在内存没有连续内存空间，由节点组成，每个节点至少由三部分组成，分别是前后两个地址域（指针域）
    和一个值域，前地址域存放前一个节点的地址，后地址域存放后一个节点的地址，值域存放本节点的值。
  • 循环链表：在内存没有连续内存空间，由节点组成，每个节点至少由两部分组成，分别是地址域（指针域）和值域
    ，地址域存放下一个节点的地址，值域存放本节点的值，末节点的地址域存放首节点的地址域。
• 字典（Dictionary）：字典（Dictionary） 类是一个抽象类，它定义了键映射到值的数据结构。
• 枚举（Enumeration）：枚举（Enumeration）接口虽然它本身不属于数据结构,但它在其他数据结构的范畴
  里应用很广。 枚举（The Enumeration）接口定义了一种从数据结构中取回连续元素的方式。
• 位集合（BitSet）：位集合类实现了一组可以单独设置和清除的位或标志。
• 向量（Vector）（线程安全，效率低）：向量（Vector）类和传统数组非常相似，但是Vector的大小能根据需要动态的变化。
• 哈希表(散列值)（Hashtable）：数组+链表，数组中每个元素都是一个链表，数组的特性查询快，增删慢
  ，链表增删快，查询慢，哈希表将数组和链表的优势集于一身。
• 属性（Properties）：Properties 继承于 Hashtable.Properties 类表示了一个持久的属性集.属性
  列表中每个键及其对应值都是一个字符串。
• 桶状结构：
• 二叉树：最多有2个分支的树状结构，根节点、根节点下单独一个分支称为叶子节点
• 三叉树：最多有3个分支的树状结构，根节点、根节点下单独一个分支称为叶子节点
• 红黑树：红黑树是二叉树中的一种，它是一种自平衡二叉树
  • 存储过程：添加第一个元素作为根节点，再添加进来的元素和根节点进行比较，大的放右边，小的放左边，
    一样不添加元素（去重），并且每个子节点（根和叶子节点中间的部分）允许的最大分支为二。
  • 性质
    • 每个节点要么是黑色，要么是红色。
    • 根节点是黑色。
    • 每个叶子节点（NIL）是黑色。
    • 每个红色结点的两个子结点一定都是黑色。
    • 任意一结点到每个叶子结点的路径都包含数量相同的黑
  • 红黑树的自平衡操作
    • 变色
    • 左旋：由于红黑树本身是一棵二叉搜索树，即左子树的所有节点值都小于自己，右子树的所有节点值都
      大于自己。于是，在旋转过程，把y提为本子树的根节点时，由于y原来是x的右孩子，y > x，
      x成为y的左孩子。y原本的左孩子b就得给x腾出位置，x的右节点恰好空了出来。b原为x的右子
      树成员，b > x，成为x的右孩子很合理。
    • 右旋：同理
• 接口方法：接口中方法是使用public abstract修饰，无方法体
• 接口成员变量：接口成员变量是使用public final static修饰的
• 多态的本质：父类代表子类行使方法等
• 静态导入：import static java.lang.Math.*静态导入Math下所有方法
• 可变形参：可变形参类型一致Integer… args,args本质是一个数组，可以按照数组的方法进行操作，
  如果可变形参之外还有其他形参，可变形参需要放在最后
• 方法重载内部调用，使用this（三元运算符），Java源码技巧
• List集合中允许多个null
• Set集合允许一个null（去重）
• HashSet集合是无序的，添加元素的顺序和迭代的顺序不一致，Set集合在存储元素的时候有自己的一套规则，
  自身存储有规则。
• 回顾List去重2种方案
  • 方案一：重新创建新的集合，挨个添加，使用contains方法判断
  • 方案二：使用选择排序的思想去重，拿集合中的所有元素（不包括最后一个）和它之后的所有元素进
    行equals比较，
    如果相同就删除改元素，序号要自减1
• 哈希值是对象，哈希表是数据结构
• HashSet判断元素是否一样的底层公式k.hashCode==(v.hashCode)&&(k==v||k.equals(v))?true:false
• LinkedHashSet和HashSet区别
  • LinkedHashSet：具有可预知迭代顺序的Set接口的哈希表和链表实现。次实现与HashSet的不同之处在
    于，后者维护着一个运行所有条目的双重链表。此链表定义了迭代的顺序，即按照将元素插入set中的顺序
    （插入顺序）进行迭代。
    数据结构：哈希表+链表，哈希表保证元素唯一，链表保证元素的可迭代
  • HashSet：此类实现Set接口，由哈希表（实际上是一个HashMap实例）支持。它不保证set的迭代顺序，
    特别是它不保证该顺序恒久不变。数据结构：哈希表（数组+链表）
• TreeSet：元素唯一，可以排序（自然排序（元素具有比较性）、比较器排序（依赖比较器排序））
  • 数据结构：二叉树（二叉树中的红黑树即自平衡二叉树）
  • 存储过程：添加第一个元素进TreeSet作为根节点，再添加进来的元素和根节点进行比较，大的放右边
    ，小的放左边，一样不添加元素（去重），并且每个子节点（根和叶子节点中间的部分）允许的最大分支为二。
  • 二叉树的遍历方式
    • 前序遍历：左、中、右
    • 中序
    • 后续遍历
  • TreeSet自定义排序,E实现Comparable接口，重写comparaTo方法，comparaTo方法的返回值是
    int类型，0表示相等什么也不做，正数表示被比较的对象比当前对象打，放在红黑树的右边
    ，负数表示当前对象比被比较的对象小，放在红黑树的左边。
    匿名内部类interface Comparator
    POJO E 实现interface Comparable
    自定义比较器实现的是interface Comparator
• Map集合特性：键不能重复，唯一，认为键是一个Set集合，值可以重复，Map集合的键对应一个值，一对一。
• Map集合中key和value都是引用类型
• StringBuffer是线程安全，而StringBuilder是线程不安全的。
• HashSet的底层其实是HashMap
• TreeSet底层是TreeMap
• LinkedHashSet底层是LinkedHashMap
• Set集合线程安全的解决方案
  • 方案一：和list一样，使用Colletcions这个工具类syn方法类创建个线程安全的set
    Set synSet = Collections.synchronizedSet(new HashSet<>());
  • 方案二：使用JUC包里面的CopyOnWriteArraySet
    Set copySet = new CopyOnWriteArraySet<>();

1.5 集合中的泛型

• 使用泛型
  • JDK1.5新特性，对集合中的类型进行限定，把类型当做参数传递,将类型明确工作推迟到对象创建
    和方法调用
  • 类、抽象类、接口、方法使用泛型
• 定义泛型
  • 类、抽象类、接口、方法加E、T、K、V
• 应用场景
  • 方法重载
• 注意事项
  • 不能把一个明确的对象赋给一个泛型类中定义的成员变量和局部变量
  • 类中方法的参数泛型是成对出现的，void前和参数列表对应
  • 类中类的参数传递泛型是单一出现，作为限定类型的参数方便传递
  • 接口实现类的限定传递泛型>=接口本身的限定传递泛型，本质上接口和实现类传递同一套限定泛型,实
    现类泛型包含接口泛型
• 泛型通配符
  • 无边际通配符任意类型
  • 向下界定通配符A类型及A类型的子类对象
  • 向上界定通配符A类型的父类对象

2. 集合体系

2.1 集合体系树状导图

• Map集合根,双列集合，Map集合的子类数据结构都只针对键，值没有数据结构。
  • Hashtable底层和HashMap一样，key和value不允许为null，线程安全
  • HashMap线程不安全，数据结构哈希表，只针对key，哈希表的特点去重、元素唯一，通过重写
    equals、hashCode实现
    • LinkedHashMap数据结构链表和哈希表，链表保证包装数据是有序的，添加顺序和迭代顺
      序是一致的
  • IdentityHashMap
  • SortedMap
    • NavigableMap
  • WeakHashMap
  • TreeMap数据结构是红黑树，特点是可以排序
    • 排序方式：1、自然排序，2、比较器排序，自然排序的对象必须要实现comparable,比较
      器排序匿名内部类
      new Comparator(){@Override},比较器排序实现Comparator
• Collection集合根,单列集合
  • List有序、可重复
    • ArrayList线程不安全，效率高
    • Vector线程安全，效率低
    • LinkedList线程不安全，效率高
    • AbstractList
    • AbstractSequentialList
    • AttributeList
    • CopyOnWriteArrayList
    • RoleList
    • RoleUnresolvedList
    • Stack
  • Set无序，不可重复、元素唯一
    • HashSet底层数据结构哈希表（数组+链表）
      • LinkedHashSet底层数据结构哈希表+链表，哈希表保证元素唯一，链表保证元素的可迭代
    • SortedSet
      • NavigableSet
        • TreeSet元素唯一，可以排序（自然排序、比较器排序），底层二叉树（红黑树）
  • Queue
    • Deque
    • BlockingQueue

3. 集合示例代码

3.1 java.util.Collection

3.1.1 成员方法

• boolean add(E e)确保此 collection 包含指定的元素（可选操作）。
• boolean addAll(Collection c)将指定 collection 中的所有元素都添加到此
  collection 中（可选操作）。
• void clear()移除此 collection 中的所有元素（可选操作）。
• boolean contains(Object o)如果此 collection 包含指定的元素，则返回 true。
• boolean containsAll(Collection c)如果此 collection 包含指定 collection 中的所
  有元素，则返回 true。
• boolean equals(Object o)比较此 collection 与指定对象是否相等。
• int hashCode()返回此 collection 的哈希码值。
• boolean isEmpty()如果此 collection 不包含元素，则返回 true。
• Iterator iterator()返回在此 collection 的元素上进行迭代的迭代器。
• boolean remove(Object o)从此 collection 中移除指定元素的单个实例，如果存在的话（可选操作）。
• boolean removeAll(Collection c)移除此 collection 中那些也包含在指定 collection
  中的所有元素（可选操作）。
• boolean retainAll(Collection c)仅保留此 collection 中那些也包含在指定 collection
  的元素（可选操作）。
• int size()返回此 collection 中的元素数。
• Object[] toArray()返回包含此 collection 中所有元素的数组。
• T[] toArray(T[] a)返回包含此 collection 中所有元素的数组；返回数组的运行时类型与
  指定数组的运行时类型相同。

3.1.2 Demo

package com.xzy.JavaCollectionsFramWork.Code.java.util.Collection;

public class Student {
    private String name;
    private Integer age;

    public Student() {
    }

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

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

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

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

---

package com.xzy.JavaCollectionsFramWork.Code.java.util.Collection;

import com.sun.org.slf4j.internal.Logger;
import com.sun.org.slf4j.internal.LoggerFactory;

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

/**
 * @Class CollectionP
 * @Description
 * @Author xuzhiyong
 * @DateTime 2020/6/3 19:52
 * @Version 1.0
 */
public class CollectionP {

    //日志记录
    private static Logger logger = LoggerFactory.getLogger(CollectionP.class);

    public static void main(String[] args) {

    }

    public static void commonMethod5() {
        Collection c=new ArrayList();

        Student stu1 = new Student("zz", 31);
        Student stu2 = new Student("tt", 22);
        Student stu3 = new Student("yy", 18);

        c.add(stu1);
        c.add(stu2);
        c.add(stu3);

        System.out.println(c);

        //数组遍历
        Object[] ob= c.toArray();
        for (int i = 0; i < ob.length; i++) {
            Student st = (Student) ob[i];
            System.out.println(st.getName()+"::"+st.getAge());
        }

        //迭代器遍历
        System.out.println("---------[42]-------");
        Iterator it = c.iterator();
        while (it.hasNext()) {
            Student next = (Student) it.next();
            System.out.println(next.getName() + ":::" + next.getAge());
        }

        //for循环遍历
        System.out.println("---------[52]-------");
        for(Iterator iterator=c.iterator();iterator.hasNext();){
            Object next = iterator.next();
            Student stu = (Student) next;
            System.out.println(stu.getName() + ":::" + stu.getAge());
        }
    }

    public static void iterator4() {
        Collection c=new ArrayList();
        c.add("Java");
        c.add("Python");
        c.add("C++");

        Object[] ob = c.toArray();
        for (Object o : ob) {
            System.out.println(o);
        }
        System.out.println("---------[31]-------");
        for (int i = 0; i < ob.length; i++) {
            System.out.println(ob[i]);
        }
        System.out.println("---[36]---");
        //通过集合得到实现了该接口的迭代器对象
        Iterator it = c.iterator();
        while (it.hasNext()) {
            Object next = it.next();
            System.out.println(next);
        }
    }

    public static void commonMethod3() {
        Collection c1=new ArrayList();
        Collection c2=new ArrayList();

        c1.add("Java");
        c1.add("C++");
        c1.add("Python");

        c3.add("hello");
        c3.add("world");
        c3.add("Java");

        System.out.println(c1.contains(c2));
        System.out.println(c1);
        System.out.println(c2);

        System.out.println("--------------------[37]--------------------");

        System.out.println(c1.retainAll(c2));
        System.out.println(c1);
        System.out.println(c2);
    }

    public static void commonMethod2() {
        Collection c1=new ArrayList();
        Collection c2=new ArrayList();
        c1.add("good");
        c1.add("hello");
        c3.add("hello");
        c1.addAll(c2);

        c1.retainAll(c2);
//        c1.removeAll(c2);
        System.out.println(c1);
        System.out.println(c2);
    }

    public static void commonMethod1() {

        Collection c = new ArrayList();

        c.add("hello");
        c.add("hello");
        c.add("hello");
        c.add("Java");
        c.add("Java");
        c.add("Java");

        System.out.println(c.remove("java"));
        System.out.println(c.remove("Java"));

        System.out.println(c);

        System.out.println("----");
        for (Object o : c) {
            if (o.equals("hello")) {
                System.out.println(o);
            }
        }

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

        System.out.println(c.contains("hello"));
        System.out.println(c);
        System.out.println(c.isEmpty());
        System.out.println(c.size());
        c.clear();
    }
}

3.2 java.util.List

3.3.1 成员方法

• void add(int index,Object element)注定位置添加元素
• Object get(int index)获取指定位置的元素
• Object remove（int index）根据索引删除元素，返回被删除的元素
• Object set（int index，Object element）根据索引修改元素，返回被修改的元素
• List subList(int fromIndex, int toIndex)返回列表中指定的 fromIndex（包括 ）和 toIndex（不包括）之间的部分视图。
• int indexOf(Object o)返回此列表中第一次出现的指定元素的索引；如果此列表不包含该元素，则返回 -1。
• int lastIndexOf(Object o)返回此列表中最后出现的指定元素的索引；如果列表不包含此元素，则返回 -1。
• ListIterator listIterator()返回此列表元素的列表迭代器（按适当顺序）。
• ListIterator listIterator(int index)返回列表中元素的列表迭代器（按适当顺序），从列表的指定位置开始。

3.3.2 Demo

package com.xzy.JavaCollectionsFramWork.Code.java.util.List;

import com.sun.org.slf4j.internal.Logger;
import com.sun.org.slf4j.internal.LoggerFactory;

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

/**
 * @Class ListP
 * @Description List特有方法练习
 * - void add(int index,Object element)注定位置添加元素
 * - Object get(int index)获取指定位置的元素
 * - Object remove（int index）根据索引删除元素，返回被删除的元素
 * - Object set（int index，Object element）根据索引修改元素，返回被修改的元素
 * - List subList(int fromIndex, int toIndex)返回列表中指定的 fromIndex（包括 ）和 toIndex（不包括）之间的部分视图。
 * - int indexOf(Object o)返回此列表中第一次出现的指定元素的索引；如果此列表不包含该元素，则返回 -1。
 * - int lastIndexOf(Object o)返回此列表中最后出现的指定元素的索引；如果列表不包含此元素，则返回 -1。
 * @Author xuzhiyong
 * @DateTime 2020/6/4 9:42
 * @Version 1.0
 */
public class ListP {

    //日志记录
    private static Logger logger = LoggerFactory.getLogger(ListP.class);

    public static void main(String[] args) {
    }

    public static void commonMethod1() {
        List list = new ArrayList();

        list.add("Java");
        list.add("Python");
        list.add("Python");

        list.add(2,"Go");
//        list.add(4,"Go");//IndexOutOfBoundsException

        for (Object o : list) {
            System.out.println(o);
        }
        System.out.println("---------[40]-------");
        Iterator it = list.iterator();
        while (it.hasNext()) {
            String str = (String) it.next();
            System.out.println(str);
        }

        System.out.println("---------[42]-------");
        for (int i = 0; i < list.size(); i++) {
            String str = (String) list.get(i);
            System.out.println(str);
        }
        System.out.println("---------[47]-------");

        System.out.println(list.remove("Python3"));//Collection中的方法
        System.out.println("---------[51]-------");
        for (Object o : list) {
            System.out.println(o);
        }
        System.out.println("---------[59]-------");
        System.out.println(list.remove(2));//List中的方法
        System.out.println("---------[56]-------");
        for (Object o : list) {
            System.out.println(o);
        }

        System.out.println("---------(set)[66]-------");
        System.out.println(list.set(0, "String"));
        System.out.println("---------()[68]-------");
        for (Object o : list) {
            System.out.println(o);
        }
        System.out.println("---------(subList)[75]-------");
        System.out.println(list.subList(0, 2));
        System.out.println("---------()[77]-------");
        System.out.println(list.indexOf("String"));
        System.out.println("---------()[79]-------");
        System.out.println(list.lastIndexOf("Python"));
    }
}

3.3 java.util.ListIterator

3.3.1 成员方法

• void add(E e)将指定的元素插入列表（可选操作）。
• boolean hasNext()以正向遍历列表时，如果列表迭代器有多个元素，则返回 true（换句话说，如果 next 返回一个元素而不是抛出异常，则返回 true）。
• boolean hasPrevious()如果以逆向遍历列表，列表迭代器有多个元素，则返回 true。
• E next()返回列表中的下一个元素。
• int nextIndex()返回对 next 的后续调用所返回元素的索引。
• E previous()返回列表中的前一个元素。
• int previousIndex()返回对 previous 的后续调用所返回元素的索引。
• void remove()从列表中移除由 next 或 previous 返回的最后一个元素（可选操作）。
• void set(E e)用指定元素替换 next 或 previous 返回的最后一个元素（可选操作）。

3.3.2 Demo

package com.xzy.JavaCollectionsFramWork.Code.java.util.ListIterator;

public class Student {
    private String name;
    private Integer age;

    public Student() {
    }

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

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

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

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

---

package com.xzy.JavaCollectionsFramWork.Code.java.util.ListIterator;

import com.sun.org.slf4j.internal.Logger;
import com.sun.org.slf4j.internal.LoggerFactory;

import java.util.*;

/**
 * @Class ListIteratorP
 * @Description listIterator特有方法练习
 * - void add(E e)将指定的元素插入列表（可选操作）。
 * - boolean hasNext()以正向遍历列表时，如果列表迭代器有多个元素，则返回 true（换句话说，如果 next 返回一个元素而不是抛出异常，则返回 true）。
 * - boolean hasPrevious()如果以逆向遍历列表，列表迭代器有多个元素，则返回 true。
 * - E next()返回列表中的下一个元素。
 * - int nextIndex()返回对 next 的后续调用所返回元素的索引。
 * - E previous()返回列表中的前一个元素。
 * - int previousIndex()返回对 previous 的后续调用所返回元素的索引。
 * - void remove()从列表中移除由 next 或 previous 返回的最后一个元素（可选操作）。
 * - void set(E e)用指定元素替换 next 或 previous 返回的最后一个元素（可选操作）。
 * @Author xuzhiyong
 * @DateTime 2020/6/4 10:40
 * @Version 1.0
 */
public class ListIteratorP {

    //日志记录
    private static Logger logger = LoggerFactory.getLogger(ListIteratorP.class);

    public static void main(String[] args) {
    }

    public static void commonMethod2() {
        List l=new ArrayList();
        l.add(new Student("Tom",20));
        l.add(new Student("Robot",19));
        l.add(new Student("Bob",25));
        l.add(new Student("Sily",18));

        System.out.println("---------()[1]-------");
        ListIterator lis = l.listIterator();
        while (lis.hasNext()) {
            System.out.println(lis.next());
        }

        System.out.println("---------()[2]-------");
        for (int i = 0; i < l.size(); i++) {
            System.out.println(l.get(i));
        }

        System.out.println("---------()[3]-------");
        Iterator it = l.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());
        }

        System.out.println("---------()[4]-------");
        for (Object o : l) {
            System.out.println(o);
        }
    }

    public static void commonMethod1() {
        List list = new ArrayList();

        list.add("Java");
        list.add("Python");
        list.add("C++");
        list.add("Go");
        System.out.println("---------(顺序遍历)[32]-------");
        ListIterator li = list.listIterator();
        while (li.hasNext()) {
            System.out.println(li.next());
        }

        System.out.println("---------(逆序遍历)[35]-------");
        while (li.hasPrevious()) {
            System.out.println(li.previous());
        }
        System.out.println("---------(指定位置开始遍历)[42]-------");
        ListIterator li2 = list.listIterator(2);
        while (li3.hasNext()) {
            System.out.println(li3.next());
        }
        System.out.println("---------(指定位置逆遍历)[47]-------");

        System.out.println(li3.hasNext());//这货底层还是临时变量
        System.out.println("---------(list元素)[50]-------");

        for (Object o : list) {
            System.out.println(o);
        }
        System.out.println("---------()[55]-------");
        System.out.println(li.next());
        System.out.println(li.next());
        System.out.println("---------()[58]-------");
        System.out.println(li.previous());
        System.out.println(li.previous());

        list.clear();
        System.out.println(list.size());
        System.out.println("---------()[71]-------");

        list.add("Java");
        list.add("C++");
        list.add("Python");
        list.add("R");

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

        //普通添加元素
        for (int i = 0; i < list.size(); i++) {
            Object o = list.get(i);
            if (o.equals("C++")) {
                list.add("Go");
                break;
            }
        }
        System.out.println(list);

        //迭代器添加元素，在本次迭代元素之后添加元素
        ListIterator lis = list.listIterator();
        while (lis.hasNext()) {
            Object next = lis.next();
            if (next.equals("R")) {
                lis.add("Ruby");
                break;
            }
        }

        System.out.println(list);
    }
}

3.4 java.util.ArrayList

3.4.1 Demo

package com.xzy.JavaCollectionsFramWork.Code.java.util.ArrayList;


import java.util.Objects;

public class Teacher extends Person {
    private Integer salary;

    @Override
    public String getName() {
        return super.getName();
    }

    @Override
    public void setName(String name) {
        super.setName(name);
    }

    @Override
    public boolean equals(java.lang.Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Teacher teacher = (Teacher) o;
        return Objects.equals(salary, teacher.salary);
    }

    @Override
    public int hashCode() {
        return Objects.hash(salary);
    }

    public Integer getSalary() {
        return salary;
    }

    public void setSalary(Integer salary) {
        this.salary = salary;
    }

    public Teacher() {
    }

    public Teacher(String name,Integer salary) {
        this.salary = salary;
        super.setName(name);
    }

    public void showTeacher(){
        System.out.println("Teacher"+":"+super.getName()+":"+salary);
    }
}

---

package com.xzy.JavaCollectionsFramWork.Code.java.util.ArrayList;


import java.util.Objects;

public class Student extends Person{
        private Integer grade;

    public Student(Integer grade) {
        this.grade = grade;
    }

    public Integer getGrade() {
        return grade;
    }

    public void setGrade(Integer grade) {
        this.grade = grade;
    }

    @Override
    public String getName() {
        return super.getName();
    }

    @Override
    public String toString() {
        return "Student{" +
                "grade=" + grade +
                '}';
    }

    @Override
    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(grade, student.grade);
    }

    @Override
    public int hashCode() {
        return Objects.hash(grade);
    }

    @Override
    public void setName(String name) {
        super.setName(name);
    }

    public Student(String name, Integer grade) {
        super(name);
        this.grade = grade;
    }
}

---

package com.xzy.JavaCollectionsFramWork.Code.java.util.ArrayList;


public class Person {
    private String name;

    public String getName() {
        return name;
    }

    public Person() {
    }

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

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

    public void showPerson(){
        System.out.println("Person"+":"+name);
    }
}

---

package com.xzy.JavaCollectionsFramWork.Code.java.util.ArrayList;

public class MyGenericInterfaceImpl implements MyGenericInterface {
    @Override
    public void show(K e) {
        System.out.println(e);
    }
}

---

package com.xzy.JavaCollectionsFramWork.Code.java.util.ArrayList;

public interface MyGenericInterface {
    public abstract void show(K e);
}

---

package com.xzy.JavaCollectionsFramWork.Code.java.util.ArrayList;


import java.util.Objects;

/**
 * @Class MyGenericClassAndMethod
 * @Description 自定义泛型类、泛型方法，默认Object类型，创建对象可以不加泛型，也可以传入泛型参数
 * @Author xuzhiyong
 * @DateTime 2020/6/5 11:04
 * @Version 1.0
 */
public class MyGenericClassAndMethod {
    private E name;
    private T age;

    //方法的参数泛型是成对出现的，void前和参数列表对应
    public  void add(K k, V v) {
        System.out.println(k + ":::" + v);
    }

    public  void show() {
        System.out.println("good");
    }

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

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

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

    public E getName() {
        return name;
    }

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

    public T getAge() {
        return age;
    }

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

    public MyGenericClassAndMethod(E name, T age) {
        this.name = name;
        this.age = age;
    }

    public MyGenericClassAndMethod() {
    }
}

---

package com.xzy.JavaCollectionsFramWork.Code.java.util.ArrayList;

import java.util.*;

/**
 * @Class ArrayListP
 * @Description 迭代器遍历、集合泛型
 * @Author xuzhiyong
 * @DateTime 2020/6/4 15:33
 * @Version 1.0
 */
public class ArrayListP {

    public static void main(String[] args) {
    }

    public static void method15() {
        //创建集合
        ArrayList integers = new ArrayList<>();
        //创建数组
        Integer[] integers1 = new Integer[integers.size()];
        //数组转集合
        List integers2 = Arrays.asList(integers1);
        //集合转数组
        Integer[] integers3 = integers.toArray(integers1);
        //数组排序
        Arrays.sort(integers3);
    }

    public static Integer judge(Integer...args){
        Integer number=args[0];
        Integer max=number;
        for (int i = 1; i < args.length; i++) {
            if (args[i]>number) {
                max=args[i];
            }
        }
        return max;
    }

    public static void method14() {
        ArrayList numbers1 = new ArrayList<>();
        //低版本
        for (int i = 0; i < 100; i++) {
            if (numbers1.size() >9) {
                continue;
            } else {
                int num = (int) (Math.random() * 20 + 1);
                if (!numbers1.contains(num)) {
                    numbers1.add(num);
                }
            }

        }
        for (Integer number : numbers1) {
            System.out.println(numbers1.size()+":::"+number);
        }
        //最优版本
        ArrayList numbers2 = new ArrayList<>();
        int count=0;
        while (count<10){
            int num = (int) (Math.random() * 20 + 1);
            if (!numbers1.contains(num)) {
                numbers1.add(num);
            }
        }
        for (Integer integer : numbers2) {
            System.out.println(numbers3.size()+":::"+integer);
        }


    }

    public static void method11() {
        ArrayList> course = new ArrayList<>();

        ArrayList java1 = new ArrayList<>();
        ArrayList java2 = new ArrayList<>();

        com.xzy.javaapi.java.util.arrays.Student s1 = new com.xzy.javaapi.java.util.arrays.Student("xzy", 20);
        com.xzy.javaapi.java.util.arrays.Student s2 = new com.xzy.javaapi.java.util.arrays.Student("Bill", 18);
        com.xzy.javaapi.java.util.arrays.Student s3 = new com.xzy.javaapi.java.util.arrays.Student("Tom", 22);

        java1.add(s1);
        java1.add(new com.xzy.javaapi.java.util.arrays.Student("Sily", 23));
        java1.add(new com.xzy.javaapi.java.util.arrays.Student("King", 25));
        java3.add(s2);
        java3.add(s3);

        course.add(java1);
        course.add(java2);

        //第一种增强for
        int x = 1;
        for (ArrayList students : course) {
            System.out.println(x);
            for (com.xzy.javaapi.java.util.arrays.Student student : students) {
                System.out.println(student.getName() + "::" + student.getAge());
            }
            x++;
        }
        x--;
        x--;
        System.out.println("---------()[" + getLineNumber() + "]-------");
        //第二种普通迭代器遍历
        Iterator> iterator = course.iterator();
        while (iterator.hasNext()) {
            System.out.println(x);
            ArrayList next = iterator.next();
            Iterator iterator1 = next.iterator();
            while (iterator1.hasNext()) {
                com.xzy.javaapi.java.util.arrays.Student next1 = iterator1.next();
                System.out.println(next1.getName() + "---" + next1.getAge());
            }
            x++;
        }
        x--;
        x--;
        System.out.println("---------()[" + getLineNumber() + "]-------");
        //第三种集合迭代器遍历，正向展开
        ListIterator> arr = course.listIterator();
        while (arr.hasNext()) {
            System.out.println(x);
            ArrayList next = arr.next();
            ListIterator st = next.listIterator();
            while (st.hasNext()) {
                com.xzy.javaapi.java.util.arrays.Student previous = st.next();
                System.out.println(previous.getName() + previous.getAge());
            }
            x++;
        }
        x--;
        x--;
        System.out.println("---------(正向遍历完成)[" + getLineNumber() + "]-------");

        while (arr.hasPrevious()) {
            System.out.println(x);
            ArrayList previous = arr.previous();
            //不使用for循环，使用纯粹的List迭代器能否实现多维数组的循环遍历逆向打印。
            for (com.xzy.javaapi.java.util.arrays.Student student : previous) {
                System.out.println(student.getName() + student.getAge());
            }
            x++;
        }
        x--;
        x--;
        System.out.println("---------(逆向遍历)[" + getLineNumber() + "]-------");
        //第四种，数组遍历
        for (int i = 0; i < course.size(); i++) {
            System.out.println(x);
            ArrayList st = course.get(i);
            for (int j = 0; j < st.size(); j++) {
                com.xzy.javaapi.java.util.arrays.Student student = st.get(j);
                System.out.println(student.getName() + student.getAge());
            }
            x++;
        }
        x--;
        x--;
        System.out.println("---------(数组遍历)[" + getLineNumber() + "]-------");
    }

    /**
     * @Method {@link }{@link ArrayListP#method12()}T(n)=O(n)
     * @Description 增强for循环，被遍历的集合或数组不能为空，即null，底层是迭代器
     * @Version 1.0
     */
    public static void method13() {
        String[] arr = {"Java", "C++", "R"};

        for (String s : arr) {
            System.out.println(s);
        }
        System.out.println("---------()[" + getLineNumber() + "]-------");
        ArrayList strs = new ArrayList<>();
        strs.add("Java");
        strs.add("C++");
        strs.add("R");
        strs.add(null);

        for (String str : strs) {
            System.out.println(str);
        }

    }

    /**
     * @Method {@link Void}{@link ArrayListP#method11()}T(n)=O()
     * @Description 向上界定通配符,迭代器不能有null，否则会报空指针异常
     * @Version 1.0
     */
    public static void method12() {
        //测试区
        ArrayList objects = new ArrayList<>();//可以任意类型,
        ArrayList objects1 = new ArrayList<>();//可以添加Student、Person、null,null不能使用迭代器遍历，否则NullPointException
        ArrayList objects2 = new ArrayList<>();//可以添加Student、null,null不能使用迭代器遍历，否则NullPointException
        objects1.add(null);
        objects1.add(new Teacher());
        objects1.add(new Person());
        objects3.add(new Teacher());
//        objects3.add(new Person());//错误,感觉和extends一样，区别是super可以直接限定为最大的类型

        //正式测试区
        System.out.println("---------()[" + getLineNumber() + "]-------");
        ArrayList teachers = new ArrayList<>();
        ArrayList people = new ArrayList<>();
        ArrayList he = new ArrayList<>();


        teachers.add(new Teacher("Tom", 20000));
        teachers.add(new Teacher("Bob", 15000));
        teachers.add(new Teacher("Bill", 30000));
        people.add(new Teacher());
        people.add(new Person());
        method10(teachers);
        System.out.println("---------()[" + getLineNumber() + "]-------");
        method7(teachers);
        method7(he);
        method9(teachers);
    }

    public static void method10(List list) {
        Iterator it = list.iterator();
        while (it.hasNext()) {
            Object next = it.next();
            Teacher next1 = (Teacher) next;
            System.out.println(next1.getName() + ":" + next1.getSalary());
        }
    }

    public static void method9(List list) {
        Iterator it = list.iterator();
        while (it.hasNext()) {
            Teacher next = it.next();
            System.out.println(next.getName() + ":" + next.getSalary());
        }
    }


    /**
     * @Method {@link Void}{@link ArrayListP#method8()}
     * @Description 向下界定通配符
     * @T(n)
     * @Version 1.0
     */
    public static void method8() {

        //创建测试
        Person person = new Person();
        Teacher teacher = new Teacher();

        Person person1 = new Teacher();//对象多态

        Person[] people1 = new Teacher[20];//数组支持多态

        ArrayList people = new ArrayList<>();
        ArrayList teachers = new ArrayList<>();

//        ArrayList p=new ArrayList();集合泛型不支持自动多态

        //使用通配符限定父类
        //第一种
        ArrayList p1 = new ArrayList();//多态1
        //第二种
        ArrayList p2 = new ArrayList();//多态2

        p1 = new ArrayList();//赋值测试
        p1 = new ArrayList();//赋值测试

        //创建集合
        ArrayList teachers3 = new ArrayList<>();
        ArrayList arrayList = new ArrayList<>();
        arrayList = teachers3;

        //泛型参数需要是方法规定的向下界定泛型的本身或者子类
        method7(teachers);
        method7(people);
        method7(arrayList);
        method7(teachers3);

        //打印测试
        ArrayList teaTest = new ArrayList<>();
        teaTest.add(new Teacher("Tom", 10000));
        teaTest.add(new Teacher("Bob", 20000));
        teaTest.add(new Teacher("Bill", 15000));
        method7(teaTest);
    }

    public static void method7(List list) {
        Iterator it = list.iterator();
        while (it.hasNext()) {
            Person next = it.next();
            Teacher next1 = (Teacher) next;
            System.out.println(next1.getName() + ":" + next1.getSalary());
        }
    }

    public static void method6() {
        MyGenericInterface str = new MyGenericInterfaceImpl<>();
        str.show("gggg");
    }

    public static void method5() {
        MyGenericClassAndMethod str = new MyGenericClassAndMethod<>();
        str.add("20", 19);
        System.out.println("---------()[" + getLineNumber() + "]-------");
        str.show();
    }

    public static void method4() {
        ArrayList st1 = new ArrayList<>();
        ArrayList st2 = new ArrayList<>();
        st1.add(new Student("Tom", 25));
        st1.add(new Student("Sily", 24));
        st1.add(new Student("Sily", 24));
        st1.add(new Student("King", 18));
        st1.add(new Student("Bob", 19));
        st1.add(new Student("Bob", 19));
        st1.add(new Student("Bob", 19));
        st1.add(new Student("Ben", 26));
        st1.add(new Student("Bob", 19));
        st1.add(new Student("Ben", 26));
        st1.add(new Student("Bill", 30));

        ListIterator lis = st1.listIterator();
        while (lis.hasNext()) {
            Student st = lis.next();
            //contains底层依赖的是equals方法，没有重写的equals方法比较的首先会比较地址值，需要重写Student对象中的equals方法
            if (!st3.contains(st)) {//看清楚condition是什么，每次都菜的一逼
                st3.add(st);
            }
        }
        System.out.println("---------()[" + getLineNumber() + "]-------");
        System.out.println(st2);
        System.out.println("---------()[" + getLineNumber() + "]-------");

        //只有正遍历才能调用逆向遍历
        ListIterator lis2 = st3.listIterator();
        while (lis3.hasNext()) {
            lis3.next();
        }
        System.out.println("---------()[" + getLineNumber() + "]-------");
        while (lis3.hasPrevious()) {
            System.out.println(lis3.previous());
        }
    }

    public static void method3() {
        ArrayList st = new ArrayList<>();
        Student s1 = new Student("xzy", 20);
        Student s2 = new Student("Robot", 18);
        Student s3 = new Student("Tom", 25);

        st.add(s1);
        st.add(s2);
        st.add(s3);


        System.out.println("---------()[" + getLineNumber() + "]-------");

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

        System.out.println("---------()[" + getLineNumber() + "]-------");
        //使用逆向遍历，需要先正向遍历，才能再逆向遍历
        ListIterator lit = st.listIterator();
        while (lit.hasNext()) {
            System.out.println(lit.next());
        }
        System.out.println("---------()[" + getLineNumber() + "]-------");
        while (lit.hasPrevious()) {
            System.out.println(lit.previous());
        }
    }

    public static void method2() {
        //泛型参数化JDK1.5之后引入
        //泛型推断JDK1.7新特性
        ArrayList strs = new ArrayList<>();

        strs.add("Java");
        strs.add("Go");
        strs.add("R");

        Iterator it = strs.iterator();
        while (it.hasNext()) {
            String str = it.next();
            System.out.println(str);
        }
    }

    public static void method1() {
        ArrayList arr = new ArrayList();

        arr.add("Java");
        arr.add("R");
        arr.add("Go");
        arr.add("Python");
        arr.add("C++");

        Iterator it = arr.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());
        }
        System.out.println("---------()[" + getLineNumber() + "]-------");
        arr.add(new Student("xzy", 20));
        arr.add(new Student("Tom", 18));
        arr.add(new Student("Bob", 19));
        arr.add(new Student("King", 25));

        Iterator it2 = arr.iterator();
        while (it3.hasNext()) {
            System.out.println(it3.next());
        }
    }

    public static int getLineNumber() {
        int level = 1;
        StackTraceElement[] stacks = new Throwable().getStackTrace();
        int lineNumber = stacks[level].getLineNumber();
        return lineNumber;
    }
}

3.5 java.util.Vector

3.5.1 成员方法

• void addElement(Object obj)添加指定对象到集合中
• Object elementAt(int index)返回指定索引处的元素
• Enumeration elements()获得迭代器
• boolean hasMoreElements()判断迭代器指向的下一个元素是否存在
• Object nextElement()返回迭代器指向的下一个元素

3.5.2 Demo

package com.xzy.JavaCollectionsFramWork.Code.java.util.Vector;

public class Student {
    private String name;
    private Integer age;

    public Student() {
    }

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

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

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

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

---

package com.xzy.JavaCollectionsFramWork.Code.java.util.Vector;

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

/**
 * @Class VectorP
 * @Description Vector特有方法练习
 * - void addElement(Object obj)添加指定对象到集合中
 * - Object elementAt(int index)返回指定索引处的元素
 * - Enumeration elements()获得迭代器
 * - boolean hasMoreElements()判断迭代器指向的下一个元素是否存在
 * - Object nextElement()返回迭代器指向的下一个元素
 * @Author xuzhiyong
 * @DateTime 2020/6/4 17:04
 * @Version 1.0
 */
public class VectorP {

    public static void main(String[] args) {
        Vector ve = new Vector();
        ve.addElement(new Student("Tom",20));
        ve.addElement(new Student("King",25));
        ve.addElement(new Student("Sally",19));

        System.out.println(ve.elementAt(0));

        System.out.println("---------()[29]-------");
        Enumeration el = ve.elements();
        while (el.hasMoreElements()) {
            System.out.println(el.nextElement());
        }
    }
}

3.6 java.util.LinkedList

3.6.1 成员方法

• void addFirst(Object e)在索引为0的位置添加对象
• void addLast(Object e)在集合末尾欠佳元素
• Object getFirst()获得集合首个元素
• Object getLast()获得集合末尾元素
• Object removeFirst()删除集合首个元素
• Object removeLast()删除集合末尾元素

3.6.2 Demo

package com.xzy.JavaCollectionsFramWork.Code.java.util.LinkedList;

import java.util.LinkedList;

/**
 * @Class MyStack
 * @Description 使用链表集合模拟栈先进后出
 * @Author xuzhiyong
 * @DateTime 2020/6/4 21:23
 * @Version 1.0
 */
public class MyStack {
    LinkedList li=new LinkedList();
    public void add(Object o){
        li.addFirst(o);
    }

    @Override
    public String toString() {
        return "MyStack{" +
                "li=" + li +
                '}';
    }

    public Object pop(){
        return li.removeFirst();
    }
    public Boolean isEmpty(){
        return li.isEmpty();
    }
}

---

package com.xzy.JavaCollectionsFramWork.Code.java.util.LinkedList;

import java.util.LinkedList;

/**
 * @Class MyQueue
 * @Description 使用链表集合模拟队列先进先出
 * @Author xuzhiyong
 * @DateTime 2020/6/4 21:24
 * @Version 1.0
 */
public class MyQueue {
    LinkedList li=new LinkedList();
    public void add(Object o){
        li.addFirst(o);
    }
    public Object pop(){
        return li.removeLast();
    }
    public Boolean isEmpty(){
        return li.isEmpty();
    }

    @Override
    public String toString() {
        return "MyQueue{" +
                "li=" + li +
                '}';
    }
}

---

package com.xzy.JavaCollectionsFramWork.Code.java.util.LinkedList;

import java.util.ArrayList;
import java.util.LinkedList;

/**
 * @Class LinkedListP
 * @Description LinkedList特有方法
 * - void addFirst(Person e)在索引为0的位置添加对象
 * - void addLast(Person e)在集合末尾欠佳元素
 * - Person getFirst()获得集合首个元素
 * - Person getLast()获得集合末尾元素
 * - Person removeFirst()删除集合首个元素
 * - Person removeLast()删除集合末尾元素
 * @Author xuzhiyong
 * @DateTime 2020/6/4 17:34
 * @Version 1.0
 */
public class LinkedListP {

    public static void main(String[] args) {
        removeRepeatingElements5();
    }

    public static void removeRepeatingElements5() {
        //去除arr1中的重复元素，2个集合实现，O（n）
        ArrayList arr1 = new ArrayList();
        ArrayList arr2 = new ArrayList();

        arr1.add("Java");
        arr1.add("R");
        arr1.add("R");
        arr1.add("Go");
        arr1.add("Go");
        arr1.add("Python");
        arr1.add("Python");
        arr1.add("C++");
        arr1.add("C++");

        for (Object o : arr1) {
            if (!arr3.contains(o)) {
                arr3.add(o);
            }
        }
        System.out.println(arr2);
        //去除arr1中的重复元素，1个集合实现,O(n^2)，写完了给自己打个分好复杂！哈哈
        System.out.println("---------()[47]-------");
        arr1.clear();
        arr3.clear();

        arr1.add("Java");
        arr1.add("Java");
        arr1.add("R");
        arr1.add("Java");
        arr1.add("Java");
        arr1.add("R");
        arr1.add("Go");
        arr1.add("Go");
        arr1.add("Python");
        arr1.add("Python");
        arr1.add("C++");
        arr1.add("C++");
        ArrayList arr = new ArrayList();
        for (int i = 0; i < arr1.size()-1; i++) {
            for (int j = i+1; j < arr1.size(); j++) {
                if (arr1.get(i).equals(arr1.get(j))) {
                    arr.add(j);
                }
            }
        }

        for (Object o : arr) {
            arr1.set((Integer) o,"##");
        }

        for (int i = 0; i < arr.size(); i++) {
            arr1.remove("##");
        }

        System.out.println(arr1);


        //去除arr1中的重复元素，1个集合实现,简单算法

        System.out.println("---------()[85]-------");
        arr1.clear();
        arr3.clear();
        arr.clear();

        arr1.add("Java");
        arr1.add("Java");
        arr1.add("R");
        arr1.add("Java");
        arr1.add("Java");
        arr1.add("R");
        arr1.add("Go");
        arr1.add("Go");
        arr1.add("Python");
        arr1.add("Python");
        arr1.add("C++");
        arr1.add("C++");

        for (int i = 0; i < arr1.size()-1; i++) {
            for (int j = i+1; j < arr1.size(); j++) {
                if (arr1.get(i).equals(arr1.get(j))) {
                    arr1.remove(j);
                    j--;
                }
            }
        }
        System.out.println(arr1);

    }

    public static void Queue4() {
        MyQueue myQueue = new MyQueue();
        myQueue.add("Java");
        myQueue.add("C++");
        myQueue.add("Python");
        myQueue.add("R");

        System.out.println(myQueue);
        System.out.println("---------()[28]-------");

        while (!myQueue.isEmpty()) {
            System.out.println(myQueue.pop());
        }
        System.out.println("---------()[33]-------");
        System.out.println(myQueue);
    }

    public static void Stacktest3() {
        MyStack myStack = new MyStack();
        myStack.add("Java");
        myStack.add("Python");
        myStack.add("C++");
        myStack.add("R");

        System.out.println(myStack);

        System.out.println("---------()[30]-------");

        while (!myStack.isEmpty()) {
            System.out.println(myStack.pop());
        }
        System.out.println("---------()[36]-------");
        System.out.println(myStack);
    }

    public static void SimulationOfTheStackMthod2() {
        //模拟栈先进后出的结构
        LinkedList li = new LinkedList();
        //压栈
        li.addFirst("1");
        li.addFirst("2");
        li.addFirst("3");
        li.addFirst("4");

        //弹栈
        System.out.println(li.removeFirst());
        System.out.println(li.removeFirst());
        System.out.println(li.removeFirst());
        System.out.println(li.removeFirst());
    }

    public static void SpecificMethod1() {
        LinkedList li = new LinkedList();

        li.add("Java");
        li.add("Python");
        li.add("C++");
        li.add("Go");

        System.out.println(li);
        li.addFirst("R");
        System.out.println("---------()[24]-------");
        System.out.println(li);
        System.out.println("---------()[32]-------");
        System.out.println(li.getFirst());
        System.out.println("---------()[33]-------");
        System.out.println(li.getLast());
        System.out.println("---------()[36]-------");

        System.out.println(li.removeFirst());
        System.out.println("---------()[39]-------");
        System.out.println(li.removeLast());
        System.out.println("---------()[41]-------");
        System.out.println(li);
    }
}

3.7 java.util.HashSet

3.7.1 Demo

package com.xzy.JavaCollectionsFramWork.Code.java.util.HashSet;

import java.util.Objects;

public class Student {
    private String name;
    private Integer age;

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

    @Override
    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) &&
                Objects.equals(age, student.age);
    }

    public String getName() {
        return name;
    }

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

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

    public Integer getAge() {
        return age;
    }

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

    public Student() {
    }

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

---

package com.xzy.JavaCollectionsFramWork.Code.java.util.HashSet;

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

/**
 * @Class HashSetP
 * @Description HashSet集合
 * - void add（Object） 添加元素
 * - Iterator