Java基础-集合框架-Collection-List-LinkedList API及常用方法

LinkedList

LinkedList API

Modifier and Type	Method	Description
boolean	add(E e)	将指定的元素追加到此列表的末尾。
void	add(int index, E element)	在此列表中的指定位置插入指定的元素。
boolean	addAll(Collection<? extends E> c)	按照指定集合的迭代器返回的顺序将指定集合中的所有元素追加到此列表的末尾。
boolean	addAll(int index, Collection<? extends E> c)	将指定集合中的所有元素插入到此列表中，从指定的位置开始。
void	addFirst(E e)	在该列表开头插入指定的元素。
void	addLast(E e)	将指定的元素追加到此列表的末尾。
void	clear()	从列表中删除所有元素。
Object	clone()	返回此 LinkedList的浅版本。
boolean	contains(Object o)	如果此列表包含指定的元素，则返回 true 。
Iterator	descendingIterator()	以相反的顺序返回此deque中的元素的迭代器。
E	element()	检索但不删除此列表的头（第一个元素）。
E	get(int index)	返回此列表中指定位置的元素。
E	getFirst()	返回此列表中的第一个元素。
E	getLast()	返回此列表中的最后一个元素。
int	indexOf(Object o)	返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1。
int	lastIndexOf(Object o)	返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1。
ListIterator	listIterator(int index)	从列表中的指定位置开始，返回此列表中元素的列表迭代器（按适当的顺序）。
boolean	offer(E e)	将指定的元素添加为此列表的尾部（最后一个元素）。
boolean	offerFirst(E e)	在此列表的前面插入指定的元素。
boolean	offerLast(E e)	在该列表的末尾插入指定的元素。
E	peek()	检索但不删除此列表的头（第一个元素）。
E	peekFirst()	检索但不删除此列表的第一个元素，如果此列表为空，则返回 null 。
E	peekLast()	检索但不删除此列表的最后一个元素，如果此列表为空，则返回 null 。
E	poll()	检索并删除此列表的头（第一个元素）。
E	pollFirst()	检索并删除此列表的第一个元素，如果此列表为空，则返回 null 。
E	pollLast()	检索并删除此列表的最后一个元素，如果此列表为空，则返回 null 。
E	pop()	从此列表表示的堆栈中弹出一个元素。
void	push(E e)	将元素推送到由此列表表示的堆栈上。
E	remove()	检索并删除此列表的头（第一个元素）。
E	remove(int index)	删除该列表中指定位置的元素。
boolean	remove(Object o)	从列表中删除指定元素的第一个出现（如果存在）。
E	removeFirst()	从此列表中删除并返回第一个元素。
boolean	removeFirstOccurrence(Object o)	删除此列表中指定元素的第一个出现（从头到尾遍历列表时）。
E	removeLast()	从此列表中删除并返回最后一个元素。
boolean	removeLastOccurrence(Object o)	删除此列表中指定元素的最后一次出现（从头到尾遍历列表时）。
E	set(int index, E element)	用指定的元素替换此列表中指定位置的元素。
int	size()	返回此列表中的元素数。
Spliterator	spliterator()	在此列表中的元素上创建late-binding和故障快速 Spliterator 。
T[]	toArray(T[] a)	以正确的顺序返回一个包含此列表中所有元素的数组（从第一个到最后一个元素）; 返回的数组的运行时类型是指定数组的运行时类型

sample code

package com.sijing.reflect_demo;

import java.util.Iterator;
import java.util.LinkedList;
import java.util.ListIterator;

public class LinkedListDemo {

	@SuppressWarnings({ "unchecked", "unused" })
	public static void main(String[] args) {

		LinkedList<String> listStr = new LinkedList<String>();

		LinkedList<String> listNum = new LinkedList<String>();

		/**
		 * 列表尾部增加一个元素
		 */
		listStr.add("A");

		/**
		 * 指定位置增加一个元素
		 */
		listStr.add(0, "B");

		listNum.add("0");

		listNum.add("1");

		/**
		 * 列表尾部增加一个列表
		 */
		listStr.addAll(listNum);

		/**
		 * 指定位置增加一个列表
		 */
		listStr.addAll(0,listNum);

		/**
		 * 列表首部添加一个元素
		 */
		listStr.addFirst("First");

		/**
		 * 列表尾部添加一个元素
		 */
		listStr.addLast("Last");

		/**
		 * 清除列表所有元素
		 */
		listStr.clear();

		/**
		 * 浅克隆该列表
		 */
		LinkedList<String> cloneObject = (LinkedList<String>) listStr.clone();

		/**
		 * 判断列表是否包含指定元素
		 * 
		 * true 包含
		 * false 不包含
		 * 
		 */
		listStr.contains("A");

		/**
		 * 判断列表是否包含指定列表的所有元素
		 */
		listStr.containsAll(listNum);


		/**
		 * 返回此列表的第一个元素
		 */
		listStr.element();

		/**
		 * 判断两个列表是否相等
		 */
		listStr.equals(listNum);

		/**
		 * 遍历列表
		 */
		listStr.forEach(
				str -> {
					System.out.println(str);
				}
				);

		/**
		 * 返回指定下标的元素
		 */
		listStr.get(2);

		/**
		 * 返回列表第一个元素
		 */
		listStr.getFirst();

		/**
		 * 返回列表最后一个元素
		 */
		listStr.getLast();

		/**
		 * 返回指定元素在此列表中第一次出现的位置，不存在则返回-1
		 */
		listStr.indexOf("A");

		/**
		 * 返回指定元素在此列表中最后一次出现的位置，不存在则返回-1
		 */
		listStr.lastIndexOf("A");

		/**
		 * 判断该列表是否包含元素
		 */
		listStr.isEmpty();

		/**
		 * 正序返回该列表的迭代器
		 */
		Iterator<String> it = listStr.iterator();
		while(it.hasNext()) {
			String str = it.next();
			it.remove();
		}

		/**
		 * 反序返回该列表的迭代器
		 */
		Iterator<String> itDesc =listStr.descendingIterator();
		while(itDesc.hasNext()) {
			String str = itDesc.next();
			itDesc.remove();
		}

		/**
		 * 返回一个高级迭代器
		 */
		ListIterator<String> listIt =  listStr.listIterator();
		while(listIt.hasNext()) {
			System.out.println(listIt.next() + ", " + listIt.previousIndex() + ", " + listIt.nextIndex());
		}
		while(listIt.hasPrevious()) {
			System.out.print(listIt.previous() + " ");
		}

		/**
		 * 返回一个高级迭代器，从指定位置开始
		 */
		listStr.listIterator(1);


		/**
		 * 将指定的元素添加为此列表的尾部
		 */
		listStr.offer("offer");

		/**
		 * 在此列表的前面插入指定的元素
		 */
		listStr.offerFirst("offerFirst");

		/**
		 * 在该列表的末尾插入指定的元素
		 */
		listStr.offerLast("offerLast");

		/**
		 * 
		 */
		listStr.parallelStream();

		/**
		 * 返回该列表第一个元素
		 */
		listStr.peek();

		/**
		 * 返回列表的第一个元素，如果此列表为空，则返回 null 
		 */
		listStr.peekFirst();

		/**
		 * 返回列表的最后一个元素，如果此列表为空，则返回 null 
		 */
		listStr.peekLast();

		/**
		 * 弹出此列表第一个元素
		 */
		listStr.poll();

		/**
		 * 弹出此列表的第一个元素，如果此列表为空，则返回 null 。
		 */
		listStr.pollFirst();

		/**
		 * 弹出此列表的最后一个元素，如果此列表为空，则返回 null 。
		 */
		listStr.pollLast();

		/**
		 * 从此列表表示的堆栈中弹出一个元素
		 */
		listStr.pop();

		/**
		 * 向此列表表示的堆栈中装入一个元素
		 */
		listStr.push("PUSH");

		/**
		 * 删除列表第一个元素
		 */
		listStr.remove();

		/**
		 * 删除指定位置的元素
		 */
		listStr.remove(2);

		/**
		 * 删除指定元素
		 */
		listStr.remove("A");

		/**
		 * 删除另一个列表中包含的所有元素
		 */
		listStr.removeAll(listNum);

		/**
		 * 删除第一个元素
		 */
		listStr.removeFirst();

		/**
		 * 删除列表中第一个相同元素
		 */
		listStr.removeFirstOccurrence("A");

		/**
		 * 删除符格条件的元素
		 */
		listStr.removeIf(
				x -> x.equals("A")
				);

		/**
		 * 删除最后一个元素
		 */
		listStr.removeLast();

		/**
		 * 删除列表中最后一个相同元素
		 */
		listStr.removeLastOccurrence("C");

		/**
		 * 替换列表中的指定元素
		 */
		listStr.replaceAll(
				str -> {
					if(str.equals("A")) {
						return "a";
					}else {
						return "B";
					}
				}
				);

		/**
		 * 仅保留与参数列表中共同存在的元素
		 */
		listStr.retainAll(listNum);

		/**
		 * 替换指定位置的元素
		 */
		listStr.set(0, "A");

		/**
		 * 返回此列表的元素个数
		 */
		listStr.size();

		/**
		 * 对此列表进行排序
		 */
//		listStr.sort();

		/**
		 * Spliterator就是为了并行遍历元素而设计的一个迭代器，jdk1.8中的集合框架中的数据结构都默认实现了spliterator
		 */
		listStr.spliterator();


		/**
		 * 截取列表
		 */
		listStr.subList(1, 3);


		/**
		 * 列表转为数组
		 */
		String[] strAry = new String[listStr.size()];
		strAry = listStr.toArray(strAry);

	}

}