集合Collection——List接口List

109 阅读 0 评论 72 点赞

我是靠谱客的博主落后水杯，这篇文章主要介绍集合Collection——List接口List，现在分享给大家，希望可以做个参考。

本文介绍集合中的List其实现方式及相关操作，其常用的实现子类有ArrayList、LinkedList、Vector及其子类Stack。

接口List<E>

有序的 collection（也称为序列）。此接口的用户可以对列表中每个元素的插入位置进行精确地控制。用户可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素(支持角标访问)。

ArrayList

简介

List 接口的大小可变数组(动态数组)的实现。
实现了所有可选列表操作，并允许包括 null 在内的所有元素。
每个 ArrayList 实例都有一个容量。该容量是指用来存储列表元素的数组的大小。
它总是至少等于列表的大小。随着向 ArrayList 中不断添加元素，其容量也自动增长。
注意，此实现不是同步的。(线程不安全)
其他所有操作都以线性时间运行

常用方法

void add(int index, E element) 在指定角标index处添加元素element，开始最好从角标0添加元素并且角标最好连续的

boolean addAll(int index, Collection<? extends E> c) 在指定角标处添加一个指定的集合中所有的元素

E get(int index) 返回列表当中指定角标index处的元素

int indexOf(Object o) 返回指定元素从左到右第一次出现的角标

int lastIndexOf(Object o) 返回指定元素从右到左第一次出现的角标

E remove(int index) 删除指定角标处index的元素并返回该删除的元素

E set(int index, E element) 修改列表当中指定角标处index的元素为新元素element

List<E> subList(int fromIndex, int toIndex) 截取列表中[from,to)之间的元素并且返回List

方法使用示例

复制代码

public class ListDemo {
public static void main(String[] args) {
List<Integer> list1 = new ArrayList<Integer>();
List<Integer> list2 = new ArrayList<Integer>();
list1.add(0, 10);//类似于在列表头部添加元素
list1.add(1, 20);//类似于在列表尾部添加元素
list1.add(2, 30);//类似于在列表尾部添加元素
list1.add(3, 40);//类似于在列表尾部添加元素
list1.add(1, 50);//类似于插入的操作
list1.add(0, 60);//类似于在列表头部添加元素
list2.add(0,50);
list2.add(1,20);
list2.add(1,30);
System.out.println(list1);
System.out.println(list2);
list1.addAll(3,list2);//将集合list2的元素全部插入list1
System.out.println(list1);
System.out.println(list1.get(3));//获取角标为3的元素
System.out.println(list1.indexOf(50));//返回指定元素50第一次出现的角标
System.out.println(list1.remove(3));//删除指定位置3的元素
System.out.println(list1);
List<Integer> list3 = list1.subList(1, 4);//截取list1中的1~4角标处的元素为一个新的列表
System.out.println(list3);
System.out.println(list1);//截取后并不改变list1
list1.sort(new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
//o1 和 o2 是由前后关系的
//前 - 后 < 0 说明前者更靠前
//后 - 前 < 0 说明后者更靠前
//o1前 o2后
o1 - o2
//o2前 o1后
o2 - o1
return o2 - o1;
}
});
System.out.println(list1);
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
public class ListDemo {
public static void main(String[] args) {
List<Integer> list1 = new ArrayList<Integer>();
List<Integer> list2 = new ArrayList<Integer>();
list1.add(0, 10);//类似于在列表头部添加元素
list1.add(1, 20);//类似于在列表尾部添加元素
list1.add(2, 30);//类似于在列表尾部添加元素
list1.add(3, 40);//类似于在列表尾部添加元素
list1.add(1, 50);//类似于插入的操作
list1.add(0, 60);//类似于在列表头部添加元素
list2.add(0,50);
list2.add(1,20);
list2.add(1,30);
System.out.println(list1);
System.out.println(list2);
list1.addAll(3,list2);//将集合list2的元素全部插入list1
System.out.println(list1);
System.out.println(list1.get(3));//获取角标为3的元素
System.out.println(list1.indexOf(50));//返回指定元素50第一次出现的角标
System.out.println(list1.remove(3));//删除指定位置3的元素
System.out.println(list1);
List<Integer> list3 = list1.subList(1, 4);//截取list1中的1~4角标处的元素为一个新的列表
System.out.println(list3);
System.out.println(list1);//截取后并不改变list1
list1.sort(new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
//o1 和 o2 是由前后关系的
//前 - 后 < 0 说明前者更靠前
//后 - 前 < 0 说明后者更靠前
//o1前 o2后
o1 - o2
//o2前 o1后
o2 - o1
return o2 - o1;
}
});
System.out.println(list1);
}
}

LinkedList

简介

List 接口的链接列表实现。
除了实现了List的功能之外还实现了Queue(Deque)队列接口。

该实现子类可以当做列表、队列、栈、双端队列。

LinkedList本质上就是一个【双向循环链表】。

允许所有元素（包括 null）。

LinkedList 类还为在列表的开头及结尾 get、remove 和 insert 元素提供了统一的命名方法。

所有操作都是按照双重链接列表（双向循环链表）的需要执行的，在列表中编索引的操作将从开头或结尾遍历列表（从靠近指定索引的一端）。

注意，此实现不是同步的。(线程不安全)

常用方法

1.LinkedList当做双端队列去用(都是对头尾操作的)
void addFirst(E e) 将指定元素插入此列表的开头。
void addLast(E e) 将指定元素添加到此列表的结尾。
E removeFirst() 移除并返回此列表的第一个元素。
E removeLast() 移除并返回此列表的最后一个元素
E getFirst() 返回此列表的第一个元素。
E getLast() 返回此列表的最后一个元素。

boolean offerFirst(E e) 在此列表的开头插入指定的元素。
boolean offerLast(E e) 在此列表末尾插入指定的元素。
E pollFirst() 获取并移除此列表的第一个元素；如果此列表为空，则返回 null。
E pollLast() 获取并移除此列表的最后一个元素；如果此列表为空，则返回 null。
E peekFirst() 获取但不移除此列表的第一个元素；如果此列表为空，则返回 null。
E peekLast() 获取但不移除此列表的最后一个元素；如果此列表为空，则返回 null。

2.LinkedList用作队列
boolean offer(E e) 入队一个元素将指定元素添加到此列表的末尾（最后一个元素）。
E poll() 出队获取并移除此列表的头（第一个元素）
E element() 获取当前队列的头元素

3.LinkedList用作栈
void push(E e) 将元素推入此列表所表示的堆栈。
E pop() 从此列表所表示的堆栈处弹出一个元素。
E peek() 获取但不移除此列表的头（第一个元素）。

方法使用示例

复制代码

public class LinkedListDemo {
public static void main(String[] args) {
/*
如果LinkedList当做双端队列去看，操作主要在head和rear身上
在head的地方可以进行增删
在rear的地方可以进行增删
head ———————————————— rear
*/
LinkedList<Integer> deque = new LinkedList<Integer>();
deque.addFirst(1);	//1
deque.addFirst(2);	//2 1
deque.addLast(3);	//2 1 3
deque.addLast(4);	//2 1 3 4
System.out.println(deque); //[2, 1, 3, 4]
deque.removeFirst();//1,3,4
deque.removeLast();//1,3
System.out.println(deque);//[1,3]
System.out.println(deque.offerFirst(0));//true
System.out.println(deque.offerLast(4));//true
System.out.println(deque);//[0,1,3,4]
deque.pollFirst();//0
deque.pollLast();//4
System.out.println(deque);//[1,3]
System.out.println(deque.peekFirst());//1
System.out.println(deque.peekLast());//3
/*如果LinkedList当做队列去看，操作主要在head和rear身上
在head的地方只能进行出队
在rear的地方只能进行入队
head ———————————————— rear
*/
LinkedList<Integer> queue = new LinkedList<Integer>();
queue.offer(1);	//1
queue.offer(2);	//1 2
queue.offer(3);	//1 2 3
System.out.println(queue);//[1, 2, 3]
System.out.println(queue.poll());// 1
System.out.println(queue);//[2, 3]
System.out.println(queue.element());//2
/*
如果LinkedList当做栈去看，操作主要在head身上
在head的地方可以进行入栈和出栈
head ———————————————— rear
*/
LinkedList<Integer> stack = new LinkedList<Integer>();
stack.push(1);//1
stack.push(2);//2 1
stack.push(3);//3 2 1
System.out.println(stack);//[3, 2, 1]
System.out.println(stack.pop());
System.out.println(stack);//[2, 1]
System.out.println(stack.peek());//2
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
public class LinkedListDemo {
public static void main(String[] args) {
/*
如果LinkedList当做双端队列去看，操作主要在head和rear身上
在head的地方可以进行增删
在rear的地方可以进行增删
head ———————————————— rear
*/
LinkedList<Integer> deque = new LinkedList<Integer>();
deque.addFirst(1);	//1
deque.addFirst(2);	//2 1
deque.addLast(3);	//2 1 3
deque.addLast(4);	//2 1 3 4
System.out.println(deque); //[2, 1, 3, 4]
deque.removeFirst();//1,3,4
deque.removeLast();//1,3
System.out.println(deque);//[1,3]
System.out.println(deque.offerFirst(0));//true
System.out.println(deque.offerLast(4));//true
System.out.println(deque);//[0,1,3,4]
deque.pollFirst();//0
deque.pollLast();//4
System.out.println(deque);//[1,3]
System.out.println(deque.peekFirst());//1
System.out.println(deque.peekLast());//3
/*如果LinkedList当做队列去看，操作主要在head和rear身上
在head的地方只能进行出队
在rear的地方只能进行入队
head ———————————————— rear
*/
LinkedList<Integer> queue = new LinkedList<Integer>();
queue.offer(1);	//1
queue.offer(2);	//1 2
queue.offer(3);	//1 2 3
System.out.println(queue);//[1, 2, 3]
System.out.println(queue.poll());// 1
System.out.println(queue);//[2, 3]
System.out.println(queue.element());//2
/*
如果LinkedList当做栈去看，操作主要在head身上
在head的地方可以进行入栈和出栈
head ———————————————— rear
*/
LinkedList<Integer> stack = new LinkedList<Integer>();
stack.push(1);//1
stack.push(2);//2 1
stack.push(3);//3 2 1
System.out.println(stack);//[3, 2, 1]
System.out.println(stack.pop());
System.out.println(stack);//[2, 1]
System.out.println(stack.peek());//2
}
}

Vector

简介

Vector 类可以实现可增长的对象数组。

与数组一样，它包含可以使用整数索引进行访问的组件。

此实现是同步的。(线程安全)

一般被ArrayList替代，故不做详细介绍。

Stack

简介

是Vector的一个子类，表示的是栈。
一般而言被LinkedList替代。

常用方法

boolean empty() 测试堆栈是否为空。
E peek() 查看栈顶对象，但不移除。
E pop() 移除栈顶对象，并返回。
E push() 把项压入堆栈顶部。

方法使用示例

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
public class StackDemo {
public static void main(String[] args) {
Stack<Integer> stack = new Stack<Integer>();
stack.push(1);
stack.push(2);
stack.push(3);
stack.push(4);
System.out.println(stack);//[1,2,3,4]
System.out.println(stack.pop());//4
System.out.println(stack.peek());//3
System.out.println(stack);//[1,2,3]
}
}