18、集合（对象数组、Collection接口、List接口、Iterator、ListIterator、并发修改异常、ArrayList、Vector、LinkedList、集合元素去重）

对象数组

需求：我有3个学生，请把这个3个学生的信息存储到数组中，并遍历数组，获取得到每一个学生信息。
学生：Student
成员变量：name,age
构造方法：无参,带参
成员方法：getXxx()/setXxx()

package org.westos.demo4;

/**
 * @author lwj
 * @date 2020/5/10 9:06
 */
public class Student {
    private String name;
    private Integer age;

    public Student() {
    }

    public Student(String name, Integer age) {
        this.name = name;
        this.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;
    }

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

package org.westos.demo4;

/**
 * @author lwj
 * @date 2020/5/10 9:08
 */
public class MyTest {
    public static void main(String[] args) {
        Student[] students = new Student[3];
        students[0] = new Student("张三", 21);
        students[1] = new Student("李四", 22);
        students[2] = new Student("王五", 23);
        for (int i = 0; i < students.length; i++) {
            System.out.println(students[i]);
        }
        //Student{name=‘张三‘, age=21}
        //Student{name=‘李四‘, age=22}
        //Student{name=‘王五‘, age=23}
    }
}

Collection接口

数组和集合的区别：

• 长度区别
  • 数组的长度是固定的
  • 集合的长度是可变的
• 存储数据类型的区别
  • 数组可以存储基本数据类型，也可以存储引用数据类型
  • 集合只能存储引用数据类型
• 内容区别
  • 数组只能存储同种数据类型的元素
  • 集合可以存储不同类型的元素

Collection接口的继承体系图

Collection接口的功能概述

1、添加功能

boolean add(Object obj)
//添加一个元素
boolean addAll(Collection c)
//添加一个集合的元素

package org.westos.demo5;


import org.westos.demo4.Student;

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

/**
 * @author lwj
 * @date 2020/5/10 9:18
 */
public class MyTest {
    public static void main(String[] args) {
        Collection collection = new ArrayList();
        collection.add("abc");
        //String
        collection.add(100);
        //Integer
        collection.add(new Integer(200));
        collection.add(Integer.valueOf(300));
        boolean b = collection.add(Double.valueOf(3.14));
        System.out.println(b);
        //true
        collection.add(new Student("赵六", 31));
        collection.add(true);
        System.out.println(collection);
        //[abc, 100, 200, 300, 3.14, Student{name=‘赵六‘, age=31}, true]

        Collection collection1 = new ArrayList();
        collection1.add(new Student("张三", 10));
        collection1.add(new Student("李四", 20));
        collection1.add(60);

        collection.addAll(collection1);
        System.out.println(collection);
        //[abc, 100, 200, 300, 3.14, Student{name=‘赵六‘, age=31}, true, Student{name=‘张三‘, age=10}, Student{name=‘李四‘, age=20}, 60]
        System.out.println(collection1);
        //[Student{name=‘张三‘, age=10}, Student{name=‘李四‘, age=20}, 60]
    }
}

2、删除功能

boolean remove(Object o)
//移除一个元素
boolean removeAll(Collection c)
//移除一个集合的元素（交集）
void clear()
//移除所有元素

package org.westos.demo5;

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

/**
 * @author lwj
 * @date 2020/5/10 9:40
 */
public class MyDemo {
    public static void main(String[] args) {
        Collection collection = new ArrayList();
        collection.add("aaa");
        collection.add("bbb");
        collection.add("ccc");
        collection.add("ddd");
        collection.add("eee");

        boolean eee = collection.remove("eee");
        System.out.println(eee);
        //true
        System.out.println(collection);
        //[aaa, bbb, ccc, ddd]


        Collection collection1 = new ArrayList();
        //按alt鼠标选则多行的collection变量
        collection1.add("aaa");
        collection1.add("bbb");
        collection1.add("ccc");

        boolean b = collection.removeAll(collection1);
        System.out.println(b);
        //true
        System.out.println(collection);
        //[ddd]
        System.out.println(collection1);
        //[aaa, bbb, ccc]

        collection.clear();
        //清空集合中的元素
        System.out.println(collection);
        //[]
        collection1.clear();
        System.out.println(collection1);
        //[]
    }
}

3、判断功能

boolean contains(Object o)
//判断集合中是否包含指定元素
boolean containsAll(Collection o)
//判断集合中是否包含指定集合的元素（这个集合包含另一个集合的所有元素才算包含，返回true）
boolean isEmpty()
//判断集合是否为空

package org.westos.demo5;

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

/**
 * @author lwj
 * @date 2020/5/10 10:11
 */
public class MyTest2 {
    public static void main(String[] args) {
        Collection collection = new ArrayList();
        collection.add("aaa");
        collection.add("bbb");
        collection.add("ccc");
        collection.add("ddd");
        collection.add("eee");

        boolean aaa = collection.contains("aaa");
        System.out.println(aaa);
        //true

        Collection collection1 = new ArrayList();
        collection1.add("aaa");
        collection1.add("bbb");
        collection1.add("ccc");

        boolean b = collection.containsAll(collection1);
        //collection1集合的所有元素都在collection集合中可以找到
        System.out.println(b);
        //true

        System.out.println(collection.isEmpty());
        //false
        System.out.println(collection1.isEmpty());
        //false
    }
}

4、获取功能

Iterator<E> iterator()
//获取集合的迭代器
int size()
//元素的个数

//Collection单列集合体系的根接口
public interface Iterable<T> {
    Iterator<T> iterator();
    default void forEach(Consumer<? super T> action) {
        Objects.requireNonNull(action);
        for (T t : this) {
            action.accept(t);
        }
    }
}
public interface Iterator<E> {
    boolean hasNext();
    E next();
}
//ArrayList对iterator()方法的实现
public Iterator<E> iterator() {
    return new Itr();
}

ArrayList中的内部类Itr，实现了Iterator接口。

外部类与内部类

内部类的class字节码文件名称为：外部类名称$内部类名称。

package org.westos.demo5;

/**
 * @author lwj
 * @date 2020/5/10 10:38
 */
public class Outer {
    private class Inter {

    }

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

使用迭代器遍历学生集合

package org.westos.demo5;

import org.westos.demo4.Student;

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

/**
 * @author lwj
 * @date 2020/5/10 10:41
 */
public class Test {
    public static void main(String[] args) {
        Collection collection = new ArrayList();
        collection.add(new Student("张三", 20));
        collection.add(new Student("李四", 21));
        collection.add(new Student("王五", 22));

        Iterator iterator = collection.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
        //Student{name=‘张三‘, age=20}
        //Student{name=‘李四‘, age=21}
        //Student{name=‘王五‘, age=22}
    }
}

数组有没有length()方法呢?字符串有没有length()方法呢?集合有没有length()方法呢?

数组是length属性，任何数据类型的数组；
字符串String是length()方法；
集合是size()方法，没有length()方法，更没有length属性

boolean retainAll(Collection c)
//A集合对B集合取交集，获取到的交集元素在A集合中
Object[] toArray()
//把集合转换为数组

package org.westos.demo5;

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

/**
 * @author lwj
 * @date 2020/5/10 10:18
 */
public class MyDemo2 {
    public static void main(String[] args) {
        Collection collection = new ArrayList();
        collection.add("aaa");
        collection.add("bbb");
        collection.add("ccc");
        collection.add("ddd");
        collection.add("eee");

        Iterator iterator = collection.iterator();
        //获取集合的迭代器
        System.out.println(iterator);
        //java.util.ArrayList$Itr@1b6d3586
        //ArrayList的内部类，同时Itr类实现了Iterator接口
        //private class Itr implements Iterator<E> {}
        //内部类可以访问外部类的元素elementDate
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
        //aaa
        //bbb
        //ccc
        //ddd
        //eee

        System.out.println(collection.size());
        //5
        System.out.println("abc".length());
        //3
        System.out.println(new int[3].length);
        //3

        Collection collection1 = new ArrayList();
        collection1.add("aaa");
        collection1.add("bbb");
        collection1.add("ccc");

        boolean b = collection.retainAll(collection1);
        //把两个集合的交集放在collection集合中
        System.out.println(b);
        //true
        System.out.println(collection);
        //[aaa, bbb, ccc]
        System.out.println(collection1);
        //[aaa, bbb, ccc]

        Object[] objects = collection.toArray();
        System.out.println(Arrays.toString(objects));
        //[aaa, bbb, ccc]
    }
}

在使用Object[] toArray()方法时

package org.westos.demo5;

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

/**
 * @author lwj
 * @date 2020/5/10 13:06
 */
public class Demo {
    public static void main(String[] args) {
        Collection collection = new ArrayList();
        collection.add(100);
        collection.add(200);
        collection.add(300);

        Integer[] array = (Integer[]) collection.toArray();
        System.out.println(Arrays.toString(array));
    }
}

/*
Exception in thread "main" java.lang.ClassCastException: [Ljava.lang.Object; cannot be cast to [Ljava.lang.Integer;
	at org.westos.demo5.Demo.main(Demo.java:18)

Process finished with exit code 1
*/

类型转换异常，Object[]类型不能转换为Integer[]类型，（Object类型可以强转为Integer类型）。

Process finished with exit code 1：虚拟机异常终止。

List接口

元素有序，并且每一个元素都存在一个索引，元素可以重复。

List集合的特有功能概述
	void add(int index,E element):在指定索引处添加元素
	E remove(int index):移除指定索引处的元素  返回的是移除的元素
	E get(int index):获取指定索引处的元素
	E set(int index,E element):更改指定索引处的元素 返回的而是被替换的元素
	int indexOf(Object o):返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1 
	int lastIndexOf(Object o):返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1 
    ListIterator<E> listIterator():返回列表中的列表迭代器（按适当的顺序）
    List<E> subList(int fromIndex, int toIndex):返回此列表中指定的 fromIndex （含）和 toIndex之间的视图 

package org.westos.demo;

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

/**
 * @author lwj
 * @date 2020/5/10 13:14
 */
public class MyTest {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add(100);
        list.add(200);
        list.add(0, 300);
        //在指定索引处添加元素
        System.out.println(list);
        //[300, 100, 200]

        System.out.println(list.get(0));
        //根据索引获取元素
        //300

        System.out.println("新的遍历List集合的方式");
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        //300
        //100
        //200

        System.out.println("使用List特有的迭代器");
        ListIterator listIterator = list.listIterator();
        System.out.println(listIterator);
        //java.util.ArrayList$ListItr@1b6d3586
        //private class ListItr extends Itr implements ListIterator<E> {}
        while (listIterator.hasNext()) {
            System.out.println(listIterator.next());
        }
    }
}

package org.westos.demo;

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

/**
 * @author lwj
 * @date 2020/5/10 13:52
 */
public class MyDemo {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add(100);
        list.add(200);
        list.add(100);

        System.out.println(list.indexOf(100));
        //0
        System.out.println(list.lastIndexOf(100));
        //2

        List list1 = new ArrayList();
        list1.add("aaa");
        list1.add("aaa");
        list1.add("aaa");
        list1.add("bbb");
        list1.add("ccc");
        list1.add("ddd");

        boolean aaa = list1.remove("aaa");
        //返回是否删除成功
        System.out.println(aaa);
        //true
        System.out.println(list1);
        //[aaa, aaa, bbb, ccc, ddd]

        Object remove = list1.remove(0);
        //返回删除的那个元素
        System.out.println(remove);
        //aaa
        System.out.println(list1);
        //[aaa, bbb, ccc, ddd]
    }
}

package org.westos.demo;

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

/**
 * @author lwj
 * @date 2020/5/10 13:59
 */
public class MyTest2 {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add(100);
        list.add(200);
        list.add(300);
        list.add(400);
        list.add(500);

        list.remove(0);
        //根据索引删除

        list.remove(Integer.valueOf(500));
        //根据元素删除,手动包装

        System.out.println(list);
        //[200, 300, 400]

        Object set = list.set(0, 100);
        //根据索引替换集合中的元素,返回替换之前的旧元素
        System.out.println(set);
        //200
        System.out.println(list);
        //[100, 300, 400]

        List list1 = list.subList(0, 2);
        System.out.println(list1);
        //[100, 300]
        System.out.println(list);
        //[100, 300, 400]
    }
}

遍历Student对象集合

package org.westos.demo1;

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

/**
 * @author lwj
 * @date 2020/5/10 14:35
 */
public class MyTest {
    public static void main(String[] args) {
        Student student = new Student("张三", 12);
        Student student1 = new Student("李四", 13);
        Student student2 = new Student("王五", 14);

        List list = new ArrayList();
        list.add(student);
        list.add(student1);
        list.add(student2);
        
        //第一种
        Iterator iterator = list.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
        
        
        //第二种
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        
        
        //第三种
        ListIterator listIterator = list.listIterator(0);
        while (listIterator.hasNext()) {
            System.out.println(listIterator.next());
        }
    }
}

ListIterator接口

相比Iterator接口，增加了反向遍历。

但是在反向遍历之前，必须先将指针移动到集合的末尾。

package org.westos.demo;

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

/**
 * @author lwj
 * @date 2020/5/10 14:10
 */
public class MyDemo2 {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add(100);
        list.add(200);
        list.add(300);
        list.add(400);
        list.add(500);

        ListIterator listIterator = list.listIterator();
        while (listIterator.hasNext()) {
            listIterator.next();
        }
        while (listIterator.hasPrevious()) {
            System.out.println(listIterator.previous());
        }
        //500
        //400
        //300
        //200
        //100
    }
}

源码：

public ListIterator<E> listIterator() {
    return new ListItr(0);
}
//无参时默认光标就在0索引
public ListIterator<E> listIterator(int index) {
    if (index < 0 || index > size)
        throw new IndexOutOfBoundsException("Index: "+index);
    return new ListItr(index);
}
//反向遍历时可以将index设置为list.size()

package org.westos.demo;

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

/**
 * @author lwj
 * @date 2020/5/10 14:14
 */
public class MyTest3 {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add(100);
        list.add(200);
        list.add(300);
        list.add(400);
        list.add(500);

        ListIterator listIterator = list.listIterator(list.size());
        while (listIterator.hasPrevious()) {
            System.out.println(listIterator.previous());
        }
        //500
        //400
        //300
        //200
        //100
    }
}

package org.westos.demo;

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

/**
 * @author lwj
 * @date 2020/5/10 14:16
 */
public class MyDemo3 {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add(100);
        list.add(200);
        list.add(300);
        list.add(400);
        list.add(500);

        ListIterator listIterator = list.listIterator(1);
        while (listIterator.hasNext()) {
            System.out.println(listIterator.next());
        }
        //200
        //300
        //400
        //500
    }
}

ConcurrentModificationException

package org.westos.demo1;

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

/**
 * @author lwj
 * @date 2020/5/10 14:49
 */
public class MyDemo {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("aaa");
        list.add("world");
        list.add("bbb");
        

        ListIterator listIterator = list.listIterator();
        while (listIterator.hasNext()) {
            Object next = listIterator.next();
            String str = (String) next;
            if (str.equals("world")) {
                list.add("javaee");
                //使用的是集合的add方法
            }
        }
    }
}

Exception in thread "main" java.util.ConcurrentModificationException
	at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:909)
	at java.util.ArrayList$Itr.next(ArrayList.java:859)
	at org.westos.demo1.MyDemo.main(MyDemo.java:21)

并发修改异常。

原因是我们的迭代依赖于集合，当我们往集合中添加好了元素之后获取迭代器 ，那么迭代器已经知道了集合的元素个数，这个时候你在遍历的时候又突然想给集合里面加一个元素（用的是集合的add方法）那迭代器不同意就报错了。

解决方案：

1、使用迭代器的add方法。

package org.westos.demo1;

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

/**
 * @author lwj
 * @date 2020/5/10 14:49
 */
public class MyDemo {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("aaa");
        list.add("world");
        list.add("bbb");


        ListIterator listIterator = list.listIterator();
        while (listIterator.hasNext()) {
            Object next = listIterator.next();
            String str = (String) next;
            if (str.equals("world")) {
                //list.add("javaee");
                listIterator.add("javaee");
            }
        }
        System.out.println(list);
        //[aaa, world, javaee, bbb]
    }
}

2、使用for循环遍历集合 添加元素 不会报错

package org.westos.demo1;

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

/**
 * @author lwj
 * @date 2020/5/10 14:58
 */
public class MyTest2 {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("aaa");
        list.add("world");
        list.add("bbb");

        for (int i = 0; i < list.size(); i++) {
            if (list.get(i).equals("world")) {
                list.add(i + 1, "javaee");
            }
        }
        System.out.println(list);
        //[aaa, world, javaee, bbb]
    }
}

remove和add同理。

在使用迭代器遍历时，不能使用集合的remove方法。

package org.westos.demo1;

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

/**
 * @author lwj
 * @date 2020/5/10 15:04
 */
public class MyDemo2 {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("aaa");
        list.add("world");
        list.add("bbb");

        ListIterator listIterator = list.listIterator();
        while (listIterator.hasNext()) {
            if (listIterator.next().equals("world")) {
                listIterator.remove();
            }
        }
        System.out.println(list);
        //[aaa, bbb]
    }
}

package org.westos.demo1;

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

/**
 * @author lwj
 * @date 2020/5/10 15:07
 */
public class MyTest3 {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("aaa");
        list.add("world");
        list.add("bbb");

        for (int i = 0; i < list.size(); i++) {
            if (list.get(i).equals("world")) {
                list.remove(i);
            }
        }
        System.out.println(list);
        //[aaa, bbb]
    }
}

数据结构

数据结构其实就是存储数据的格式。
分类: 栈 , 队列 , 数组 , 链表 , 树 , 哈希表

数组特点：查询快，增删慢

链表特点：查询慢，增删快

List的三个子类的特点
ArrayList:
底层数据结构是数组，查询快，增删慢。
线程不安全，效率高。
Vector:
底层数据结构是数组，查询快，增删慢。
线程安全，效率低。
LinkedList:
底层数据结构是链表，查询慢，增删快。
线程不安全，效率高。

ArrayList

ArrayList的继承体系

Consumer接口（函数式接口）

@FunctionalInterface
public interface Consumer<T> {
    void accept(T t);
}

ArrayList的遍历

package org.westos.demo2;


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

/**
 * @author lwj
 * @date 2020/5/10 15:20
 */
public class MyTest {
    public static void main(String[] args) {
        ArrayList arrayList = new ArrayList();
        arrayList.add(100);
        arrayList.add(100);
        //元素可以重复
        arrayList.add(null);
        arrayList.add(null);
        //元素可以为null

        //遍历方式
        //两种迭代器
        Iterator iterator = arrayList.iterator();
        ListIterator listIterator = arrayList.listIterator();
        //for循环
        for (int i = 0; i < arrayList.size(); i++) {
			
        }
        //forEach JDK1.8新增的方法
        //匿名内部类
        arrayList.forEach(new Consumer() {
            @Override
            public void accept(Object o) {
                System.out.println(o);
            }
        });
        //Lambda表达式
        arrayList.forEach(o -> System.out.println(o));
        //100
        //100
        //null
        //null
        //如果方法的逻辑已经有实现
        arrayList.forEach(System.out::println);
        //100
        //100
        //null
        //null
    }
}

函数式接口Comparator

@FunctionalInterface
public interface Comparator<T> {
    int compare(T o1, T o2);
}

ArrayList的排序

package org.westos.demo2;

import java.util.ArrayList;
import java.util.Comparator;

/**
 * @author lwj
 * @date 2020/5/10 16:25
 */
public class MyDemo {
    public static void main(String[] args) {
        ArrayList arrayList = new ArrayList();
        arrayList.add(100);
        arrayList.add(20);
        arrayList.add(40);
        arrayList.add(200);
        arrayList.add(300);
        arrayList.add(400);


        //Comparator比较器接口
        arrayList.sort((o1, o2) -> (Integer)o1 - (Integer)o2);

        System.out.println(arrayList);
        //[20, 40, 100, 200, 300, 400]
    }
}

函数式接口Predicate

@FunctionalInterface
public interface Predicate<T> {
    boolean test(T t);
}

package org.westos.demo2;

import java.util.ArrayList;

/**
 * @author lwj
 * @date 2020/5/10 16:33
 */
public class MyTest2 {
    public static void main(String[] args) {
        ArrayList arrayList = new ArrayList();
        arrayList.add(100);
        arrayList.add(20);
        arrayList.add(40);
        arrayList.add(200);
        arrayList.add(300);
        arrayList.add(400);


        //删除大于100的整数
        arrayList.removeIf(o -> (Integer)o - 100 > 0);

        System.out.println(arrayList);
    }
}

Vector

package org.westos.demo3;

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

/**
 * @author lwj
 * @date 2020/5/10 16:40
 */
public class MyTest {
    public static void main(String[] args) {
        Vector vector = new Vector();
        vector.addElement(100);
        vector.addElement(200);

        Object o = vector.elementAt(0);
        System.out.println(o);
        //100

        //Vector独有的迭代器
        Enumeration elements = vector.elements();
        while (elements.hasMoreElements()) {
            System.out.println(elements.nextElement());
        }
        //100
        //200
    }
}

LinkedList

LinkedList具有队列和双端队列的性质，可以当作队列、栈使用，LinkedList没有实现RandomAccess，即不能快速访问。

课后题

1、使用LinkedList模拟栈数据结构

package org.westos.demo2;

import java.util.LinkedList;

/**
 * @author lwj
 * @date 2020/5/11 18:35
 */
public class MyTest {
    public static void main(String[] args) {
        //使用LinkedList模拟栈的操作
        LinkedList<Integer> integers = new LinkedList<>();
        integers.push(100);
        //public void push(E e) {
        //    addFirst(e);
        //}
        integers.push(200);
        integers.push(300);

        System.out.println(integers.peek());
        //Retrieves, but does not remove, the head (first element) of this list
        //查询但是不会移除
        //300
        System.out.println(integers.pop());
        //Pops an element from the stack represented by this list.
        //弹出栈顶元素
        //300
        integers.forEach(System.out::println);
        //遍历集合并打印
        //200
        //100
    }
}

2、去除集合中的重复元素（保留一个）

在第二种方式中，contains方法判断集合中是否包含integer参数：把参数和集合中的每一个元素进行比较，使用元素类型的equals()方法，比较的是int类型的value值是否相等。

public boolean contains(Object o) {
    return indexOf(o) >= 0;
}
//判断第一次出现的索引是否>=0
public int indexOf(Object o) {
    if (o == null) {
        for (int i = 0; i < size; i++)
            if (elementData[i]==null)
                return i;
    } else {
        for (int i = 0; i < size; i++)
            if (o.equals(elementData[i]))
                //使用参数类型的equals()方法比较集合中的元素
                return i;
    }
    return -1;
}

所以如果集合存储的是自定义类型（Student）时，需要重写Student类的equals()方法，然后进行比较。

//Integer的equals()方法
public boolean equals(Object obj) {
    if (obj instanceof Integer) {
        return value == ((Integer)obj).intValue();
    }
    return false;
}

package org.westos.demo;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;

/**
 * 去除重复元素保留一个
 * @author lwj
 * @date 2020/5/10 18:14
 */
public class MyTest {
    public static void main(String[] args) {
        ArrayList<Integer> integers = new ArrayList<>(Arrays.asList(12, 13, 12, 13, 11, 14, 11, 10, 15, 14));
        //1、不创建新集合
        for (int i = 0; i < integers.size() - 1; i++) {
            for (int j = i + 1; j < integers.size(); j++) {
                if (integers.get(i).equals(integers.get(j))) {
                    //如果相等，移除j索引该元素
                    integers.remove(j);
                    //List: remove(int index)
                    j--;
                    //移除了该元素之后，集合总长度-1，在j++之前必须j--
                }
            }
        }
        System.out.println(integers);
        //[12, 13, 11, 14, 10, 15]
    }
}

class MyTest2 {
    public static void main(String[] args) {
        ArrayList<Integer> integers = new ArrayList<>(Arrays.asList(12, 13, 12, 13, 11, 14, 11, 10, 15, 14));
        //2、创建新的集合
        ArrayList<Integer> target = new ArrayList<>();
        for (int i = 0; i < integers.size(); i++) {
            Integer integer = integers.get(i);
            if (!target.contains(integer)) {
                //如果集合中不包含此元素，则将此元素加入集合
                target.add(integer);
            }
        }
        System.out.println(target);
        //[12, 13, 11, 14, 10, 15]
    }
}

class MyTest3 {
    public static void main(String[] args) {
        ArrayList<Integer> integers = new ArrayList<>(Arrays.asList(12, 13, 12, 13, 11, 14, 11, 10, 15, 14));
        //3、使用HashSet集合
        HashSet<Integer> hashSet = new HashSet<>(integers);
        ArrayList<Integer> target = new ArrayList<>(hashSet);

        System.out.println(target);
        //[10, 11, 12, 13, 14, 15]
        //使用HashSet会改变原始顺序,按照hash排序
    }
}

2、去除集合中的重复元素（不保留重复元素）

package org.westos.demo;

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

/**
 * 去除重复元素不保留
 * @author lwj
 * @date 2020/5/10 18:23
 */
@SuppressWarnings("all")
public class MyDemo {
    public static void main(String[] args) {
        ArrayList<Integer> integers = new ArrayList<>(Arrays.asList(12, 13, 12, 13, 11, 14, 11, 10, 15, 14));
        //1、
        for (int i = 0; i < integers.size() - 1; i++) {
            boolean flag = false;
            //每次循环前重置flag
            for (int j = i + 1; j < integers.size(); j++) {
                if (integers.get(i).equals(integers.get(j))) {
                    integers.remove(j);
                    j--;
                    flag = true;
                    //表示存在重复元素
                }
            }
            if (flag) {
                integers.remove(i);
                i--;
            }
        }
        System.out.println(integers);
    }
}

18、集合（对象数组、Collection接口、List接口、Iterator、ListIterator、并发修改异常、ArrayList、Vector、LinkedList、集合元素去重）

原文：https://www.cnblogs.com/shawnyue-08/p/12872449.html