目录
②.public void add(int index, E element)
④.public boolean remove(Object o)
⑥.public int indexOf(Object o)
⑧.public boolean contains(Object o)
⑩.public E set(int index, Object element)
回忆一下我们的集合框架体系图。List接口属于单列集合Collection接口下的其中一条分支，它最常用的三个实现类分别是——ArrayList，Vector，以及LinkedList。这三个实现类各有各的特点，但又有着一些相同的特性。本篇博文将带大家从List集合的介绍，特点，使用，再到它的三个常用实现类完完整整地给大家梳理清楚。
注意 : ①代码中的注释也很重要；②不要眼高手低，自己跟着过一遍才算有收获；③点击文章的侧边栏目录或者文章开头的目录可以进行跳转。良工不示人以朴，所有文章都会适时补充完善。大家如果有问题都可以在评论区进行交流或者私信up。感谢阅读！
List集合属于java.base模块，java.util包下，是单列集合Collection接口的一个子接口。之前在面向对象专题我们讲过，接口不能直接被实例化。因此需要通过创建其子类对象来完成该接口的实例化（即多态）。List接口的常用子类有ArrayList类，LinkedList类等，我们先以ArrayList类为栗来演示List接口中的常用方法。eg：
List list = new ArrayList(); （多态的方式保证了编译类型为List接口类型）
1.List集合是有序集合，即元素的存取顺序是一致的。List集合中的元素可通过索引的形式来访问。
如何理解此处的“存储顺序一致”呢？
比如说你将某个元素添加进去集合时，它在索引为3的位置，也就是在当前集合中的第四个元素，那么，在当前集合无改动的情况下，你想取出该元素就必须从索引为3的位置去取，大白话就是——一个元素原来是在哪儿放的，现在就是从哪儿取的。
2.List集合具有可重复的特点，即一个集合中可以有相同的元素。
1.创建集合对象
2.创建元素对象
3.将元素对象添加到集合对象中
4.遍历集合
我们先创建一个Student类，作为将来要实例化的类，之后可以将创建的Student类的对象添加到集合中。Student类代码如下：
package knowledge.API.gather.list;
public class Student {
//私有的成员变量
private String name;
private int age;
//公共的空参构造
public Student() { }
//公共的带参构造
public Student(String name, int age) {
this.name = name;
this.age = age;
}
//getter，setter方法
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;
}
//重写toString() 方法，以便于遍历集合时可以打印出学生对象。
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
up在Student类的同一包下创建LIstTest类作为演示类，来演示LIst接口的常用成员方法。
//将数据添加到集合的末尾，这里的E是泛型的意思，目前可以先理解为Object类。
package knowledge.API.gather.list;
import java.util.ArrayList;
import java.util.List;
public class ListTest {
public static void main(String[] args) {
//requirement : Test ①.public boolean add(E e)
//1.创建集合对象
List list = new ArrayList(); //此时集合list为空
boolean bool = list.add(100); //将第一个元素100添加到集合list中
System.out.println("100这个元素成功添加到了集合list中了吗：" + bool);
System.out.println("--------------------------------------------");
//实际开发中，往往省略用boolean类型作接收的步骤，而是直接添加，如下:
list.add(100); //再次添加一个元素100到集合list中，验证了list集合的可重复性。
list.add("CSDN"); //添加一个字符串类型的元素到集合list中
list.add("Cyan");
//2.创建元素对象
//接下来我们创建Student类对象(利用带参构造)，并将Student类对象的元素添加到集合对象中
Student st1 = new Student("Cyan", 20);
Student st2 = new Student("Five", 100);
Student st3 = new Student("Ice", 30);
//3.将元素对象添加到集合对象中
list.add(st1);
list.add(st2);
list.add(st3);
//4.遍历集合
//遍历一下集合，看看元素究竟添加进去没有:(get方法我们下面会讲到的，这里简单提一嘴，无非就是根据索引获取元素，功能上类似于数组)
//size()方法用于获取集合的长度，我们后面也会演示到。
for (int i = 0; i < list.size(); ++i) {
System.out.println("集合中索引为" + i + "的元素是" + list.get(i));
}
System.out.println("--------------------------------------------");
}
}
输出结果①：
//将指定的元素添加到该集合指定的位置。
为了更好地展示出方法②与方法①的区别，我们在方法①的基础上进行演示，如下：
package knowledge.API.gather.list;
import java.util.ArrayList;
import java.util.List;
public class ListTest {
public static void main(String[] args) {
//requirement : Test ②.public void add(int index, E element)
//1.创建集合对象
List list = new ArrayList(); //此时集合list为空
//2.创建元素对象
Student st1 = new Student("Cyan", 20);
Student st2 = new Student("Five", 100);
Student st3 = new Student("Ice", 30);
Student stu1 = new Student("Cyan", 200);
Student stu2 = new Student("Five", 1000);
Student stu3 = new Student("Ice", 300);
//3.将集合对象添加到元素对象中
list.add(st1);
list.add(st2);
list.add(st3);
/*
我们以及将st1，st2和st3三个Student类对象添加到了集合中，它们对应的索引自然是0，1，2
这时如果我们想在任意位置添加元素，就可以用到add的另一个重载方法，如下：
*/
list.add(0, stu1);
list.add(1, stu2);
list.add(2, stu3); //我们在集合的前面插入了三个Student对象元素
//4.遍历集合
for (int i = 0; i < list.size(); ++i) {
System.out.println("集合中索引为" + i + "的元素是" + list.get(i));
}
System.out.println("--------------------------------------------");
}
}
输出结果②：
//将指定索引处的元素从该集合中删除
package knowledge.API.gather.list;
import java.util.ArrayList;
import java.util.List;
public class ListTest {
public static void main(String[] args) {
//requirement : Test ③.public E remove(int index)
//1.创建集合对象
List list = new ArrayList(); //此时集合list为空
//2.创建元素对象
Student st1 = new Student("Cyan", 20);
Student st2 = new Student("Five", 100);
Student st3 = new Student("Ice", 30);
//3.将集合对象添加到元素对象中
list.add(st1);
list.add(st2);
list.add(st3);
list.add(11);// 添加三个相同的元素11到集合list中
list.add(11);
list.add(11);
//4.遍历集合
System.out.println("删除元素前的集合如下：");
for (int i = 0; i < list.size(); ++i) {
System.out.println("集合中索引为" + i + "的元素是" + list.get(i));
}
System.out.println("----------------------------------------------");
//现在我们调用remove() 方法，删除集合中的第一个元素及最后一个元素。
list.remove(0);
list.remove(list.size() - 1);
/*
特别注意，如果要连续删除集合中的前三个元素，只需要写三次list.remove(0);就可以了。
错误写法：
list.remove(0);
list.remove(1);
list.remove(2);
这么写的后果就是，并不会删除原集合中前三个元素，而是会跳着删除，
这是因为每次删除元素后，都是一个新的集合，下次删除传入的索引，只会在新集合中生效！
*/
System.out.println("删除索引为0，1的元素后，集合如下：");
for (int i = 0; i < list.size(); ++i) {
System.out.println("集合中索引为" + i + "的元素是" + list.get(i));
}
System.out.println("--------------------------------------------");
}
}
输出结果③:
//若该集合中存在该元素，则删除第一个指定的元素。
package knowledge.API.gather.list;
import java.util.ArrayList;
import java.util.List;
public class ListTest {
//requirement : Test ④.public boolean remove(Object o)
public static void main(String[] args) {
//1.创建集合对象
List list = new ArrayList();
//2.创建元素对象
Student student1 = new Student("Bob", 11);
Student student2 = new Student("Alice", 18);
//3.将元素对象添加到集合对象中
list.add(student1);
list.add(student2);
list.add(student2);
list.add(122);
list.add(122);
list.add(122);
//4.遍历集合
System.out.println("删除元素前，集合如下:");
for (int i = 0; i < list.size(); ++i) {
System.out.println("集合中索引为" + i + "的元素为" + list.get(i));
}
System.out.println("-----------------------------------");
//现在我们调用remove(Object o)方法来删除指定值的第一个元素(前提是该集合中要存在该元素才行)
list.remove((Object)122);
list.remove((Object)122);//删去了集合中的前两个元素。
/*
list.remove(122);
不能直接这样写，122会被当成索引，造成下标越界异常。
IndexOutOfBoundsException: Index 122 out of bounds for length 4
*/
System.out.println("删除元素后，集合如下；");
for (int i = 0; i < list.size(); ++i) {
System.out.println("索引:" + i + "元素：" + list.get(i));
}
}
}
输出结果④：
//根据索引，获取其对应的元素。
package knowledge.API.gather.list;
import java.util.ArrayList;
import java.util.List;
public class ListTest {
//requirement : Test ⑤.public E get(int index)
public static void main(String[] args) {
//1.创建集合对象
List list = new ArrayList();
//2.创建元素对象
Student kong = new Student("Aether", 19);
Student ying = new Student("Lumine", 19);
Student laoye = new Student("Diluc", 23);
//3.将元素对象添加到集合对象中
list.add(kong);
list.add(ying);
list.add(laoye);
//4.遍历集合
for (int i = 0; i < list.size(); ++i) {
Object o = list.get(i); //i代表索引，利用get方法获取指定索引处的元素
System.out.println("索引为" + i + "的元素是:" + o);
}
}
}
输出结果⑤：
//获取集合中第一个指定元素的索引，若集合中没有该元素，则返回-1。
package knowledge.API.gather.list;
import java.util.ArrayList;
import java.util.List;
public class ListTest {
//requirement : Test ⑥.public int indexOf(Object o)
public static void main(String[] args) {
//1.创建集合对象
List list = new ArrayList();
//2.创建元素对象
Student kong = new Student("Aether", 19);
Student ying = new Student("Lumine", 19);
Student laoye = new Student("Diluc", 23);
//3.将元素对象添加到集合对象中
list.add(kong);
list.add(ying);
list.add(laoye);
int index1 = list.indexOf(kong);
int index2 = list.indexOf(ying);
int index3 = list.indexOf(laoye);
System.out.println("kong元素对应的索引是：" + index1);
System.out.println("ying元素对应的索引是：" + index2);
System.out.println("laoye元素对应的索引是：" + index3);
//4.遍历集合
//遍历个j8...
}
}
输出结果⑥：
//获取集合的长度。
package knowledge.API.gather.list;
import java.util.ArrayList;
import java.util.List;
public class ListTest {
//requirement : Test ⑦.public int size()
public static void main(String[] args) {
//1.创建集合对象
List list = new ArrayList();
//2.创建元素对象
//懒得建了。。。
//3.添加元素对象到集合对象中
//直接加不行吗
list.add(1);
list.add(1);
list.add(1);
list.add(1);
int length = list.size();
System.out.println("集合的长度为：" + length);
System.out.println("集合的长度为：" + list.size()); //直接用方法就可以
//4.遍历集合
//遍历个p
}
}
输出结果⑦：
//判断该集合中是否有指定的元素。
package knowledge.API.gather.list;
import java.util.ArrayList;
import java.util.List;
public class ListTest {
//requirement : Test ⑧.public boolean contains(Object o)
public static void main(String[] args) {
//1.创建集合对象
List list = new ArrayList();
//2.创建元素对象
Student student = new Student("SB", 250);
Student student2 = new Student("Low", 11);
//3.添加元素对象到集合对象中
list.add(student);
list.add(student2);
boolean bool1 = list.contains(student); //判断集合中是否含有Student元素
boolean bool2 = list.contains(student2); //判断集合中是否含有Student2元素
boolean bool3 = list.contains(100); //传入一个集合中不存在的元素，作为对照
System.out.println("集合中含有student元素吗? " + bool1);
System.out.println("集合中含有student2元素吗? " + bool2);
System.out.println("集合中含有100元素吗? " + bool3);
//4.遍历集合
//遍历个p
}
}
输出结果⑧：
//判断集合是否为空。
package knowledge.API.gather.list;
import java.util.ArrayList;
import java.util.List;
public class ListTest {
//requirement : Test ⑨.public boolean isEmpty()
public static void main(String[] args) {
//1.创建集合对象
List list = new ArrayList();
boolean bool1 = list.isEmpty();
System.out.println("刚创建集合，集合目前是否为空呢:" + bool1);
System.out.println("刚创建集合，集合目前是否为空呢:" + list.isEmpty()); //同样也可直接输出
System.out.println("---------------------------------------\n");
//2.创建元素对象
Student student = new Student("SB", 250);
Student student2 = new Student("Low", 11);
//3.添加元素对象到集合对象中
list.add(student);
list.add(student2);
System.out.println("添加了几个元素之和，集合现在还为空吗?" + list.isEmpty());
//4.遍历集合
//遍历个p
}
}
输出结果⑨：
//可用来修改对应索引处的元素。
package knowledge.API.gather.list;
import java.util.ArrayList;
import java.util.List;
public class ListTest {
//requirement : Test ⑩.public E set(int index, Object element)
public static void main(String[] args) {
//1.创建集合对象
List list = new ArrayList();
//2.创建元素对象
Student st1 = new Student("Tom", 12);
Student st2 = new Student("Tom's Dad", 35);
//3.将元素对象添加到集合对象中
list.add(st1);
list.add(st1);
list.add(st1);
list.add(0, 11);
list.add(0, 12);
list.add(0, 13);
/*
每次添加元素后，集合都会更新，所以，若以固定索引添加元素时，每次都会以新集合
为出发点，这样我们连续以0为索引添加，就可以在集合的开头连续添加元素
*/
//4.遍历集合
System.out.println("更改元素前，数组如下：");
for (int i = 0; i < list.size(); ++i) {
System.out.println("索引：" + i + "元素：" + list.get(i));
}
System.out.println();
/*
利用set方法更改指定索引出的元素。
*/
list.set(0, 111);
list.set(1, 122);
list.set(2, 133);
list.set(3, st2);
list.set(4, st2);
System.out.println("更改元素后，数组如下：");
for (int i = 0; i < list.size(); ++i) {
System.out.println("索引：" + i + "元素：" + list.get(i));
}
}
}
输出结果⑩：
不想一个一个看代码，有一定基础的小伙伴儿们可以直接看这里，每个方法都演示到了。如下:
package knowledge.API.gather.list;
import java.util.ArrayList;
import java.util.List;//别忘了导包
/**
* 单链集合（Collection）之List集合：
* 1.特点
* 有序（元素的存取顺序一致）， 可重复
* 2.注意:
* List是接口，所以可以通过创建其子类ArrayList对象来完成该接口的实例化
* eg : List list = new ArrayList(); //(多态)
* 3.List接口中的常用成员方法：
* ①.public boolean add(E e) //将数据添加到集合的末尾，这里的E是泛型的意思，目前可以先理解为Object类
* ②.public void add(int index, E element) //将指定的元素添加到该集合指定的位置。
*
* ③.public E remove(int index) //将指定索引处的元素从该集合中删除
* ④.public boolean remove(Object o) //若该集合中存在该元素，则删除第一个指定的元素。
*
* ⑤.public E get(int index) //根据索引，获取其对应的元素
* ⑥.public int indexOf(Object o) //获取集合中第一个指定元素的索引，若集合中没有该元素，则返回-1.
* ⑦.public int size() //获取集合的长度
*
* ⑧.public boolean contains(Object o) //判断该集合中是否有指定的元素。
* ⑨.public boolean isEmpty() //判断集合是否为空。
*
* ⑩.public E set(int index, Object element); //可用来修改对应索引处的元素
* 4.使用集合的步骤：
* 创建集合对象
* 创建元素对象
* 将元素对象添加到集合对象中
* 遍历集合
*
*/
public class CodeSum {
public static void main(String[] args) {
//1.创建集合对象
List list = new ArrayList();
/* 测试方法⑩isEmpty()，判断此时集合是否为空 */
boolean bool1 = list.isEmpty();
System.out.println("集合此时为空吗：" + bool1);
System.out.println("---------------------------------");
//2.创建元素对象
Student student1 = new Student("Kyrie", 33);
Student student2 = new Student("Five", 22);
Student student3 = new Student("Ice", 44);
Student student4 = new Student("Cyan", 44);
Student student5 = new Student("Cyan", 19);
Student student6 = new Student("Cyan", 19);
//3.将元素对象添加到集合对象中
/* 测试方法①add(E e)和②add(int index, E element)，对集合添加元素 */
boolean b = list.add(student1); //添加Kyrie到list集合中
System.out.println("student1对象成功添加到集合list中了吗？" + b);
System.out.println("---------------------------------");
/* 对于方法①，实际开发中我们都会省略前面的booelan b = ，而是直接调用方法 */
list.add(student2); //添加Five到list集合中
list.add(student3); //添加Ice到list集合中
list.add(0, student4); //添加第一个Cyan（44岁）到list集合中
list.add(1, student5); //添加第二个Cyan（19岁）到list集合中
list.add(2, student6); //添加第三个Cyan（19岁）到list集合中
/* 测试一下list集合的可重复性 */
list.add(10);
list.add(10);
/*
本来student1，student2，student3，分别对应索引0，1，2
但我们此处可以调用方法②将student4 ，student5 和 student6分别插入到索引为0，1，2的位置，
这样，集合中的结果应该如下：
索引 -----> 对应元素
0 -----> Cyan, 44
1 -----> Cyan, 19
2 -----> Cyan, 19
3 -----> Kyrie, 33
4 -----> Five, 22
5 -----> Ice, 44
6 -----> 10
7 -----> 10
*/
//4.遍历集合
/* 测试方法⑤get(int index), 遍历一下集合 */
for (int i = 0; i < list.size(); ++i) {
System.out.println("list集合的第" + i + "个元素为：" + list.get(i));
}
System.out.println("---------------------------------");
/* 测试方法⑥indexOf(Object o) */
int index1 = list.indexOf(student4);
System.out.println("student4元素在集合list中的索引为：" + index1);
int index2 = list.indexOf(10);
System.out.println("10的第一个元素在集合list中的索引为：" + index2);
int index3 = list.indexOf(100);
System.out.println("如果没有100这个元素，请返回-1" + index3);
/* 测试方法⑦size() */
int length = list.size();
System.out.println("添加了六个学生对象元素后，集合目前的长度为" + length);
System.out.println("---------------------------------");
/* 测试方法⑧contains(Object) 和 再次测试方法⑨isEmpty() */
boolean b2 = list.isEmpty();
System.out.println("添加了六个学生对象元素后，集合目前还为空吗？" + b2);
System.out.println("---------------------------------");
boolean b3_1 = list.contains("Cyan");
System.out.println("集合list中有Cyan这个元素吗？" + b3_1);
boolean b3_2 = list.contains(student1);
System.out.println("集合list中有student1这个元素吗？" + b3_2);
boolean b3_3 = list.contains(22);
System.out.println("集合list中有22这个元素吗？" + b3_3);
System.out.println("---------------------------------");
/* 测试方法⑩set(int index, Object o) */
System.out.println("修改之前，list集合的索引为6的元素是:" + list.get(6));
list.set(6, 11);
System.out.println("修改之后，list集合的索引为6的元素是:" + list.get(6));
System.out.println("修改之前，list集合的索引为5的元素是:" + list.get(5));
list.set(5, student1);
System.out.println("修改之后，list集合的索引为5的元素是:" + list.get(5));
/* 测试方法③remove(int index) 和 方法④remove(Object o)*/
list.remove(list.size() - 1);
list.remove(student1);
System.out.println("看看删除最后一个元素和第一个元素后集合成什么样子了：");
for (int i = 0; i < list.size(); ++i) {
System.out.println(list.get(i));
}
System.out.println("---------------------------------");
}
}
输入结果如下gif图: 
链接如下 :
ArrayList主要内容包括 :
①ArrayList类简介
②ArrayLIst类的底层实现
③ArrayList类的源码解读
链接如下 :
Vector类主要内容包括 :
①Vector类简介
②Vector类的底层实现
③Vector类 VS ArrayLIst类
④Vector类的源码解读
链接如下 :
LinkedList类主要内容包括 :
①LinkedList类简介
②LinkedList类的底层实现
③LinkedList类 VS ArrayList类
④LinkedList类源码解读
https://blog.csdn.net/TYRA9/article/details/129478037