java集合框架(二)LinkedList常见方法的使用

一、什么是LinkedList

LinkedList是Java中的一个双向链表。

它实现了List和Deque接口，在使用时可以像List一样使用元素索引，也可以像Deque一样使用队列操作。

LinkedList每个节点都包含了前一个和后一个节点的引用，因此可以很方便地在其中进行节点的插入、删除和移动。

相比于ArrayList，LinkedList的插入和删除操作效率更高，但是访问元素时效率较低，因为需要遍历链表来寻找目标元素。

LinkedList的使用场景主要是场景是需要频繁执行插入和删除操作且对访问操作的效率要求较低的情况。例如队列、栈等数据结构的实现，或者是需要实现LRU缓存淘汰策略的场景。

使用场景

LinkedList是一种非常灵活的数据结构，可以适用于许多不同的场景。以下是一些常见的LinkedList使用场景：

1. 链表的插入和删除操作频繁：由于LinkedList的插入和删除操作的时间复杂度为O(1)，相比于数组的O(n)，在需要频繁进行插入和删除操作的场景中，LinkedList可以提供更高的性能。

2. 需要按照插入顺序访问数据：LinkedList中的数据都是按照插入的顺序进行排列的，因此可以很方便地按照插入顺序对数据进行访问。

3. 需要在数据中进行快速访问和搜索：虽然LinkedList的插入和删除操作效率高，但在进行查找操作时，需要从头开始遍历整个链表，时间复杂度为O(n)。所以在需要频繁进行查找操作的场景中，LinkedList的效率较低，不如数组或者其他高效的数据结构。

4. 需要动态分配内存：LinkedList的节点在内存中是分散存储的，需要使用指针进行连接。相比于数组，LinkedList可以动态地分配和释放节点，更加灵活。

5. 需要实现队列和栈：LinkedList可以很方便地实现队列和栈等数据结构。对于队列，可以使用LinkedList的尾部作为队尾，头部作为队首，实现先入先出的特性；对于栈，可以使用LinkedList的头部作为栈顶，实现后入先出的特性。

总的来说，LinkedList适用于需要频繁进行插入和删除操作，按照插入顺序访问数据，以及动态分配内存等场景。

二、常用的方法

返回类型	方法	描述
boolean	add(E o)	将指定元素追加到此列表的结尾。
void	add(int index, E element)	在此列表中指定的位置插入指定的元素。
boolean	addAll(Collection c)	追加指定 collection 中的所有元素到此列表的结尾，顺序是指定 collection 的迭代器返回这些元素的顺序。
boolean	addAll(int index, Collection c)	将指定集合中的所有元素从指定位置开始插入此列表。
void	addFirst(E o)	将指定元素插入此列表的开头。
void	addLast(E o)	将指定元素追加到此列表的结尾。
void	clear()	从此列表中移除所有元素。
boolean	contains(Object o)	如果此列表包含指定元素，则返回 true。
E	get(int index)	返回此列表中指定位置处的元素。
E	getFirst()	返回此列表的第一个元素。
E	getLast()	返回此列表的最后一个元素。
int	indexOf(Object o)	返回此列表中首次出现的指定元素的索引，如果列表中不包含此元素，则返回 -1。
int	lastIndexOf(Object o)	返回此列表中最后出现的指定元素的索引，如果列表中不包含此元素，则返回 -1。
ListIterator	listIterator(int index)	返回此列表中的元素的列表迭代器（按适当顺序），从列表中指定位置开始。
E	peek()	找到但不移除此列表的头（第一个元素）。
E	remove()	找到并移除此列表的头（第一个元素）。
E	remove(int index)	移除此列表中指定位置处的元素。
boolean	remove(Object o)	移除此列表中首次出现的指定元素。
E	removeFirst()	移除并返回此列表的第一个元素。
E	removeLast()	移除并返回此列表的最后一个元素。
E	set(int index, E element)	将此列表中指定位置的元素替换为指定的元素。
int	size()	返回此列表的元素数。

下面是一个示例代码：

add()
在链表的末尾添加元素。如果需要在指定位置添加元素，则可以使用add(index, element)方法。

代码演示：

LinkedList<String> list = new LinkedList<>();
list.add("apple");
list.add("banana");
list.add("orange");

System.out.println(list); // 结果:[apple, banana, orange]

remove()
在链表中删除指定元素。如果需要删除指定位置的元素，则可以使用remove(index)方法。

代码演示：

LinkedList<String> list = new LinkedList<>();
list.add("apple");
list.add("banana");
list.add("orange");

list.remove("banana");

System.out.println(list); // 结果:[apple, orange]

get()
获取指定位置的元素。

代码演示：

LinkedList<String> list = new LinkedList<>();
list.add("apple");
list.add("banana");
list.add("orange");

String second = list.get(1);

System.out.println(second); // 结果:banana

set()
替换指定位置的元素。

代码演示：

LinkedList<String> list = new LinkedList<>();
list.add("apple");
list.add("banana");
list.add("orange");

list.set(1, "grape");

System.out.println(list); // 结果:[apple, grape, orange]

clear()
清空链表中的所有元素。

代码演示：

LinkedList<String> list = new LinkedList<>();
list.add("apple");
list.add("banana");
list.add("orange");

list.clear();

System.out.println(list); // 结果:[]

size()
返回链表中的元素数量。

代码演示：

LinkedList<String> list = new LinkedList<>();
list.add("apple");
list.add("banana");
list.add("orange");

int size = list.size();

System.out.println(size); //结果:3

contains()
判断链表中是否包含指定元素。

代码演示：

LinkedList<String> list = new LinkedList<>();
list.add("apple");
list.add("banana");
list.add("orange");

boolean hasApple = list.contains("apple");

System.out.println(hasApple); //结果: true

addFirst()
在链表的头部插入元素。

代码演示：

LinkedList<String> list = new LinkedList<>();
list.add("apple");
list.add("banana");
list.add("orange");

list.addFirst("pear");

System.out.println(list); // 结果:[pear, apple, banana, orange]

addLast()
在链表的尾部插入元素。

代码演示：

LinkedList<String> list = new LinkedList<>();
list.add("apple");
list.add("banana");
list.add("orange");

list.addLast("pear");

System.out.println(list); // 结果:[apple, banana, orange, pear]

getFirst()
获取链表的第一个元素。

代码演示：

LinkedList<String> list = new LinkedList<>();
list.add("apple");
list.add("banana");
list.add("orange");

String first = list.getFirst();

System.out.println(first); // 结果:apple

getLast()
获取链表的最后一个元素。

代码演示：

LinkedList<String> list = new LinkedList<>();
list.add("apple");
list.add("banana");
list.add("orange");

String last = list.getLast();

System.out.println(last); // 结果:orange

removeFirst()
移除链表的第一个元素。

代码演示：

LinkedList<String> list = new LinkedList<>();
list.add("apple");
list.add("banana");
list.add("orange");

list.removeFirst();

System.out.println(list); // 结果:[banana, orange]

removeLast()
移除链表的最后一个元素。

代码演示：

LinkedList<String> list = new LinkedList<>();
list.add("apple");
list.add("banana");
list.add("orange");

list.removeLast();

System.out.println(list); // 结果:[apple, banana]

所有代码演示的,运行结果：

[apple, banana, orange]
[apple, orange]
banana
[apple, grape, orange]
[]
3
true
[pear, apple, banana, orange]
[apple, banana, orange, pear]
apple
orange
[banana, orange]
[apple, banana]

总结

LinkedList有以下几个好处：

1. 插入和删除操作高效：LinkedList的插入和删除操作的时间复杂度为O(1)，因为只需要修改节点的指针即可完成，无需像数组那样需要进行数据的搬移操作。因此，在需要频繁进行插入和删除操作的场景中，LinkedList具有较高的性能。

2. 能够动态分配内存：LinkedList的节点在内存中是分散存储的，每个节点都通过指针连接起来。这意味着，当需要新增或删除节点时，可以动态地分配或释放内存，更加灵活。

3. 灵活的数据结构：LinkedList可以根据实际需求灵活地进行扩展和调整。可以在任意位置插入新节点，也可以删除任意位置的节点。这使得LinkedList具有更高的灵活性，适用于各种不同的应用场景。

4. 不会出现存储容量不足的问题：与数组不同，LinkedList不会由于存储容量不足而导致插入失败。只要有足够的内存，就可以插入新节点。

5. 实现队列和栈等数据结构简单：由于LinkedList的高效插入和删除操作，它特别适用于实现队列和栈等数据结构。对于队列，可以使用LinkedList的尾部作为队尾，头部作为队首，实现先入先出的特性；对于栈，可以使用LinkedList的头部作为栈顶，实现后入先出的特性。

总的来说，LinkedList具有高效的插入和删除操作、动态分配内存、灵活性强等优点，适用于需要频繁进行插入和删除操作的场景，并且能够很方便地实现队列和栈等数据结构。