LinkedList
LinkedList同样实现了List接口，它的特点正好与ArrayList相反，除了实现了List接口外，LinkedList还实现了Deque和Queue接口，可以按照队列、栈和双端队列的方式进行操作，底层是链表结构。特点是查询慢、增删快，允许插入元素为null。
API使用示例
add(E e)
@Test
public void addE() {
//add(E e)：将指定元素添加到此集合的结尾。
LinkedList<Object> linked = new LinkedList<>();
linked.add("this is a linked Collection"); //添加一条数据
linked.add("this is the second linked Collection"); //从尾部按顺序添加
System.out.println(linked);
}
add
@Test
public void add() {
//add(int index, E element)：在指定的索引位置插入指定的元素
LinkedList<Object> linked = new LinkedList<>();
linked.add("this is a linked");
linked.add(0,"linked collection"); //这条数据被插入到了最前面
System.out.println(linked);
}
addAll(有参)
@Test
public void addAllCoo() {
//addAll(有参)：根据Collection集合批量插入数据到集合的尾部
LinkedList<Object> linked = new LinkedList<>();
linked.add("this is a linked");
Collection<Object> collection = new LinkedList<>();
collection.add("this is a collection");
boolean addAll = linked.addAll(collection);//将collection集合参数放入方法中
System.out.println(addAll); //打印是否添加成功
System.out.println(linked);
}
addAll(有参)
@Test
public void addAllTwoArgs() {
//addAll(int index, Collection<? extends E> c：)
LinkedList<Object> linked = new LinkedList<>();
linked.add("linked");
//创建一个Collection集合
Collection<Object> collection = new LinkedList<>();
collection.add("collection");//添加一条数据
linked.addAll(0,collection); //把collection集合数据添加到linked集合的0号索引位置
System.out.println(linked);
}
clear
@Test
public void clear() {
//clear：清除集合所有元素
LinkedList<Object> linked = new LinkedList<>();
linked.add(123);
linked.add(321);
System.out.println(linked); //此时打印有值
linked.clear();
System.out.println(linked); //此时打印无值
}
listIterator(有参)
@Test
public void listIteratorArgs() {
//listIterator：返回一个带参数的集合迭代器接口，从列表指定位置开始
LinkedList<Object> linked = new LinkedList<>();
linked.add("listIterator--0");
linked.add("listIterator--1");
ListIterator<Object> listIterator = linked.listIterator(0); //指定位置为0号索引
while (listIterator.hasNext()) { //迭代器遍历集合数据
System.out.println(listIterator.next()); //只会打印0号索引值，因为上边指定了参数
}
}
listIterator
@Test
public void listIterator() {
//listIterator：返回一个集合迭代器
LinkedList<Object> linked = new LinkedList<>();
linked.add("hello");
linked.add("world");
ListIterator<Object> listIterator = linked.listIterator();
while (listIterator.hasNext()) { //使用迭代器方法遍历集合数据
System.out.print(listIterator.next());
}
}
size
@Test
public void size() {
//size：返回集合的长度
LinkedList<Object> linked = new LinkedList<>();
linked.add(1);
System.out.println(linked.size()); //只有一条数据，所以返回为1
}
spliterator
@Test
public void spliterator() {
//spliterator：用于分割和遍历集合
LinkedList<Object> linked = new LinkedList<>();
linked.add("this is spliterator method");
Spliterator<Object> spliterator = linked.spliterator();
spliterator.forEachRemaining(System.out::print); //遍历集合元素
}
addFirst
@Test
public void addFirst() {
//addFirst： 将指定元素插入此集合的头部。
LinkedList<Object> linked = new LinkedList<>();
linked.add("second");
linked.addFirst("First");
System.out.println(linked); //1号索引值会打印在最前边
}
addLast
@Test
public void addLast() {
//addLast：将指定元素添加到此集合的尾部。
LinkedList<Object> linked = new LinkedList<>();
linked.addLast("First");
linked.addLast("Second");
System.out.println(linked); //按照从尾部插入打印排序
}
Clone
@Test
public void Clone() {
//clone：克隆打印集合的数据
LinkedList<Object> linked = new LinkedList<>();
linked.add("clone method");
Object clone = linked.clone();
System.out.println(clone);
}
contains
@Test
public void contains() {
//contains：判断集合是否存在指定的元素
LinkedList<Object> linked = new LinkedList<>();
linked.add("not contains");
boolean contains = linked.contains("contains"); //不存在这个元素，打印为false
System.out.println(contains);
}
descendingIterator
@Test
public void descendingIterator() {
//descendingIterator：返回以逆向顺序在此双端队列的元素上进行迭代的迭代器。
LinkedList<Object> linked = new LinkedList<>();
linked.add(123); linked.add(321);
Iterator<Object> descendingIterator = linked.descendingIterator();
descendingIterator.forEachRemaining(System.out::println); //使用迭代器遍历集合元素
}
element
@Test
public void element() {
//获取但不移除此集合的第一个元素。
LinkedList<Object> linked = new LinkedList<>();
linked.add("element--1");
linked.add("element--2");
Object element = linked.element();
System.out.println(element); //只打印第一个元素
}
get
@Test
public void get() {
//get：根据参数获取指定位置的元素
LinkedList<Object> linked = new LinkedList<>();
linked.add("get method");
Object get = linked.get(0); //获取第0号索引值
System.out.println(get);
}
getFirst
@Test
public void getFirst() {
//getFirst：获取头部的元素
LinkedList<Object> linked = new LinkedList<>();
linked.add("First");
linked.add("Second");
Object first = linked.getFirst();
System.out.println(first); //只打印最前边的值
}
getLast
@Test
public void getLast() {
//getLast：获取集合尾部的值
LinkedList<Object> linked = new LinkedList<>();
linked.add("First");
linked.add("Last");
Object last = linked.getLast();
System.out.println(last); //只打印集合最尾部的值
}
indexOf
@Test
public void indexOf() {
//indexOf：返回此列表中首次出现的指定元素的索引
LinkedList<Object> linked = new LinkedList<>();
linked.add("indexOf--0");
linked.add("indexOf--1");
System.out.println(linked.indexOf("indexOf--0")); //打印为0号索引编号
}
lastIndexOf
@Test
public void lastIndexOf() {
//lastIndexOf:返回此列表中最后出现的指定元素的索引
LinkedList<Object> linked = new LinkedList<>();
linked.add("First");
linked.add("Last");
System.out.println(linked.lastIndexOf("Last")); //返回为1号索引编号
}
offer
@Test
public void offer() {
// 将指定元素添加到此集合的尾部
LinkedList<Object> linked = new LinkedList<>();
linked.add("hello");
linked.offer("world"); //添加一个字符串
System.out.println(linked);
}
offerFirst
@Test
public void offerFirst() {
//在此集合的头部插入指定的元素
LinkedList<Object> linked = new LinkedList<>();
linked.add("Last");
linked.offerFirst("offerFirst");
System.out.println(linked); //offerFirst显示在最前边
}
offerLast
@Test
public void offerLast() {
//在此集合的尾部插入指定的元素
LinkedList<Object> linked = new LinkedList<>();
linked.offerLast("offerLast");
System.out.println(linked);
}
peek
@Test
public void peek() {
//peek：获取此集合的头部数据
LinkedList<Object> linked = new LinkedList<>();
linked.add("peek");
linked.add("peek2");
Object peek = linked.peek();
System.out.println(peek); //打印获取最前边的数据
}
peekFirst
@Test
public void peekFirst() {
//peekFirst：获取头部的数据，如果没有则为null
LinkedList<Object> linked = new LinkedList<>();
linked.add("First");
linked.add("Last");
System.out.println(linked.peekFirst()); //显示最前边的值
}
peekLast
@Test
public void peekLast() {
//peekFirst：获取尾部的数据，如果没有则为null
LinkedList<Object> linked = new LinkedList<>();
linked.add("First");
linked.add("Last");
System.out.println(linked.peekLast()); //打印结果为Last，获取尾部的值
}
poll
@Test
public void poll() {
//poll：获取并移除此集合的头部值
LinkedList<Object> linked = new LinkedList<>();
linked.add("poll");
linked.add("linked");
System.out.println(linked.poll()); //获取并移除0号索引值
System.out.println(linked); //此时打印只有一个值
}
pollFirst
@Test
public void pollFirst() {
//pollFirst：获取并移除此集合的第一个元素；如果集合为空，则返回 null。
LinkedList<Object> linked = new LinkedList<>();
linked.add("pollFirst");
linked.add("poll");
System.out.println(linked.pollFirst()); //移除0号索引数据
}
pollLast
@Test
public void pollLast() {
//pollLast：获取并移除此集合的最后一个元素；如果集合为空，则返回 null。
LinkedList<Object> linked = new LinkedList<>();
linked.add("First");
linked.add("Last");
System.out.println(linked.pollLast()); //移除1号索引值并打印结果
}
pop
@Test
public void pop() {
//pop：从此集合获取第一个元素值，并删除
LinkedList<Object> linked = new LinkedList<>();
linked.add("pop-0");
linked.add("pop-1");
System.out.println(linked.pop());
System.out.println(linked);
}
push
@Test
public void push() {
//push：在集合头部添加一个元素
LinkedList<Object> linked = new LinkedList<>();
linked.add("pull");
linked.push("push");
System.out.println(linked); //push元素会在头部显示
}
remove
@Test
public void remove() {
//remove：移除集合所有元素,并打印移除的元素结果
LinkedList<Object> linked = new LinkedList<>();
linked.add("remove");
System.out.println(linked.remove());
}
remove(E e)
@Test
public void removeArg() {
//remove(E e)带参：从集合中移除首次出现的指定元素
LinkedList<Object> linked = new LinkedList<>();
linked.add("remove");
System.out.println(linked.remove("remove")); //移除remove字符串,打印为true
}
remove(int index)
@Test
public void removeInt() {
//remove(int index)：根据参数移除指定的集合元素
LinkedList<Object> linked = new LinkedList<>();
linked.add("remove(int index)");
System.out.println(linked.remove(0)); //根据整数移除第0号索引值
}
removeFirst
@Test
public void removeFirst() {
//removeFirst:移除并返回此集合的第一个元素。
LinkedList<Object> linked = new LinkedList<>();
linked.add("First");
linked.add("Second");
System.out.println(linked.removeFirst()); //移除了First字符串并打印结果
}
removeFirstOccurrence
@Test
public void removeFirstOccurrence() {
//removeFirstOccurrence:从此集合中移除第一次出现的指定元素（从头部到尾部遍历集合时
LinkedList<Object> linked = new LinkedList<>();
linked.add("removeFirstOccurrence");
linked.add("removeFirstOccurrence");
System.out.println(linked.removeFirstOccurrence("removeFirstOccurrence")); //根据指定字符移除数据
System.out.println(linked); //此时打印集合1号索引值仍然存在
}
set
@Test
public void set() {
//set： 将此集合中指定位置的元素替换为指定的元素。
LinkedList<Object> linked = new LinkedList<>();
linked.add("not set");
System.out.println(linked.set(0, "set"));//将0号元素替换为set字符
System.out.println(linked); //打印结果为set
}
toArray
@Test
public void toArray() {
//toArray：将集合转换为Object数组
LinkedList<Object> linked = new LinkedList<>();
linked.add("toArray");
linked.add("toArray");
Object[] toArray = linked.toArray();
for (Object o : toArray) {
System.out.println(o); //遍历数组内容
}
}
toArray(有参)
@Test
public void toArrayArg() {
//toArray：根据数组内容匹配集合参数,打印结果按照数组元素输出
LinkedList<Object> linked = new LinkedList<>();
linked.add(1);
Object[] toArray = linked.toArray(new Object[]{1, 2, 3});
for (Object o : toArray) {
System.out.println(o); //数组内的1号索引值打印会为null
}
}