JDK-In-Action-LinkedList

LinkedList

Java集合框架的双向链表实现.
同时支持FIFO队列,双端队列.
非线程安全的集合.
迭代快速失败.

API Example

空构造链表

 LinkedList<Integer> linkedList = new LinkedList<>();
 assertEquals(linkedList, "[]");

空构造链表双端队列

 Deque<Integer> deque = new LinkedList<>();
 assertEquals(deque, "[]");

空构造链表队列

 Queue<Integer> queue = new LinkedList<>();
 assertEquals(queue, "[]");

链表操作

 printTableHeader("操作", "结果");

 LinkedList<Integer> linkedList = new LinkedList<>();
 printTable("初始空构造", linkedList);
 assertEquals(linkedList, "[]");


 //插入

 linkedList.add(1);
 printTable("插入单个节点1", linkedList);

 linkedList.add(5);
 printTable("插入单个节点5", linkedList);

 linkedList.addAll(Arrays.asList(10, 15));
 printTable("批量插入节点10,15", linkedList);

 linkedList.addFirst(0);
 printTable("头插入节点0", linkedList);

 linkedList.addLast(99);
 printTable("尾插入节点99", linkedList);

 linkedList.add(0, 3);
 printTable("索引0前插入节点3", linkedList);

 //查找

 Integer value = linkedList.get(1);
 printTable("获取索引值=1的节点", value);

 Integer first = linkedList.getFirst();
 printTable("获取头节点", first);

 Integer last = linkedList.getLast();
 printTable("获取尾节点", last);

 int index = linkedList.indexOf(10);
 printTable("查找值=10的节点索引", index);

 index = linkedList.lastIndexOf(10);
 printTable("从尾向头查找值=10的节点索引", index);

 boolean contains = linkedList.contains(99);
 printTable("是否包含值=99的节点", contains);


 //删除

 Integer remove = linkedList.remove(1);
 printTable("删除索引=1的节点:" + remove, linkedList);

 boolean succ = linkedList.remove(Integer.valueOf(1));
 printTable("查找并删除值=1的节点?" + succ, linkedList);

 remove = linkedList.removeFirst();
 printTable("删除头节点:" + remove, linkedList);

 remove = linkedList.removeLast();
 printTable("删除尾节点:" + remove, linkedList);

 succ = linkedList.removeAll(Arrays.asList(5, 15));
 printTable("删除指定集合的全部节点:" + succ, linkedList);

操作	结果
初始空构造	[]
插入单个节点1	[1]
插入单个节点5	[1, 5]
批量插入节点10,15	[1, 5, 10, 15]
头插入节点0	[0, 1, 5, 10, 15]
尾插入节点99	[0, 1, 5, 10, 15, 99]
索引0前插入节点3	[3, 0, 1, 5, 10, 15, 99]
获取索引值=1的节点	0
获取头节点	3
获取尾节点	99
查找值=10的节点索引	4
从尾向头查找值=10的节点索引	4
是否包含值=99的节点	true
删除索引=1的节点:0	[3, 1, 5, 10, 15, 99]
查找并删除值=1的节点?true	[3, 5, 10, 15, 99]
删除头节点:3	[5, 10, 15, 99]
删除尾节点:99	[5, 10, 15]
删除指定集合的全部节点:true	[10]

链表迭代

 LinkedList<String> linkedList = new LinkedList<>(Arrays.asList(
         " 钱塘湖春行",
         " 唐代/白居易",
         "孤山寺北贾亭西, 水面初平云脚低.",
         "几处早莺争暖树, 谁家新燕啄春泥.",
         "乱花渐欲迷人眼, 浅草才能没马蹄.",
         "最爱东湖行不足, 绿杨阴里白沙堤."
 ));
 linkedList.forEach(value -> println(value));

       钱塘湖春行
                  唐代/白居易
孤山寺北贾亭西, 水面初平云脚低.
几处早莺争暖树, 谁家新燕啄春泥.
乱花渐欲迷人眼, 浅草才能没马蹄.
最爱东湖行不足, 绿杨阴里白沙堤.

链表集合构造

 println("按照原集合的迭代顺序插入");
 LinkedList<Integer> listSrc = new LinkedList<>(Arrays.asList(1, 3, 5));
 assertEquals(listSrc, "[1, 3, 5]");

 LinkedList<Integer> linkedList = new LinkedList<>(listSrc);
 assertEquals(linkedList, "[1, 3, 5]");

 TreeSet<Integer> treeSetSrc = new TreeSet<>(Arrays.asList(5, 3, 1));
 linkedList = new LinkedList<>(treeSetSrc);
 assertEquals(linkedList, "[1, 3, 5]");

 LinkedHashSet<Integer> linkedHashSetSrc = new LinkedHashSet<>(Arrays.asList(1, 5, 3));
 linkedList = new LinkedList<>(linkedHashSetSrc);
 assertEquals(linkedList, "[1, 5, 3]");

按照原集合的迭代顺序插入

队列操作

 printTableHeader("操作", "结果");
 Queue<Integer> queue = new LinkedList<>(Arrays.asList(1, 3, 5));

 printTable("init queue", queue);

 boolean succ = queue.offer(7);
 printTable("offer 7 ? " + succ, queue);

 Integer top = queue.poll();
 printTable("poll : " + top, queue);

 Integer peek = queue.peek();
 printTable("peek : " + peek, queue);

操作	结果
init queue	[1, 3, 5]
offer 7 ? true	[1, 3, 5, 7]
poll : 1	[3, 5, 7]
peek : 3	[3, 5, 7]

双端队列操作

 printTableHeader("操作", "结果");
 Deque<Integer> deque = new LinkedList<>(Arrays.asList(1, 3, 5));

 printTable("init deque", deque);

 boolean succ = deque.offerFirst(7);
 printTable("入对首 7 ? " + succ, deque);

 succ = deque.offerLast(0);
 printTable("入对尾 0 ? " + succ, deque);

 Integer first = deque.pollFirst();
 printTable("出对首 : " + first, deque);

 Integer last = deque.pollLast();
 printTable("出对尾 : " + last, deque);

 first = deque.peekFirst();
 printTable("读对首 : " + first, deque);

 last = deque.peekLast();
 printTable("读对尾 : " + last, deque);

操作	结果
init deque	[1, 3, 5]
入对首 7 ? true	[7, 1, 3, 5]
入对尾 0 ? true	[7, 1, 3, 5, 0]
出对首 : 7	[1, 3, 5, 0]
出对尾 : 0	[1, 3, 5]
读对首 : 1	[1, 3, 5]
读对尾 : 5	[1, 3, 5]

引用

• 源码