zoukankan      html  css  js  c++  java
  • 转: Java LinkedList基本用法

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

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


    2、获取链表元素  

    [java] view plain copy
     
    1. for (String str: lList) {  
    2.       System.out.println(str);  
    3.     }  

    3、从链表生成子表

    [java] view plain copy
     
    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()方法实现的效果一样.

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

    5、删除元素

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

    6、使用链表实现栈效果

    [java] view plain copy
     
    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、使用链表来实现队列效果

    [java] view plain copy
     
    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

    [java] view plain copy
     
    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、删除列表的首位元素

    [java] view plain copy
     
    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、根据范围删除列表元素

    [java] view plain copy
     
    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、删除链表的特定元素

    [java] view plain copy
     
    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

    [java] view plain copy
     
    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转换为数组,数组长度为链表长度

    [java] view plain copy
     
    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

    [java] view plain copy
     
    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、实现栈

    [java] view plain copy
     
    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、实现队列

    [java] view plain copy
     
    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 、同步方法

    [java] view plain copy
     
    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、查找元素位置

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

    20、替换元素

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

    21、链表添加对象

    [java] view plain copy
     
    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.   
    20.   
    21. class MailList {  
    22.   public static void main(String args[]) {  
    23.     LinkedList<Address> ml = new LinkedList<Address>();  
    24.     ml.add(new Address("A", "11 Ave", "U", "IL", "11111"));  
    25.     ml.add(new Address("R", "11 Lane", "M", "IL", "22222"));  
    26.     ml.add(new Address("T", "8 St", "C", "IL", "33333"));  
    27.     for (Address element : ml)  
    28.       System.out.println(element + " ");  
    29.   }  
    30. }  

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

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

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

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

    24、链表多线程

    [java] view plain copy
     
    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)

    [java] view plain copy
     
    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.   
    7.   
    8. public class BasicPriorityLinkedList {  
    9.   
    10.   
    11.   protected LinkedList[] linkedLists;  
    12.   protected int priorities;  
    13.   protected int size;  
    14.   
    15.   
    16.   public BasicPriorityLinkedList(int priorities) {  
    17.     this.priorities = priorities;  
    18.     initDeques();  
    19.   }  
    20.   public void addFirst(Object obj, int priority) {  
    21.     linkedLists[priority].addFirst(obj);  
    22.     size++;  
    23.   }  
    24.   public void addLast(Object obj, int priority) {  
    25.     linkedLists[priority].addLast(obj);  
    26.     size++;  
    27.   }  
    28.   public Object removeFirst() {  
    29.     Object obj = null;  
    30.     for (int i = priorities - 1; i >= 0; i--) {  
    31.       LinkedList ll = linkedLists[i];  
    32.       if (!ll.isEmpty()) {  
    33.         obj = ll.removeFirst();  
    34.         break;  
    35.       }  
    36.     }  
    37.     if (obj != null) {  
    38.       size--;  
    39.     }  
    40.     return obj;  
    41.   }  
    42.   public Object removeLast() {  
    43.     Object obj = null;  
    44.     for (int i = 0; i < priorities; i++) {  
    45.       LinkedList ll = linkedLists[i];  
    46.       if (!ll.isEmpty()) {  
    47.         obj = ll.removeLast();  
    48.       }  
    49.       if (obj != null) {  
    50.         break;  
    51.       }  
    52.     }  
    53.     if (obj != null) {  
    54.       size--;  
    55.     }  
    56.     return obj;  
    57.   }  
    58.   
    59.   
    60.   public Object peekFirst() {  
    61.     Object obj = null;  
    62.     for (int i = priorities - 1; i >= 0; i--) {  
    63.       LinkedList ll = linkedLists[i];  
    64.       if (!ll.isEmpty()) {  
    65.         obj = ll.getFirst();  
    66.       }  
    67.       if (obj != null) {  
    68.         break;  
    69.       }  
    70.     }  
    71.     return obj;  
    72.   }  
    73.   
    74.   
    75.   public List getAll() {  
    76.     List all = new ArrayList();  
    77.     for (int i = priorities - 1; i >= 0; i--) {  
    78.       LinkedList deque = linkedLists[i];  
    79.       all.addAll(deque);  
    80.     }  
    81.     return all;  
    82.   }  
    83.   
    84.   
    85.   public void clear() {  
    86.     initDeques();  
    87.   }  
    88.   
    89.   
    90.   public int size() {  
    91.     return size;  
    92.   }  
    93.   
    94.   
    95.   public boolean isEmpty() {  
    96.     return size == 0;  
    97.   }  
    98.   
    99.   
    100.   public ListIterator iterator() {  
    101.     return new PriorityLinkedListIterator(linkedLists);  
    102.   }  
    103.   
    104.   
    105.   protected void initDeques() {  
    106.     linkedLists = new LinkedList[priorities];  
    107.     for (int i = 0; i < priorities; i++) {  
    108.       linkedLists[i] = new LinkedList();  
    109.     }  
    110.     size = 0;  
    111.   }  
    112.   
    113.   
    114.   class PriorityLinkedListIterator implements ListIterator {  
    115.     private LinkedList[] lists;  
    116.     private int index;  
    117.     private ListIterator currentIter;  
    118.     PriorityLinkedListIterator(LinkedList[] lists) {  
    119.       this.lists = lists;  
    120.       index = lists.length - 1;  
    121.       currentIter = lists[index].listIterator();  
    122.     }  
    123.   
    124.   
    125.     public void add(Object arg0) {  
    126.       throw new UnsupportedOperationException();  
    127.     }  
    128.   
    129.   
    130.     public boolean hasNext() {  
    131.       if (currentIter.hasNext()) {  
    132.         return true;  
    133.       }  
    134.       while (index >= 0) {  
    135.         if (index == 0 || currentIter.hasNext()) {  
    136.           break;  
    137.         }  
    138.         index--;  
    139.         currentIter = lists[index].listIterator();  
    140.       }  
    141.       return currentIter.hasNext();  
    142.     }  
    143.   
    144.   
    145.     public boolean hasPrevious() {  
    146.       throw new UnsupportedOperationException();  
    147.     }  
    148.   
    149.   
    150.     public Object next() {  
    151.       if (!hasNext()) {  
    152.         throw new NoSuchElementException();  
    153.       }  
    154.       return currentIter.next();  
    155.     }  
    156.   
    157.   
    158.     public int nextIndex() {  
    159.       throw new UnsupportedOperationException();  
    160.     }  
    161.   
    162.   
    163.     public Object previous() {  
    164.       throw new UnsupportedOperationException();  
    165.     }  
    166.   
    167.   
    168.     public int previousIndex() {  
    169.       throw new UnsupportedOperationException();  
    170.     }  
    171.   
    172.   
    173.     public void remove() {  
    174.       currentIter.remove();  
    175.       size--;  
    176.     }  
    177.   
    178.   
    179.     public void set(Object obj) {  
    180.       throw new UnsupportedOperationException();  
    181.     }  
    182.   }  
    183.   
    184.   
    185. }  

    26、生成list的帮助类(来自google)

    [java] view plain copy
     
      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. }  
      29.    
  • 相关阅读:
    7月15日考试 题解(链表+状压DP+思维题)
    暑假集训日记
    C# .NET 使用 NPOI 生成 .xlsx 格式 Excel
    JavaSE 基础 第42节 局部内部类
    JavaSE 基础 第41节 匿名内部类
    JavaSE 基础 第40节 内部类概述
    JavaSE 基础 第39节 接口的应用
    JavaSE 基础 第38节 接口的实现
    JavaSE 基础 第37节 接口概述
    JavaSE 基础 第36节 抽象类概述与使用
  • 原文地址:https://www.cnblogs.com/AryaZ/p/7591741.html
Copyright © 2011-2022 走看看