最近博主一直被Java的各个容器的使用搞得很烦，每次都要去搜一下怎么使用，于是博主就想自己把所有的Java容器的用法总结起来，写成博客，之后方便使用，也可以方便大家使用。
Java8新加的几个方法可以直接跳到后面编号21处。
这一章主要介绍List接口中的各个方法的使用，同时也会介绍Lsit在Java8中更新的几个方法的意思和以及如何使用。
1.List对象的创建
list是一个接口，其下有许多实现类，已知的实现类有：
AbstractList， AbstractSequentialList， ArrayList， AttributeList， CopyOnWriteArrayList， LinkedList， RoleList， RoleUnresolvedList， Stack， Vector
因此，List对象的创建时这样的，通常我们创建的是ArrayList的实现类对象：
List<> list = new ArrayList<>();而不是，以下是错误的创建
List<> list =new List(); //这是错误的，编译器会报错记住List是一个接口而不是一个类，至于我们该创建什么样的实现类，应该根据具体情况而定。比方说ArrayList适合用于查询较多的情况，而不适合用于增删较多的情况；而LinkedList适合用于增删较多的情况，而不适合用于查询较多的情况。
2.boolean add(E e);
这应该是最容易理解的，将数据加到list列表里，默认返回true；例：
List<Integer> numList = new ArrayList<>();
numList.add(1);
numList.add(2);
numList.add(3);
for (int i = 0; i < numList.size(); i++) {
System.out.println(numList.get(i));
}运行结果：
1 2 3
3.void add(int index, E element);
第二种添加，将数据插入到指定下标位置；例：
List<Integer> numList = new ArrayList<>();
numList.add(1);
numList.add(2);
numList.add(3);
numList.add(0,4);
for (int i = 0; i < numList.size(); i++) {
System.out.println(numList.get(i));
}运行结果：
4 1 2 3
3.boolean addAll(Collection<? extend E> c);
该方法可以将一个列表中的所有元素添加到另一个列表的末尾，默认返回true，若最后结果的list的大小为0，则返回false；例：
List<Integer> numList = new ArrayList<>();
numList.add(1);
numList.add(2);
numList.add(3);
List<Integer> numList2 = new ArrayList();
numList2.add(2);
numList2.add(3);
numList.addAll(numList2);
for (int i = 0; i < numList.size(); i++) {
System.out.println(numList.get(i));
}运行结果：
1 2 3 2 3
4.boolean addAll(int index, Collection<? extends E> c);
该方法比上一个方法多了一个index参数，代表插入的位置，index = 0 代表list的第一个数据；例
List<Integer> numList = new ArrayList<>();
numList.add(1);
numList.add(2);
numList.add(3);
List<Integer> numList2 = new ArrayList();
numList2.add(2);
numList2.add(3);
numList.addAll(0,numList2);//将列表插入到开头位置
for (int i = 0; i < numList.size(); i++) {
System.out.println(numList.get(i));
}运行结果：
2 3 1 2 3
5.int size();
从2的例子可以看出，这个方法主要返回list列表的大小，并返回int型，例
List<Integer> numList = new ArrayList<>();
numList.add(1);
numList.add(2);
numList.add(3);
System.out.println("size = " + numList.size());运行结果：
size = 3
5.E get(int index);
从2的例子可以看出，这个方法就是获得list列表中指定下标的数据的，例
List<Integer> numList = new ArrayList<>();
numList.add(1);
numList.add(2);
numList.add(3);
System.out.println("numList列表中下标为1的数据是" + numList.get(1));运行结果：
numList列表中下标为1的数据是2
6.boolean isEmpty();
这个方法主要判断list列表是否为空，若为空，则返回true，否则返回false；
List<Integer> numList = new ArrayList<>();
numList.add(1);//只添加一条数据测试一下
if (numList.isEmpty()) {
System.out.println("numList为空");
} else {
System.out.println("numList不为空");
}运行结果：
list不为空
7.boolean contains(Object o);
判断list中是否包含指定的对象，若有则返回true，没有则返回false；用上面的列表测一下
List<Integer> numList = new ArrayList<>();
numList.add(1);
numList.add(2);
if (numList.contains(2)) {
System.out.println("list包含2");
} else {
System.out.println("list不包含2");
}运行结果：
list包含2
8.boolean containsAll(Collection<?> c);
判断列表是否包含目标列表中所有的元素，下面以numList集合为例
List<Integer> numList = new ArrayList();
numList.add(1);
numList.add(2);
numList.add(3);
List<Integer> numList2 = new ArrayList();
numList2.add(2);
numList2.add(3);
if (numList.containsAll(numList2)) {
System.out.println("numList2被包含于numList列表");
} else {
System.out.println("numList2不被包含于numList列表");
}运行结果：
numList2被包含于numList列表
9.boolean remove(E e);
既然有添加，那肯定有移除啦，这是第一种remove的形式，根据指定对象值来移除，移除在列表中第一个出现的相同的对象，若列表中有该对象且移除成功，则返回true，否则返回false，例
List<Integer> numList = new ArrayList<>();
numList.add(1);
numList.add(1);
numList.add(2);
numList.add(3);
System.out.println("----移除前----");
for(int i = 0; i < numList.size(); i++) {
System.out.print(numList.get(i)+" ");
}
System.out.println();
numList.remove(new Integer(1));//移除列表中第一个值为指定对象的数据，若移除成功，则返回true
System.out.println("----移除后----");
for(int i = 0; i < numList.size(); i++) {
System.out.print(numList.get(i)+" ");
}运行结果：
----移除前----
1 1 2 3
----移除后----
1 2 3
10.E remove(int index);
这是第二种remove，根据下标值来remove，并返回移除对象的数据，例
List<Integer> numList = new ArrayList<>();
numList.add(1);
numList.add(2);
numList.add(3);
System.out.println("----移除前----");
for(int i = 0; i < numList.size(); i++) {
System.out.print(numList.get(i)+" ");
}
System.out.println();
int result = numList.remove(1);
System.out.println("----移除后----");
for(int i = 0; i < numList.size(); i++) {
System.out.print(numList.get(i)+" ");
}
System.out.println();
System.out.println("被移除的对象是： "+ result );运行结果：
----移除前----
1 2 3
----移除后----
1 3
被移除的对象是： 2
11.boolean removeAll(Collection<?> c);
这个方法时为了移除第一个列表中两个列表中共有的部分，例
List<Integer> numList = new ArrayList<>();
numList.add(1);
numList.add(2);
numList.add(3);
List<Integer> numList2 = new ArrayList<>();
numList2.add(2);
numList2.add(3);
numList2.add(4);
numList.removeAll(numList2);
for (int i = 0;i < numList.size(); i++) {
System.out.print(numList.get(i)+" ");
}运行结果：
1
12.boolean retainAll(Collection<?> c);
该方法与removeAll方法的效果相反，它是保留第一个列表中两个列表中共有的部分，例
List<Integer> numList = new ArrayList<>();
numList.add(1);
numList.add(2);
numList.add(3);
List<Integer> numList2 = new ArrayList<>();
numList2.add(2);
numList2.add(3);
numList2.add(4);
numList.retainAll(numList2);
for (int i = 0;i < numList.size(); i++) {
System.out.print(numList.get(i)+" ");
}运行结果：
2 3
13.boolean equals(Object o);
顾名思义，这个方法需要两个列表的大小和所有相应位置的元素都是相等的，才返回true，一点点不同，都返回false。例：
List<Integer> numList = new ArrayList<>();
numList.add(1);
numList.add(2);
numList.add(3);
List<Integer> numList2 = new ArrayList<>();
numList2.add(1);
numList2.add(2);
numList2.add(3);
if (numList.equals(numList2)) {
System.out.println("两个列表相等");
} else {
System.out.println("两个列表不等");
}运行结果：
两个列表相等
14.E set(int index, E element);
将指定下标的值替换成指定值，并返回原来下标的值
List<Integer> numList = new ArrayList<>();
numList.add(1);
numList.add(2);
numList.add(3);
Integer result = numList.set(0,2);
System.out.println("替换后的列表");
for (int i = 0; i < numList.size(); i++) {
System.out.println(numList.get(i));
}
System.out.println("被替换的值为： "+ result);运行结果：
替换后的列表
2 2 3
被替换的值为：1
15.int indexOf(Object o);
这个方法时为了返回列表第一次出现指定对象的下标的，例：
List<Integer> numList = new ArrayList<>();
numList.add(1);
numList.add(2);
numList.add(3);
numList.add(1);
int location = numList.indexOf(new Integer(1));
System.out.println("指定对象的下标是： " + location);运行结果：
指定对象的下标是： 0
16.int lastIndexOf(Object o);
这个方法时为了返回列表最后一次出现指定对象的下标的，例：
List<Integer> numList = new ArrayList<>();
numList.add(1);
numList.add(2);
numList.add(3);
numList.add(1);
int location = numList.lastIndexOf(new Integer(1));
System.out.println("指定对象的下标是： " + location);运行结果：
指定对象的下标是： 3
17.List<E> subList(int fromIndex, int toIndex);
这个方法用来截取列表，从fromIndex下标（包括）开始，到toIndex下标（不包括）位置，例
List<Integer> numList = new ArrayList<>();
numList.add(1);
numList.add(2);
numList.add(3);
numList.add(1);
numList = numList.subList(0,3);//截取的是下标0到下标2的数据
System.out.println("截取之后的列表为：");
for (int i = 0; i < numList.size(); i++) {
System.out.println(numList.get(i));
}运行结果：
截取之后的列表为：1 2 3
18.Object[] toArray();
按正确的顺序将任意类型列表转换成一个Object数组，例：
List<Integer> numList = new ArrayList<>();
numList.add(1);
numList.add(2);
numList.add(3);
Object[] numArray = numList.toArray();
for (int i = 0; i < numArray.length; i++) {
System.out.println(numArray[i]);
}运行结果：
1 2 3
19.<T> T[] toArray(T[] a);
这个方法可以根据用户喜好，转换成自己想要的类型数组，具体用法如下：
List<Integer> numList = new ArrayList<>();
numList.add(1);
numList.add(2);
numList.add(3);
Integer[] numArray = numList.toArray(new Integer[numList.size()]);
for (int i = 0; i < numArray.length; i++) {
System.out.println(numArray[i]);
}20.void clear();
该方法将清空list，直接调用就行
接下来是几个Java8出现的新方法，新方法如何使用，博主在网上查不到，因此自己研究了一下，接下来说一下新方法的使用。
21.default void replaceAll(UnaryOperator<E> operator) ;
该方法是传入一个操作函数，来对整个列表进行处理，博主暂时只发现该方法能在Integer型和String型列表中使用，至于自定义的pojo型列表，可能无法使用该方法。
想要详细了解该方法使用的同学，可以查看我另一篇博客：Java 关于List接口中的replaceAll() 方法
一个简单的例子：
List<Integer> numList = new ArrayList<>();
numList.add(1);
numList.add(2);
numList.add(3);
numList.replaceAll(x -> x + 1);
for (int i = 0; i < numList.size(); i++) {
System.out.println(numList.get(i));
}运行结果：
2 3 4
22.default void sort(Comparator<? super E> c);
该方法是通过传入一个自己定义的比较规则，来对列表中的所有元素进行一个排列
也可以在我的另一片博客里查看会更加详细：Java 关于List接口中sort()方法的使用
首先我们定义一个学生类，并在学生类中添加比较规则：
import java.util.Comparator;
public class UserPO {
private String name ;
private Integer 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;
}
//这里就是自定义的规则，根据年龄排列列表
public static class Comparators {
public static Comparator<UserPO> AGE = new Comparator<UserPO>() {
@Override
public int compare(UserPO o1, UserPO o2) {
return o1.age - o2.age;
}
};
}
}接下来，我们看一下如何调用这个规则：
UserPO userPO1 = new UserPO();
userPO1.setAge(31);
userPO1.setName("张三");
UserPO userPO2 = new UserPO();
userPO2.setAge(21);
userPO2.setName("李四");
UserPO userPO3 = new UserPO();
userPO3.setAge(43);
userPO3.setName("王五");
list.add(userPO1);
list.add(userPO2);
list.add(userPO3);
System.out.println("----------排列之前-------------");
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i).getName() + " " + list.get(i).getAge());
}
list.sort(UserPO.Comparators.AGE);
System.out.println("----------排列之后-------------");
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i).getName() + " " + list.get(i).getAge());
}运行结果：
----------排列之前-------------
张三 31
李四 21
王五 43
----------排列之后-------------
李四 21
张三 31
王五 43
最后，再来说一下list列表的遍历吧，一共有三种遍历
第一种，通过for循环遍历
List<Integer> numList = new ArrayList<>();
numList.add(1);
numList.add(2);
numList.add(3);
for (int i = 0; i < numList.size(); i++) {
System.out.println(numList.get(i));
}第二种，通过foreach遍历,这种遍历会比其他两个遍历的时间消耗多一些，因为每次都要赋值给it。
List<Integer> numList = new ArrayList<>();
numList.add(1);
numList.add(2);
numList.add(3);
for (Integer it : numList) {
System.out.println(it);
}第三种，通过声明迭代器遍历
List<Integer> numList = new ArrayList<>();
numList.add(1);
numList.add(2);
numList.add(3);
Iterator iterator = numList.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next());
}以上三种看个人喜好使用。
至此，Java中List接口里的各个方法的使用以及List的一些操作都已全部讲解完毕，内容有点多，所以可能会有地方打错的请及时帮忙指出，也感谢大家观看。
扫一扫
3517
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
