集合大滿貫

概念很重要

集合：就是一個存儲數據的容器 下面這段話很重要，多讀幾遍好不
集合與數組一樣，也是一個容器，與數組不同的是，數組長度固定，集合的長度不定，可以無限的向集合中添加元素，而且集合中存儲的元素類型只能是引用類型，數組可以存儲基本類型和引用類型。
注意：
任何一種數據類型或者對象放進容器中後都會失去原有的類型，變成 Object，用的時候從容器中取出後進行轉型成所需的類型就可以了。
《Think in java》 中是這樣解釋的： 由於當初編寫集合時，那個集合的程序員根本不知道用戶到底想把什麼類型置入集合。若指示某個集合只允許特定的類型，會妨礙它成爲一個“常規用途”的工具，爲用戶帶來麻煩。爲解決這個問題，集合實際容納的是類型爲Object的一些對象的句柄。

集合的框架結構圖

Collection集合的框架結構圖
Map集合的框架結構圖

集合與數組的對比

相同點： 都是數據的容器，在一個數組或集合中可以存儲多個數據
不同點：元素：數組中的元素只能是相同，集合中的元素是任意的（泛型）
數組中可以存儲基本類型和引用類型，集合只能存儲引用類型 涉及基本類型的拆裝箱
長度(元素個數)：
數組是定長的，一旦初始化長度就不可以修改
集合長度可以修改，可以刪除元素和添加元素

Collection接口中常用的方法

add(E e)

確保此 collection 包含指定的元素（可選操作）。

addAll(Collection<? extends E> c)

將指定 collection 中的所有元素都添加到此 collection 中（可選操作）。

clear()

移除此 collection 中的所有元素（可選操作）。

contains(Object o)

如果此 collection 包含指定的元素，則返回true。

containsAll(Collection<?> c)

如果此 collection 包含指定 collection 中的所有元素，則返回 true。

equals(Object o)

比較此 collection 與指定對象是否相等。

isEmpty()

如果此 collection 不包含元素，則返回true。

iterator()

返回在此 collection 的元素上進行迭代的迭代器。

remove(Object o)

從此 collection 中移除指定元素的單個實例，如果存在的話（可選操作）。

removeAll(Collection<?> c)

移除此 collection 中那些也包含在指定 collection 中的所有元素（可選操作）。

retainAll(Collection<?> c)

僅保留此 collection 中那些也包含在指定 collection 的元素（可選操作）。

size()

返回此 collection 中的元素數。

toArray()

返回包含此 collection 中所有元素的數組。

上機練習

//1創建Collection對象
   	Collection collection=new ArrayList();
   	//2操作
   	//2.1添加
   	collection.add("張三");
   	collection.add("李四");
   	collection.add("王五");
   	System.out.println("集合的元素個數:"+collection.size());
   	//2.2刪除
   	//2.2.1刪除一個
   	collection.remove("張三");
   	System.out.println("刪除之後的數據個數:"+collection.size());
   	//2.2.2清空
   	collection.clear();
   	System.out.println("清空之後:"+collection.size());
   	
   	//3遍歷
   	//3.1 使用增強for//注意：集合中存儲的是Object類型
   	System.out.println("--------使用增強for遍歷----------");
   	for(Object obj:collection){
   		System.out.println(obj);
   	}
   	//3.2使用迭代器
   	System.out.println("-------使用迭代器---------");
   	Iterator it=collection.iterator();
   	while(it.hasNext()){
   		Object obj=it.next();
   		System.out.println(obj);
   	}
   	//4判斷（判斷依據equals）
   	//4.1判斷是否存在
   	boolean b=collection.contains("王五");
   	boolean b2=collection.contains("他老爺");
   	System.out.println(b);
   	System.out.println(b2);
   	//4.2判斷是否爲空
   	System.out.println(collection.isEmpty());
   	
   	//5其他方法
   	System.out.println("c1.equals(c2):"+c1.equals(c2));
   	System.out.println("c1==c2:"+(c1==c2));

   Collection collection=new ArrayList();
   	//1添加
   	collection.add(111);//111自動裝箱 new Integer(111)
   	collection.add("222");

iterator迭代器

hasNext()

判斷迭代器是否存在下一個元素可以迭代器

next()

迭代器迭代下一個元素

remove()

從迭代器指向的 collection 中移除迭代器返回的最後一個元素（可選操作）。

List接口的方法

add(int index, E element)

在列表的指定位置插入指定元素（可選操作）。

addAll(int index, Collection<? extends E> c)

將指定 collection 中的所有元素都插入到列表中的指定位置（可選操作）。

containsAll(Collection<?> c)

如果列表包含指定 collection 的所有元素，則返回true。

get(int index)

返回列表中指定位置的元素。

indexOf(Object o)

返回此列表中第一次出現的指定元素的索引；如果此列表不包含該元素，則返回 -1。

lastIndexOf(Object o)

返回此列表中最後出現的指定元素的索引；如果列表不包含此元素，則返回 -1。

listIterator()

返回此列表元素的列表迭代器（按適當順序）。

remove(int index)

移除列表中指定位置的元素（可選操作）。

set(int index, E element)

用指定元素替換列表中指定位置的元素（可選操作）。

subList(int fromIndex, int toIndex)

返回列表中指定的 fromIndex（包括 ）和 toIndex（不包括）之間的部分視圖。

List接口的存儲特點

相對有序存儲，可以存儲相同元素（不排重），可以通過下標訪問集合元素
List接口中可以使用獨有的迭代器ListIterator，具有反向遍歷的功能

List接口的實現類

ArrayList類

ArrayList類是List接口的大小可變數組的實現。實現了所有可選列表操作，並允許包括null在內的所有元素。
存儲特點：
相對有序存儲，可以存儲相同元素（不排重），可以通過下標訪問集合元素，通過數組實現的集合
存儲結構:數組

代碼實現

public class ArrayListDemo {
    public static void main(String[] args) {
      //創建一個ArrayList集合
      ArrayList<String> list = new ArrayList<>();//構造方法中的泛型可以省略
      list.add("zhangsan");//向集合中添加元素
      list.add("lisi");
      list.add("wangwu");
      System.out.println(list.isEmpty());//判斷list集合是否爲空集合
      System.out.println(list.size());//查看集合中元素的個數
      System.out.println(list.get(1));//獲取集合中下標爲1的元素
      System.out.println(list.set(1,"zhaoliu"));//修改集合中下標爲1的元素
      System.out.println(list.contains("wangwu"));//查看"wangwu"是否是集合中的元素
      list.remove("wangwu");//刪除集合中"wangwu"元素
      list.remove(1);//刪除集合中下標爲1的元素
      //for循環遍歷集合
      for(int i=0; i<list.size(); i++){
        System.out.println(list.get(i));
      }
      //使用Iterator迭代器遍歷
      Iterator<String> it = list.iterator();//獲取迭代器
      while(it.hasNext()){
        System.out.println(it.next());
      }
      //使用ListIterator迭代器遍歷
      ListIterator<String> lit = list.listIterator();
      while(lit.hasNext()){
        System.out.println(lit.next());
      }
      //反向遍歷
      while(lit.hasPrevious()){
        System.out.println(lit.previous());
      }
    }
 }

LinkedList類

LinkedList類是List接口的鏈接列表實現。實現所有可選的列表操作，並且允許所有元素（包括null）。
存儲特點：
相對有序存儲，可以存儲相同元素（不排重），可以通過下標訪問集合元素，通過鏈表實現的集合
存儲結構:雙向鏈表
LinkedList集合適用在對元素插入和刪除操作較頻繁的時候
ArrayList集合適用在對元素查詢、遍歷操作較頻繁的時候

Vector類

Vector類可以實現可增長的對象數組。與數組一樣，
它包含可以使用整數索引進行訪問的組件。
但是Vector的大小可以根據需要增大或縮小，
以適應創建 Vector後進行添加或移除項的操作。
特點:同步的:有序的，可以重複
面試：elements()  
Vector<String> vector=new Vector<String>();
vector.add("xxx");
vector.add("yyy");
System.out.println(vector.size());
System.out.println(vector);
//遍歷
//for
//foreach
//迭代器
//枚舉器
Enumeration<String> enumeration=vector.elements();
	while(enumeration.hasMoreElements()) {
		System.out.println(enumeration.nextElement());
}

Stack類

Stack類表示後進先出（LIFO）的對象棧。是Vector的子類。
//添加元素   入棧
Stack<String> stack=new Stack<String>();
stack.push("xxx");
//出棧
for(int i=0;i<1;i++){
   System.out.println(stack.pop());
}

ArrayList與LinkedList，Vector三種實現類存儲的比較

a.功能基本相同
b.底層存儲結構：ArrayList是數組，LinkedList是雙向鏈表，Vector是數組
c.Vector是一個古老的集合，從JDK1.0開始就有了，Vector存在一些方法名比較長的方法，xxxElement
d.Vector是線程安全的，效率低，ArrayList是線程不安全的，效率高，推薦使用ArrayList【Collections工具類中有相應的方法可以將ArrayList改爲線程安全的】
e.ArrayList查找遍歷比較快，LinkedList插入刪除比較快

下一篇文章講解Set Map Collections工具類。¹

---

1. 不然篇幅太長了 https://blog.csdn.net/l1996729/article/details/106638694 ↩︎