回忆一下我们的集合框架体系图。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.遍历集合

四、List接口的常用成员方法：

前言:直接看汇总也可以，含讲解。

1.常用十个成员方法及代码演示:

Δ准备工作1：

我们先创建一个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 +
                '}';
    }
}

Δ准备工作2：

up在Student类的同一包下创建LIstTest类作为演示类，来演示LIst接口的常用成员方法。

①.public boolean add(E e)

//将数据添加到集合的末尾，这里的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("--------------------------------------------");
    }
}

输出结果①：

②.public void add(int index, E element)

//将指定的元素添加到该集合指定的位置。

代码演示②：

为了更好地展示出方法②与方法①的区别，我们在方法①的基础上进行演示，如下：

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("--------------------------------------------");
    }
}

输出结果②：

③.public E remove(int index)

//将指定索引处的元素从该集合中删除

代码演示③：

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("--------------------------------------------");
    }
}

输出结果③:

④.public boolean remove(Object o)

//若该集合中存在该元素，则删除第一个指定的元素。

代码演示④：

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));
        }
    }
}

输出结果④：

⑤.public E get(int index)

//根据索引，获取其对应的元素。

代码演示⑤：

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);
        }
    }
}

输出结果⑤：

⑥.public int indexOf(Object 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...
    }
}

输出结果⑥：

⑦.public int size()

//获取集合的长度。

代码演示⑦：

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
    }
}

输出结果⑦：

⑧.public boolean contains(Object o)

//判断该集合中是否有指定的元素。

代码演示⑧：

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
    }
}

输出结果⑧：

⑨.public boolean isEmpty()

//判断集合是否为空。

代码演示⑨：

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
    }
}

输出结果⑨：

⑩.public E set(int index, Object element)

//可用来修改对应索引处的元素。

代码演示⑩：

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));
        }
    }
}

输出结果⑩：

2.代码汇总(含讲解，也可直接看这里):

不想一个一个看代码，有一定基础的小伙伴儿们可以直接看这里，每个方法都演示到了。如下:

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图

五、List接口实现类——ArrayList

链接如下 :

https://blog.csdn.net/TYRA9/article/details/129478037

ArrayList主要内容包括 :

①ArrayList类简介
②ArrayLIst类的底层实现
③ArrayList类的源码解读

六、List接口实现类——Vector

链接如下 :

https://blog.csdn.net/TYRA9/article/details/129522104

Vector类主要内容包括 :

①Vector类简介

②Vector类的底层实现

③Vector类 VS ArrayLIst类

④Vector类的源码解读

七、List接口实现类——LinkedList

链接如下 :

https://blog.csdn.net/TYRA9/article/details/129578222

LinkedList类主要内容包括 :

①LinkedList类简介

②LinkedList类的底层实现

③LinkedList类 VS ArrayList类

④LinkedList类源码解读

八、完结撒❀：

🆗，以上就是单列集合List接口的全部内容了。单列集合Collection接口除了List外，还有一个Set接口，因此接下里up将会开始Set接口系列的博文讲解。不过在将Set接口之前，建议大家先去看看up写得"增强for和迭代器万字详解"一文，如果学过的可以不看。好的，我们Set接口不见不散😆。感谢阅读！

System.out.println("END-------------------------------------------------------------------");

点赞
收藏
关注作者

0/1000

抱歉，系统识别当前为高风险访问，暂不支持该操作

全部回复

上滑加载中

设置昵称

在此一键设置昵称，即可参与社区互动！

*长度不超过10个汉字或20个英文字符，设置后3个月内不可修改。

确认取消

加入云驻计划，成为创作者

华为云周边好礼
免费体验产品
特殊身份标识
线下官方门票
内部专家零距离
与10000+优质创作者共同成长

立即加入

java 单列集合List 万字详解（通俗易懂）

前言 :