介绍java的LinkedList类

Java的LinkedList类是Java中的一个经典数据结构实现，它提供了一种双向链表的结构，可以快速地添加、删除和获取元素。下面我们对其进行详细的介绍：

LinkedList的概述

LinkedList类是Java中的一个集合类，它实现了List接口，是一种双向链表的结构，每个元素包含前驱、后继以及存储的数据。LinkedList支持对元素进行添加、删除、获取、遍历等一系列操作。

LinkedList的主要特点包括：

• 使用双向链表实现，不需要移动元素即可进行插入和删除操作，因此在插入和删除操作上具有较高的效率。
• LinkedList支持随机访问，但效率较低，因为需要遍历整个链表来查找元素。
• 由于每个元素都需要存储前驱和后继指针，所以相对于ArrayList等使用数组实现的集合类，LinkedList的存储空间会较大。

LinkedList的构造方法

LinkedList类提供了多种构造方法，以便创建不同类型的链表。

无参构造方法

public LinkedList()

创建一个空的LinkedList对象。

拷贝构造方法

public LinkedList(Collection<? extends E> c)

将给定集合中的元素复制到新的LinkedList对象中。

其他构造方法

除了上述构造方法外，LinkedList还提供了一些其他的构造方法，例如：

• public LinkedList(int initialCapacity)：创建一个具有指定初始容量的LinkedList对象。
• public LinkedList(E[] array)：将指定数组中的元素复制到新的LinkedList对象中。
• public LinkedList(List<E> list)：将指定List中的元素复制到新的LinkedList对象中。

LinkedList的常用方法

下面列举了LinkedList类中常用的方法：

添加元素

public boolean add(E e)
public void add(int index, E element)
public boolean addAll(Collection<? extends E> c)
public boolean addAll(int index, Collection<? extends E> c)

add方法

add方法可以向链表中添加一个元素。例如：

LinkedList<Integer> list = new LinkedList<>();
list.add(1);
list.add(2);
list.add(3);

执行上述代码后，链表中的元素会变成[1, 2, 3]。

add(index, element)方法

add(index, element)方法可以向链表中指定的位置添加一个元素。例如：

LinkedList<Integer> list = new LinkedList<>();
list.add(0, 1);
list.add(1, 2);
list.add(1, 3);

执行上述代码后，链表中的元素会变成[1, 3, 2]。

addAll方法

addAll方法可以向链表中添加一组元素。例如：

LinkedList<Integer> list = new LinkedList<>();
list.addAll(Arrays.asList(1, 2, 3));

执行上述代码后，链表中的元素会变成[1, 2, 3]。

addAll(index, c)方法

addAll(index, c)方法可以向链表中指定的位置添加一组元素。例如：

LinkedList<Integer> list1 = new LinkedList<>();
list1.addAll(Arrays.asList(1, 2, 3));
LinkedList<Integer> list2 = new LinkedList<>();
list2.addAll(Arrays.asList(4, 5));
list1.addAll(1, list2);

执行上述代码后，链表中的元素会变成[1, 4, 5, 2, 3]。

删除元素

public void clear()
public E remove()
public E remove(int index)
public boolean remove(Object o)
public boolean removeAll(Collection<?> c)

clear方法

clear方法可以清空链表中的所有元素。例如：

LinkedList<Integer> list = new LinkedList<>();
list.addAll(Arrays.asList(1, 2, 3));
list.clear();

执行上述代码后，链表中的元素会变成[]。

remove方法

remove方法可以删除链表中的一个元素。例如：

LinkedList<Integer> list = new LinkedList<>();
list.addAll(Arrays.asList(1, 2, 3));
list.remove(0);

执行上述代码后，链表中的元素会变成[2, 3]。

remove(Object o)方法

remove(Object o)方法可以删除链表中指定的元素。例如：

LinkedList<Integer> list = new LinkedList<>();
list.addAll(Arrays.asList(1, 2, 3));
list.remove(Integer.valueOf(2));

执行上述代码后，链表中的元素会变成[1, 3]。

removeAll方法

removeAll方法可以删除链表中的一组元素。例如：

LinkedList<Integer> list1 = new LinkedList<>();
list1.addAll(Arrays.asList(1, 2, 3));
LinkedList<Integer> list2 = new LinkedList<>();
list2.addAll(Arrays.asList(2, 3));
list1.removeAll(list2);

执行上述代码后，链表中的元素会变成[1]。

获取元素

public E get(int index)
public E getFirst()
public E getLast()
public int indexOf(Object o)
public int lastIndexOf(Object o)

get方法

get方法可以获取链表中指定位置的元素。例如：

LinkedList<Integer> list = new LinkedList<>();
list.addAll(Arrays.asList(1, 2, 3));
System.out.println(list.get(0)); // 输出1

getFirst和getLast方法

getFirst和getLast方法可以分别获取链表中第一个和最后一个元素。例如：

LinkedList<Integer> list = new LinkedList<>();
list.addAll(Arrays.asList(1, 2, 3));
System.out.println(list.getFirst()); // 输出1
System.out.println(list.getLast()); // 输出3

indexOf和lastIndexOf方法

indexOf和lastIndexOf方法可以分别获取指定元素在链表中第一次出现和最后一次出现的位置。例如：

LinkedList<Integer> list = new LinkedList<>();
list.addAll(Arrays.asList(1, 2, 3, 2));
System.out.println(list.indexOf(2)); // 输出1
System.out.println(list.lastIndexOf(2)); // 输出3

遍历元素

LinkedList支持使用迭代器和foreach循环进行遍历。

迭代器遍历

LinkedList<Integer> list = new LinkedList<>();
list.addAll(Arrays.asList(1, 2, 3));
Iterator<Integer> it = list.iterator();
while (it.hasNext()) {
    System.out.println(it.next());
}

foreach循环遍历

LinkedList<Integer> list = new LinkedList<>();
list.addAll(Arrays.asList(1, 2, 3));
for (Integer i : list) {
    System.out.println(i);
}

总结

LinkedList是Java中的一个经典数据结构实现，它提供了一种双向链表的结构，可以快速地添加、删除和获取元素。LinkedList的主要特点包括使用双向链表实现、支持随机访问、存储空间较大等。LinkedList提供了多种构造方法和常用方法，例如add、remove、get、遍历等。在开发中，应根据具体需求选择合适的集合类，合理应用LinkedList可以提高程序的效率和可维护性。