第二十一講 集合概述、ArrayList和LinkedList的應用

導讀

集合概述：暫時來說就可以理解爲可變的數組，但長遠來說，它就是對象類型數據的容器。（數據存儲區）

ArrayList：數組集合，使用方式跟數組有那麼一點相似，但可以自動增長容量。

LinkedList：鏈表集合，分爲單向鏈表與雙向鏈表。

HashSet：無序集合，它的元素是HashMap的key來維護的。

HashMap：鍵與值的對應，通過key來找到value。

一、集合概述

①、集合是一種數據容器。

②、集合默認存儲元素的類型是：Object。

③、集合是可以自動增長存儲空間的。

④、集合Collection是一個集合，延伸出很多實現類。

結構體系如圖：

collection接口主要定義了一些操作集合元素的方法：

二、ArrayList類是數組集合

概述：因爲它的存儲核心是連接的。一個接着一個地存儲起來，具有順序特性。有一個for循環的方法還能list.get(index)說明，可以按照下標來存儲我們的數據。

ArrayList的常用方法和解釋如下：

①、list.add("a"); 這個方法就是說將a這個元素，添加到list集合中。

②、在第N個數據後面添加一個數據：

list.add(1,"b"); // 第一個參數是位置，第二個參數是將要添加到集合中的元素。

③、將一個ArrayList中的所有數據添加到另外一個ArraList中

list1.addAll(list2); 

④、將一個ArrayList中的所有數據添加到另外一個ArraList中的第N個元素之後。

list1.addAll(2,list2); 

⑤、按照位置刪除單個數據

list.remove(2);

⑥、按照內容刪除單個數據

list.remove("d");

⑦、按照集合同時刪除多個數據

list.removeAll(list2);

⑧、清空ArrayList

list.clear();

⑨、修改指定位置的元素

list.set(2, "M");

⑩、獲取指定位置元素

String ele = list.get(2);

三、LinkedList集合概述與應用

概述：LinkedList類是雙向列表,列表中的每個節點都包含了對前一個和後一個元素的引用.。

應用如下——

①、添加一個元素到集合中：

link.add("a");

②、刪除一個元素從集合中：

link.remove(1);

link.remove("a");

③、獲取第一個和最後一個元素：

System.out.println("鏈表的第一個元素是 : " + litFirst());  

    System.out.println("鏈表最後一個元素是 : " + lnk.last());

⑤、遍歷一個鏈表集合（但前提是這個鏈表集合中的元素必須是字符串，否則編譯錯誤！）

for(String str: lList){  

   System.out.println(str);  

}  

3、從鏈表生成子表

List subl = lList.subList(1, 4);  

    System.out.println(subl);  

    lst.remove(2);  

    System.out.println(lst);  

    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()方法實現的效果一樣.

import java.util.LinkedList;    

public class LinkedListTest{  

  public static void main(String[] a) {  

    LinkedList list = new LinkedList();  

    list.add("A");  

    list.add("B");  

    list.add("C");  

    list.add("D");  

    list.addFirst("X");  

    list.addLast("Z");  

    System.out.println(list);  

  }  

}  

5、刪除元素

public Object removeFirst()  

public Object removeLast()  

import java.util.LinkedList;    

public class MainClass {  

  public static void main(String[] a) {  

    LinkedList list = new LinkedList();  

    list.add("A");  

    list.add("B");  

    list.add("C");  

    list.add("D");  

    list.removeFirst();  

    list.removeLast();  

    System.out.println(list);  

  }  

}  

6、使用鏈表實現棧效果

import java.util.LinkedList;  

public class MainClass {  

  public static void main(String[] args) {  

    StackL stack = new StackL();  

    for (int i = 0; i < 10; i++)  

      stack.push(i);  

    System.out.println(stack.top());  

    System.out.println(stack.top());  

    System.out.println(stack.pop());  

    System.out.println(stack.pop());  

    System.out.println(stack.pop());  

  }  

}  

class StackL {  

  private LinkedList list = new LinkedList();  

  public void push(Object v) {  

    list.addFirst(v);  

  }  

  public Object top() {  

    return list.getFirst();  

  }  

  public Object pop() {  

    return list.removeFirst();  

  }  

}  

7、使用鏈表來實現隊列效果

import java.util.LinkedList;  

public class MainClass {  

  public static void main(String[] args) {  

    Queue queue = new Queue();  

    for (int i = 0; i < 10; i++)  

      queue.put(Integer.toString(i));  

    while (!queue.isEmpty())  

      System.out.println(queue.get());  

  }  

}  

class Queue {  

  private LinkedList list = new LinkedList();  

  public void put(Object v) {  

    list.addFirst(v);  

  }  

  public Object get() {  

    return list.removeLast();  

  }  

  public boolean isEmpty() {  

    return list.isEmpty();  

  }  

}  

8、將LinkedList轉換成ArrayList

ArrayList<String> arrayList = new ArrayList<String>(linkedList);  

    for (String s : arrayList) {  

      System.out.println("s = " + s);  

    }  

9、刪掉所有元素：清空LinkedList

    lList.clear();

10、刪除列表的首位元素

import java.util.LinkedList;  

public class Main {  

  public static void main(String[] args) {  

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

    lList.add("1");  

    lList.add("2");  

    lList.add("3");  

    lList.add("4");  

    lList.add("5");  

    System.out.println(lList);  

        //元素在刪除的時候，仍然可以獲取到元素  

    Object object = lList.removeFirst();  

    System.out.println(object + " has been removed");  

    System.out.println(lList);  

    object = lList.removeLast();  

    System.out.println(object + " has been removed");  

    System.out.println(lList);  

  }  

}  

11、根據範圍刪除列表元素

import java.util.LinkedList;  

public class Main {  

  public static void main(String[] args) {  

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

    lList.add("1");  

    lList.add("2");  

    lList.add("3");  

    lList.add("4");  

    lList.add("5");  

    System.out.println(lList);  

    lList.subList(2, 5).clear();  

    System.out.println(lList);  

  }  

}  

12、刪除鏈表的特定元素

import java.util.LinkedList;  

public class Main {  

  public static void main(String[] args) {  

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

    lList.add("1");  

    lList.add("2");  

    lList.add("3");  

    lList.add("4");  

    lList.add("5");  

    System.out.println(lList);  

    System.out.println(lList.remove("2"));//刪除元素值=2的元素  

    System.out.println(lList);  

    Object obj = lList.remove(2);  //刪除第二個元素  

    System.out.println(obj + " 已經從鏈表刪除");  

    System.out.println(lList);  

  }  

}  

13、將LinkedList轉換爲數組，數組長度爲0

import java.util.LinkedList;  

import java.util.List;  

public class Main {  

  public static void main(String[] args) {  

    List<String> theList = new LinkedList<String>();  

    theList.add("A");  

    theList.add("B");  

    theList.add("C");  

    theList.add("D");  

    String[] my = theList.toArray(new String[0]);  

    for (int i = 0; i < my.length; i++) {  

      System.out.println(my[i]);  

    }  

  }  

}  

14、將LinkedList轉換爲數組，數組長度爲鏈表長度

import java.util.LinkedList;  

import java.util.List;  

public class Main {  

  public static void main(String[] args) {  

    List<String> theList = new LinkedList<String>();  

    theList.add("A");  

    theList.add("B");  

    theList.add("C");  

    theList.add("D");  

    String[] my = theList.toArray(new String[theList.size()]);  

    for (int i = 0; i < my.length; i++) {  

      System.out.println(my[i]);  

    }  

  }  

}  

15、將LinkedList轉換成ArrayList

import java.util.ArrayList;  

import java.util.LinkedList;  

import java.util.List;  

public class Main {  

  public static void main(String[] args) {  

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

    myQueue.add("A");  

    myQueue.add("B");  

    myQueue.add("C");  

    myQueue.add("D");  

    List<String> myList = new ArrayList<String>(myQueue);  

    for (Object theFruit : myList)  

      System.out.println(theFruit);  

  }  

}  

16、實現棧

import java.util.Collections;  

import java.util.LinkedList;  

public class Main {  

  public static void main(String[] argv) throws Exception {  

    LinkedList stack = new LinkedList();  

    Object object = "";  

    stack.addFirst(object);  

    Object o = stack.getFirst();  

    stack = (LinkedList) Collections.synchronizedList(stack);  

  }  

}  

17、實現隊列

import java.util.LinkedList;  

public class Main {  

  public static void main(String[] argv) throws Exception {  

    LinkedList queue = new LinkedList();  

    Object object = "";  

    // Add to end of queue  

    queue.add(object);  

    // Get head of queue  

    Object o = queue.removeFirst();  

  }  

}  

18 、同步方法

import java.util.Collections;  

import java.util.LinkedList;  

public class Main {  

  public static void main(String[] argv) throws Exception {  

    LinkedList queue = new LinkedList();  

    Object object = "";  

    queue.add(object);  

    Object o = queue.removeFirst();  

    queue = (LinkedList) Collections.synchronizedList(queue);  

  }  

}  

19、查找元素位置

import java.util.LinkedList;  

public class Main {  

  public static void main(String[] args) {  

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

    lList.add("1");  

    lList.add("2");  

    lList.add("3");  

    lList.add("4");  

    lList.add("5");  

    lList.add("2");  

    System.out.println(lList.indexOf("2"));  

    System.out.println(lList.lastIndexOf("2"));  

  }  

}  

20、替換元素

import java.util.LinkedList;   

public class Main {  

  public static void main(String[] args) {  

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

    lList.add("1");  

    lList.add("2");  

    lList.add("3");  

    lList.add("4");  

    lList.add("5");  

    System.out.println(lList);  

    lList.set(3, "Replaced");//使用set方法替換元素，方法的第一個參數是元素索引，後一個是替換值  

    System.out.println(lList);  

  }  

}  

21、鏈表添加對象

import java.util.LinkedList;  

class Address {  

  private String name;  

  private String street;  

  private String city;  

  private String state;  

  private String code;  

  Address(String n, String s, String c, String st, String cd) {  

    name = n;  

    street = s;  

    city = c;  

    state = st;  

    code = cd;  

  }  

  public String toString() {  

    return name + " " + street + " " + city + " " + state + " " + code;  

  }  

}  

class MailList {  

  public static void main(String args[]) {  

    LinkedList<Address> ml = new LinkedList<Address>();  

    ml.add(new Address("A", "11 Ave", "U", "IL", "11111"));  

    ml.add(new Address("R", "11 Lane", "M", "IL", "22222"));  

    ml.add(new Address("T", "8 St", "C", "IL", "33333"));  

    for (Address element : ml)  

      System.out.println(element + "\n");  

  }  

}  

22、確認鏈表是否存在特定元素

import java.util.LinkedList;  

public class Main {  

  public static void main(String[] args) {  

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

    lList.add("1");  

    lList.add("2");  

    lList.add("3");  

    lList.add("4");  

    lList.add("5");  

    if (lList.contains("4")) {  

      System.out.println("LinkedList contains 4");  

    } else {  

      System.out.println("LinkedList does not contain 4");  

    }  

  }  

}  

23、根據鏈表元素生成對象數組

Object[] objArray = lList.toArray();  

for (Object obj: objArray) {  

   System.out.println(obj);  

}

鏈表多線程

import java.util.Collections;  

import java.util.LinkedList;  

import java.util.List;  

class PrepareProduction implements Runnable {  

  private final List<String> queue;  

  PrepareProduction(List<String> q) {  

    queue = q;  

  }  

  public void run() {  

    queue.add("1");  

    queue.add("done");  

  }  

}  

class DoProduction implements Runnable {  

  private final List<String> queue;  

  DoProduction(List<String> q) {  

    queue = q;  

  }  

  public void run() {  

    String value = queue.remove(0);  

    while (!value.equals("*")) {  

      System.out.println(value);  

      value = queue.remove(0);  

    }  

  }  

}  

public class Main {  

  public static void main(String[] args) throws Exception {  

    List q = Collections.synchronizedList(new LinkedList<String>());  

    Thread p1 = new Thread(new PrepareProduction(q));  

    Thread c1 = new Thread(new DoProduction(q));  

    p1.start();  

    c1.start();  

    p1.join();  

    c1.join();  

  }  

}

import java.util.ArrayList;  

import java.util.LinkedList;  

import java.util.List;  

import java.util.ListIterator;  

import java.util.NoSuchElementException;    

public class BasicPriorityLinkedList {    

  protected LinkedList[] linkedLists;  

  protected int priorities;  

  protected int size;   

  public BasicPriorityLinkedList(int priorities) {  

    this.priorities = priorities;  

    initDeques();  

  }  

  public void addFirst(Object obj, int priority) {  

    linkedLists[priority].addFirst(obj);  

    size++;  

  }  

  public void addLast(Object obj, int priority) {  

    linkedLists[priority].addLast(obj);  

    size++;  

  }  

  public Object removeFirst() {  

    Object obj = null;  

    for (int i = priorities - 1; i >= 0; i--) {  

      L4inkedList ll = linkedLists[i];  

      if (!ll.isEmpty()) {  

        obj = ll.removeFirst();  

        break;  

      }  

    }  

    if (obj != null) {  

      size--;  

    }  

    return obj;  

  }  

  public Object removeLast() {  

    Object obj = null;  

    for (int i = 0; i < priorities; i++) {  

      LinkedList ll = linkedLists[i];  

      if (!ll.isEmpty()) {  

        obj = ll.removeLast();  

      }  

      if (obj != null) {  

        break;  

      }  

    }  

    if (obj != null) {  

      size--;  

    }  

    return obj;  

  }   

  public Object peekFirst() {  

    Object obj = null;  

    for (int i = priorities - 1; i >= 0; i--) {  

      LinkedList ll = linkedLists[i];  

      if (!ll.isEmpty()) {  

        obj = ll.getFirst();  

      }  

      if (obj != null) {  

        break;  

      }  

    }  

    return obj;  

  }    

  public List getAll() {  

    List all = new ArrayList();  

    for (int i = priorities - 1; i >= 0; i--) {  

      LinkedList deque = linkedLists[i];  

      all.addAll(deque);  

    }  

    return all;  

  }   

  public void clear() {  

    initDeques();  

  }    

  public int size() {  

    return size;  

  }    

  public boolean isEmpty() {  

    return size == 0;  

  }   

  public ListIterator iterator() {  

    return new PriorityLinkedListIterator(linkedLists);  

  }    

  protected void initDeques() {  

    linkedLists = new LinkedList[priorities];  

    for (int i = 0; i < priorities; i++) {  

      linkedLists[i] = new LinkedList();  

    }  

    size = 0;  

  }   

  class PriorityLinkedListIterator implements ListIterator {  

    private LinkedList[] lists;  

    private int index;  

    private ListIterator currentIter;  

    PriorityLinkedListIterator(LinkedList[] lists) {  

      this.lists = lists;  

      index = lists.length - 1;  

      currentIter = lists[index].listIterator();  

    }    

    public void add(Object arg0) {  

      throw new UnsupportedOperationException();  

    }  

    public boolean hasNext() {  

      if (currentIter.hasNext()) {  

        return true;  

      }  

      while (index >= 0) {  

        if (index == 0 || currentIter.hasNext()) {  

          break;  

        }  

        index--;  

        currentIter = lists[index].listIterator();  

      }

      return currentIter.hasNext();  

    }  

    public boolean hasPrevious() {  

      throw new UnsupportedOperationException();  

    }   

    public Object next() {  

      if (!hasNext()) {  

        throw new NoSuchElementException();  

      }  

      return currentIter.next();  

    }    

    public int nextIndex() {  

      throw new UnsupportedOperationException();  

    }   

    public Object previous() {  

      throw new UnsupportedOperationException();  

    }  

    public int previousIndex() {  

      throw new UnsupportedOperationException();  

    }  

    public void remove() {  

      currentIter.remove();  

      size--;  

    }   

       public void set(Object obj) {  

      throw new UnsupportedOperationException();  

    }  

  }

}  

import java.util.ArrayList;  

import java.util.Collections;  

import java.util.LinkedList;  

import java.util.List;  

public class Lists {  

  private Lists() { }  

  public static <E> ArrayList<E> newArrayList() {  

    return new ArrayList<E>();  

  }  

  public static <E> ArrayList<E> newArrayListWithCapacity(int initialCapacity) {  

    return new ArrayList<E>(initialCapacity);  

  }  

  public static <E> ArrayList<E> newArrayList(E... elements) {  

    ArrayList<E> set = newArrayList();  

    Collections.addAll(set, elements);  

    return set;  

  }  

  public static <E> ArrayList<E> newArrayList(Iterable<? extends E> elements) {  

    ArrayList<E> list = newArrayList();  

    for(E e : elements) {  

      list.add(e);  

  }  

    return list;  

  }  

  public static <E> LinkedList<E> newLinkedList() {  

    return new LinkedList<E>();  

  }  

}