LinkedList类是双向列表,列表中的每个节点都包含了对前一个和后一个元素的引用.
LinkedList的构造函数如下
1. public LinkedList():  ——生成空的链表
2. public LinkedList(Collection col):  复制构造函数
1、获取链表的第一个和最后一个元素

  1. import java.util.LinkedList;
  2. public class LinkedListTest{
  3. public static void main(String[] args) {
  4. LinkedList<String> lList = new LinkedList<String>();
  5. lList.add("1");
  6. lList.add("2");
  7. lList.add("3");
  8. lList.add("4");
  9. lList.add("5");
  10. System.out.println("链表的第一个元素是 : " + lList.getFirst());
  11. System.out.println("链表最后一个元素是 : " + lList.getLast());
  12. }
  13. }

2、获取链表元素

  1. for (String str: lList) {
  2. System.out.println(str);
  3. }

3、从链表生成子表

  1. List subl = lList.subList(1, 4);
  2. System.out.println(subl);
  3. lst.remove(2);
  4. System.out.println(lst);
  5. System.out.println(lList);

4、添加元素：添加单个元素
 如果不指定索引的话，元素将被添加到链表的最后.
public boolean add(Object element)
public boolean add(int index, Object element)
也可以把链表当初栈或者队列来处理:
public boolean addFirst(Object element)
public boolean addLast(Object element)
addLast()方法和不带索引的add()方法实现的效果一样.

  1. import java.util.LinkedList;
  2. public class LinkedListTest{
  3. public static void main(String[] a) {
  4. LinkedList list = new LinkedList();
  5. list.add("A");
  6. list.add("B");
  7. list.add("C");
  8. list.add("D");
  9. list.addFirst("X");
  10. list.addLast("Z");
  11. System.out.println(list);
  12. }
  13. }

5、删除元素

  1. public Object removeFirst()
  2. public Object removeLast()
  3. import java.util.LinkedList;
  4. public class MainClass {
  5. public static void main(String[] a) {
  6. LinkedList list = new LinkedList();
  7. list.add("A");
  8. list.add("B");
  9. list.add("C");
  10. list.add("D");
  11. list.removeFirst();
  12. list.removeLast();
  13. System.out.println(list);
  14. }
  15. }

6、使用链表实现栈效果

  1. import java.util.LinkedList;
  2. public class MainClass {
  3. public static void main(String[] args) {
  4. StackL stack = new StackL();
  5. for (int i = 0; i < 10; i++)
  6. stack.push(i);
  7. System.out.println(stack.top());
  8. System.out.println(stack.top());
  9. System.out.println(stack.pop());
  10. System.out.println(stack.pop());
  11. System.out.println(stack.pop());
  12. }
  13. }
  14. class StackL {
  15. private LinkedList list = new LinkedList();
  16. public void push(Object v) {
  17. list.addFirst(v);
  18. }
  19. public Object top() {
  20. return list.getFirst();
  21. }
  22. public Object pop() {
  23. return list.removeFirst();
  24. }
  25. }

7、使用链表来实现队列效果

  1. import java.util.LinkedList;
  2. public class MainClass {
  3. public static void main(String[] args) {
  4. Queue queue = new Queue();
  5. for (int i = 0; i < 10; i++)
  6. queue.put(Integer.toString(i));
  7. while (!queue.isEmpty())
  8. System.out.println(queue.get());
  9. }
  10. }
  11. class Queue {
  12. private LinkedList list = new LinkedList();
  13. public void put(Object v) {
  14. list.addFirst(v);
  15. }
  16. public Object get() {
  17. return list.removeLast();
  18. }
  19. public boolean isEmpty() {
  20. return list.isEmpty();
  21. }
  22. }

8、将LinkedList转换成ArrayList

  1. ArrayList<String> arrayList = new ArrayList<String>(linkedList);
  2. for (String s : arrayList) {
  3. System.out.println("s = " + s);
  4. }

9、删掉所有元素：清空LinkedList
    lList.clear();
10、删除列表的首位元素

  1. import java.util.LinkedList;
  2. public class Main {
  3. public static void main(String[] args) {
  4. LinkedList<String> lList = new LinkedList<String>();
  5. lList.add("1");
  6. lList.add("2");
  7. lList.add("3");
  8. lList.add("4");
  9. lList.add("5");
  10. System.out.println(lList);
  11. //元素在删除的时候，仍然可以获取到元素
  12. Object object = lList.removeFirst();
  13. System.out.println(object + " has been removed");
  14. System.out.println(lList);
  15. object = lList.removeLast();
  16. System.out.println(object + " has been removed");
  17. System.out.println(lList);
  18. }
  19. }

11、根据范围删除列表元素

  1. import java.util.LinkedList;
  2. public class Main {
  3. public static void main(String[] args) {
  4. LinkedList<String> lList = new LinkedList<String>();
  5. lList.add("1");
  6. lList.add("2");
  7. lList.add("3");
  8. lList.add("4");
  9. lList.add("5");
  10. System.out.println(lList);
  11. lList.subList(2, 5).clear();
  12. System.out.println(lList);
  13. }
  14. }

12、删除链表的特定元素

  1. import java.util.LinkedList;
  2. public class Main {
  3. public static void main(String[] args) {
  4. LinkedList<String> lList = new LinkedList<String>();
  5. lList.add("1");
  6. lList.add("2");
  7. lList.add("3");
  8. lList.add("4");
  9. lList.add("5");
  10. System.out.println(lList);
  11. System.out.println(lList.remove("2"));//删除元素值=2的元素
  12. System.out.println(lList);
  13. Object obj = lList.remove(2);  //删除第二个元素
  14. System.out.println(obj + " 已经从链表删除");
  15. System.out.println(lList);
  16. }
  17. }

13、将LinkedList转换为数组，数组长度为0

  1. import java.util.LinkedList;
  2. import java.util.List;
  3. public class Main {
  4. public static void main(String[] args) {
  5. List<String> theList = new LinkedList<String>();
  6. theList.add("A");
  7. theList.add("B");
  8. theList.add("C");
  9. theList.add("D");
  10. String[] my = theList.toArray(new String[0]);
  11. for (int i = 0; i < my.length; i++) {
  12. System.out.println(my[i]);
  13. }
  14. }
  15. }

14、将LinkedList转换为数组，数组长度为链表长度

  1. import java.util.LinkedList;
  2. import java.util.List;
  3. public class Main {
  4. public static void main(String[] args) {
  5. List<String> theList = new LinkedList<String>();
  6. theList.add("A");
  7. theList.add("B");
  8. theList.add("C");
  9. theList.add("D");
  10. String[] my = theList.toArray(new String[theList.size()]);
  11. for (int i = 0; i < my.length; i++) {
  12. System.out.println(my[i]);
  13. }
  14. }
  15. }

15、将LinkedList转换成ArrayList

  1. import java.util.ArrayList;
  2. import java.util.LinkedList;
  3. import java.util.List;
  4. public class Main {
  5. public static void main(String[] args) {
  6. LinkedList<String> myQueue = new LinkedList<String>();
  7. myQueue.add("A");
  8. myQueue.add("B");
  9. myQueue.add("C");
  10. myQueue.add("D");
  11. List<String> myList = new ArrayList<String>(myQueue);
  12. for (Object theFruit : myList)
  13. System.out.println(theFruit);
  14. }
  15. }

16、实现栈

  1. import java.util.Collections;
  2. import java.util.LinkedList;
  3. public class Main {
  4. public static void main(String[] argv) throws Exception {
  5. LinkedList stack = new LinkedList();
  6. Object object = "";
  7. stack.addFirst(object);
  8. Object o = stack.getFirst();
  9. stack = (LinkedList) Collections.synchronizedList(stack);
  10. }
  11. }

17、实现队列

  1. import java.util.LinkedList;
  2. public class Main {
  3. public static void main(String[] argv) throws Exception {
  4. LinkedList queue = new LinkedList();
  5. Object object = "";
  6. // Add to end of queue
  7. queue.add(object);
  8. // Get head of queue
  9. Object o = queue.removeFirst();
  10. }
  11. }

18 、同步方法

  1. import java.util.Collections;
  2. import java.util.LinkedList;
  3. public class Main {
  4. public static void main(String[] argv) throws Exception {
  5. LinkedList queue = new LinkedList();
  6. Object object = "";
  7. queue.add(object);
  8. Object o = queue.removeFirst();
  9. queue = (LinkedList) Collections.synchronizedList(queue);
  10. }
  11. }

19、查找元素位置

  1. import java.util.LinkedList;
  2. public class Main {
  3. public static void main(String[] args) {
  4. LinkedList<String> lList = new LinkedList<String>();
  5. lList.add("1");
  6. lList.add("2");
  7. lList.add("3");
  8. lList.add("4");
  9. lList.add("5");
  10. lList.add("2");
  11. System.out.println(lList.indexOf("2"));
  12. System.out.println(lList.lastIndexOf("2"));
  13. }
  14. }

20、替换元素

  1. import java.util.LinkedList;
  2. public class Main {
  3. public static void main(String[] args) {
  4. LinkedList<String> lList = new LinkedList<String>();
  5. lList.add("1");
  6. lList.add("2");
  7. lList.add("3");
  8. lList.add("4");
  9. lList.add("5");
  10. System.out.println(lList);
  11. lList.set(3, "Replaced");//使用set方法替换元素，方法的第一个参数是元素索引，后一个是替换值
  12. System.out.println(lList);
  13. }
  14. }

21、链表添加对象

  1. import java.util.LinkedList;
  2. class Address {
  3. private String name;
  4. private String street;
  5. private String city;
  6. private String state;
  7. private String code;
  8. Address(String n, String s, String c, String st, String cd) {
  9. name = n;
  10. street = s;
  11. city = c;
  12. state = st;
  13. code = cd;
  14. }
  15. public String toString() {
  16. return name + " " + street + " " + city + " " + state + " " + code;
  17. }
  18. }
  19. class MailList {
  20. public static void main(String args[]) {
  21. LinkedList<Address> ml = new LinkedList<Address>();
  22. ml.add(new Address("A", "11 Ave", "U", "IL", "11111"));
  23. ml.add(new Address("R", "11 Lane", "M", "IL", "22222"));
  24. ml.add(new Address("T", "8 St", "C", "IL", "33333"));
  25. for (Address element : ml)
  26. System.out.println(element + "\n");
  27. }
  28. }

22、确认链表是否存在特定元素

  1. import java.util.LinkedList;
  2. public class Main {
  3. public static void main(String[] args) {
  4. LinkedList<String> lList = new LinkedList<String>();
  5. lList.add("1");
  6. lList.add("2");
  7. lList.add("3");
  8. lList.add("4");
  9. lList.add("5");
  10. if (lList.contains("4")) {
  11. System.out.println("LinkedList contains 4");
  12. } else {
  13. System.out.println("LinkedList does not contain 4");
  14. }
  15. }
  16. }

23、根据链表元素生成对象数组

  1. Object[] objArray = lList.toArray();
  2. for (Object obj: objArray) {
  3. System.out.println(obj);
  4. }

24、链表多线程

  1. import java.util.Collections;
  2. import java.util.LinkedList;
  3. import java.util.List;
  4. class PrepareProduction implements Runnable {
  5. private final List<String> queue;
  6. PrepareProduction(List<String> q) {
  7. queue = q;
  8. }
  9. public void run() {
  10. queue.add("1");
  11. queue.add("done");
  12. }
  13. }
  14. class DoProduction implements Runnable {
  15. private final List<String> queue;
  16. DoProduction(List<String> q) {
  17. queue = q;
  18. }
  19. public void run() {
  20. String value = queue.remove(0);
  21. while (!value.equals("*")) {
  22. System.out.println(value);
  23. value = queue.remove(0);
  24. }
  25. }
  26. }
  27. public class Main {
  28. public static void main(String[] args) throws Exception {
  29. List q = Collections.synchronizedList(new LinkedList<String>());
  30. Thread p1 = new Thread(new PrepareProduction(q));
  31. Thread c1 = new Thread(new DoProduction(q));
  32. p1.start();
  33. c1.start();
  34. p1.join();
  35. c1.join();
  36. }
  37. }

25、优先级链表（来自JBOSS）

  1. import java.util.ArrayList;
  2. import java.util.LinkedList;
  3. import java.util.List;
  4. import java.util.ListIterator;
  5. import java.util.NoSuchElementException;
  6. public class BasicPriorityLinkedList {
  7. protected LinkedList[] linkedLists;
  8. protected int priorities;
  9. protected int size;
  10. public BasicPriorityLinkedList(int priorities) {
  11. this.priorities = priorities;
  12. initDeques();
  13. }
  14. public void addFirst(Object obj, int priority) {
  15. linkedLists[priority].addFirst(obj);
  16. size++;
  17. }
  18. public void addLast(Object obj, int priority) {
  19. linkedLists[priority].addLast(obj);
  20. size++;
  21. }
  22. public Object removeFirst() {
  23. Object obj = null;
  24. for (int i = priorities - 1; i >= 0; i--) {
  25. LinkedList ll = linkedLists[i];
  26. if (!ll.isEmpty()) {
  27. obj = ll.removeFirst();
  28. break;
  29. }
  30. }
  31. if (obj != null) {
  32. size--;
  33. }
  34. return obj;
  35. }
  36. public Object removeLast() {
  37. Object obj = null;
  38. for (int i = 0; i < priorities; i++) {
  39. LinkedList ll = linkedLists[i];
  40. if (!ll.isEmpty()) {
  41. obj = ll.removeLast();
  42. }
  43. if (obj != null) {
  44. break;
  45. }
  46. }
  47. if (obj != null) {
  48. size--;
  49. }
  50. return obj;
  51. }
  52. public Object peekFirst() {
  53. Object obj = null;
  54. for (int i = priorities - 1; i >= 0; i--) {
  55. LinkedList ll = linkedLists[i];
  56. if (!ll.isEmpty()) {
  57. obj = ll.getFirst();
  58. }
  59. if (obj != null) {
  60. break;
  61. }
  62. }
  63. return obj;
  64. }
  65. public List getAll() {
  66. List all = new ArrayList();
  67. for (int i = priorities - 1; i >= 0; i--) {
  68. LinkedList deque = linkedLists[i];
  69. all.addAll(deque);
  70. }
  71. return all;
  72. }
  73. public void clear() {
  74. initDeques();
  75. }
  76. public int size() {
  77. return size;
  78. }
  79. public boolean isEmpty() {
  80. return size == 0;
  81. }
  82. public ListIterator iterator() {
  83. return new PriorityLinkedListIterator(linkedLists);
  84. }
  85. protected void initDeques() {
  86. linkedLists = new LinkedList[priorities];
  87. for (int i = 0; i < priorities; i++) {
  88. linkedLists[i] = new LinkedList();
  89. }
  90. size = 0;
  91. }
  92. class PriorityLinkedListIterator implements ListIterator {
  93. private LinkedList[] lists;
  94. private int index;
  95. private ListIterator currentIter;
  96. PriorityLinkedListIterator(LinkedList[] lists) {
  97. this.lists = lists;
  98. index = lists.length - 1;
  99. currentIter = lists[index].listIterator();
  100. }
  101. public void add(Object arg0) {
  102. throw new UnsupportedOperationException();
  103. }
  104. public boolean hasNext() {
  105. if (currentIter.hasNext()) {
  106. return true;
  107. }
  108. while (index >= 0) {
  109. if (index == 0 || currentIter.hasNext()) {
  110. break;
  111. }
  112. index--;
  113. currentIter = lists[index].listIterator();
  114. }
  115. return currentIter.hasNext();
  116. }
  117. public boolean hasPrevious() {
  118. throw new UnsupportedOperationException();
  119. }
  120. public Object next() {
  121. if (!hasNext()) {
  122. throw new NoSuchElementException();
  123. }
  124. return currentIter.next();
  125. }
  126. public int nextIndex() {
  127. throw new UnsupportedOperationException();
  128. }
  129. public Object previous() {
  130. throw new UnsupportedOperationException();
  131. }
  132. public int previousIndex() {
  133. throw new UnsupportedOperationException();
  134. }
  135. public void remove() {
  136. currentIter.remove();
  137. size--;
  138. }
  139. public void set(Object obj) {
  140. throw new UnsupportedOperationException();
  141. }
  142. }
  143. }

26、生成list的帮助类（来自google）

    1. import java.util.ArrayList;
    2. import java.util.Collections;
    3. import java.util.LinkedList;
    4. import java.util.List;
    5. public class Lists {
    6. private Lists() { }
    7. public static <E> ArrayList<E> newArrayList() {
    8. return new ArrayList<E>();
    9. }
    10. public static <E> ArrayList<E> newArrayListWithCapacity(int initialCapacity) {
    11. return new ArrayList<E>(initialCapacity);
    12. }
    13. public static <E> ArrayList<E> newArrayList(E... elements) {
    14. ArrayList<E> set = newArrayList();
    15. Collections.addAll(set, elements);
    16. return set;
    17. }
    18. public static <E> ArrayList<E> newArrayList(Iterable<? extends E> elements) {
    19. ArrayList<E> list = newArrayList();
    20. for(E e : elements) {
    21. list.add(e);
    22. }
    23. return list;
    24. }
    25. public static <E> LinkedList<E> newLinkedList() {
    26. return new LinkedList<E>();
    27. }
    28. }

转： Java LinkedList基本用法的更多相关文章

  1. java LinkedList(链表)

    LinkedList也像ArrayList一样实现了基本的List接口,但是它执行某些操作(在List的中间插入和移除)时比ArrayList更高效,但在随机访问方面却要逊色一些 LinkedList ...

  2. java Arrays.asList用法

    java Arrays.asList用法 用途 Arrays是java容器相关操作的工具类,asList方法将Array转换为list,是Array和List之间的桥梁. 注意 Arrays.asLi ...

  3. JAVA的continue用法

    JAVA的continue用法: public class test{ public static void main(String [] args){  for(int i=0;i<=10;i ...

  4. Java Spring AOP用法

    Java Spring AOP用法 Spring AOP Java web 环境搭建 Java web 项目搭建 Java Spring IOC用法 spring提供了两个核心功能,一个是IoC(控制 ...

  5. Java Spring IOC用法

    Java Spring IOC用法 Spring IoC 在前两篇文章中,我们讲了java web环境搭建 和 java web项目搭建,现在看下spring ioc在java中的运用,开发工具为In ...

  6. 四种Java线程池用法解析

    本文为大家分析四种Java线程池用法,供大家参考,具体内容如下 http://www.jb51.net/article/81843.htm 1.new Thread的弊端 执行一个异步任务你还只是如下 ...

  7. JAVA中ArrayList用法

    JAVA中ArrayList用法 2011-07-20 15:02:03|  分类: 计算机专业 |  标签:java  arraylist用法  |举报|字号 订阅     Java学习过程中做题时 ...

  8. this在java中的用法

    this在java中的用法 1.使用this关键字引用成员变量 作用:解决成员变量与参数或局部变量命名冲突的问题 public class Dog { String name; public Dog( ...

  9. java assert的用法简介【转】

    assert的基本用法 assertion(断言)在软件开发中是一种常用的调试方式,很多开发语言中都支持这种机制,如C,C++和Eiffel等,但是支持的形式不尽相同,有的是通过语言本身.有的是通过库 ...

随机推荐

  1. C# MVC+EF—页面搭建

    上一篇文章搭建了基本结构,现在来搭建页面 一.新建控制器 Controllers=>添加=>控制器=>MVC 5控制器=>命名为DepartmentController pub ...

  2. 洛谷P1040 加分二叉树【记忆化搜索】

    题目链接:https://www.luogu.org/problemnew/show/P1040 题意: 某一个二叉树的中序遍历是1~n,每个节点有一个分数(正整数). 二叉树的分数是左子树分数乘右子 ...

  3. 阿里云容器服务与ASP.NET Core部署：用 docker secrets 保存 appsettings.Production.json

    这是我们使用阿里云容器服务基于 docker 容器部署 asp.net core 应用遇到的另一个问题 —— 如果将包含敏感信息的应用配置文件 appsettings.Production.json ...

  4. [No000011C]使人醒悟的生活中的定律

    1.     墨菲定律 我们在事前应该是尽可能想得周到.全面一些,如果真的发生不幸或者损失,就笑着应对吧,关键在于总结所犯的错误,而不是企图掩盖它. 2.     羊群效应 对他人的信息不可全信也不可 ...

  5. JSP+Servlet+JavaBean实现数据库的增删改查

    基本思想:JSP文件显示页面,使用form或href超链接传值到Servlet中方法,在Servlet方法中调用Dao层的类对象,实现对数据库里的数据的增删改查,之后重新返回到JSP输出操作完的结果. ...

  6. git bash 常用命令

    1.   cd : 切换到哪个目录下, 如 cd e:\fff  切换 E 盘下面的fff 目录. 当我们用cd 进入文件夹时,我们可以使用 通配符*, cd f*,  如果E盘下只有一个f开头的文件 ...

  7. nginx内置变量 大全

    nginx内置变量 内置变量存放在  ngx_http_core_module 模块中,变量的命名方式和apache 服务器变量是一致的.总而言之,这些变量代表着客户端请求头的内容,例如$http_u ...

  8. 最全最详细：ubuntu16.04下linux内核编译以及设备驱动程序的编写（针对新手而写）

    写在前面:本博客为本人原创,严禁任何形式的转载!本博客只允许放在博客园(.cnblogs.com),如果您在其他网站看到这篇博文,请通过下面这个唯一的合法链接转到原文! 本博客全网唯一合法URL:ht ...

  9. [dpdk] dpdk多线程任务调度

    DPDK下的线程,叫做EAL线程. EAL线程默认是与CPU core一对一绑定的,这样的话,有一些实时性,计算量不高的任务独占CORE是一种浪费,大概找了如下几种解决方案. 1. dpdk seri ...

  10. day3_元组

    元组与列表类似,不同之处在于元组的元素不能修改. 元组使用小括号,列表使用方括号. 元组创建很简单,只需要在括号中添加元素,并使用逗号隔开即可. 一.创建元组 1.普通创建 实例1: >> ...