學習目標：會存取，掌握特性
學習方式：學習頂層接口/抽象類的共性方法，使用底層的子類創建對象使用

1 集合框架

集合類的繼承體系：
Collection接口：
·············1) List接口：有序、允許重復、有索引
··························1.1) ArrayList集合【重點】
··························1.2) Vector集合【了解】
··························1.3) LinkedList集合【熟悉】
·············2) Set接口：不重復、無索引
··························2.1) TreeSet集合：無序（存取順序可能不一致）【了解】
··························2.2) HashSet集合：無序【重點】
·······································2.2.1) LinkedHashSet集合：無序【熟悉】

集合特點

List	有索引，可以存儲重復元素，可以保證存取順序
ArrayList	底層是數組實現的，查詢快，增刪慢
LinkedList	底層是鏈表實現的，查詢慢，增刪快
Set	無索引，不可以存儲重復元素，存取無序
HashSet	底層是哈希表+紅黑樹實現，無索引，不可以存重復元素，存取無序
LinkedHashSet	底層是哈希表+鏈表實現，無索引，不可以存重復元素，可以保證存取順序
TreeSet	底層是二叉樹實現，一般用于排序

2 Collection集合常用功能

Collection是單列結合最頂層的接口，定義了單列集合共性方法，任意單列集合都可以使用
java.util.Collection：1. add(e); 2. remove(e); 3. inEmpty(); 4. clear(); 5. contains(e); 6. toArray(); 7. size()

public static void main(String[] args) {Collection<String> coll = new ArrayList<>();//add添加元素coll.add("a");coll.add("b");coll.add("c");System.out.println(coll);//[a,b,c]//remove刪除元素boolean result = coll.remove("a");System.out.println(result);//刪除結果：trueSystem.out.println(coll);//[b,c]//clear清空集合coll.clear();System.out.println(coll);//contains是否包含coll.add("b");boolean result2 = coll.contains("a");System.out.println(result2);//flaseboolean result3 = coll.contains("b");System.out.println(result3);//true//isEmpty判斷集合是否為空System.out.println(coll.isEmpty());//false//size獲取集合長度System.out.println(coll.size());//1//toArray集合--->數組 遍歷集合元素Object[] arr = coll.toArray();for (int i = 0; i < arr.length; i++) {System.out.println(arr[i]);//打印Object對象 因為重寫了toString 所以顯示的是值而不是地址} }

3 Iterator迭代器

常用方法：1. hasNext()、2. next()
Iterator迭代器是一個接口，無法直接使用，需要使用Iterator接口的實現類對象
Collection中有一個iterator()方法，返回的是迭代器的實現類對象，list和set 通用，無需索引。
【重點】使用方式

使用iterator()方法獲取實現類對象，使用Iterator接口接收（多態）

使用hasNext判斷是否還有下一個

使用next取出下一個元素

實現原理：iterator()獲取迭代器的實現類對象，會把指針（索引）指向集合-1索引處。hasNext()判斷是否有下一個。next取出一個元素后，會把指針向后移動一位。

實現示例：

public static void main(String[] args) {Collection<String> coll = new ArrayList<>();coll.add("a");coll.add("b");coll.add("c");coll.add("d");coll.add("e");//迭代器有泛型 跟著集合走//多態 接口 實現類對象Iterator<String> it = coll.iterator();while(it.hasNext()){System.out.println(it.next());}} public static void main(String[] args) {Collection<String> coll = new ArrayList<>();coll.add("a");coll.add("b");coll.add("c");//迭代器有泛型 跟著集合走//多態 接口 實現類對象Iterator<String> it = coll.iterator();//常用while循環while(it.hasNext()){String e = it.next();System.out.println(e);}//一個迭代器只能取一次 再取要創建新的迭代器 否則會報NoSuchElement異常for( Iterator<String> it2 = coll.iterator();it2.hasNext();){String e = it2.next();System.out.println(e);}//foreach語句 增強for循環JDK1.5開始出現 //專門用來遍歷數組和結合 //底層使用的也是迭代器遍歷過程中只能遍歷不能增刪for(Object o : coll){System.out.println(o);}}

4 泛型的概念

概念
泛型是一種未知的數據類型，當不知道使用什么數據類型的時候可以使用泛型
泛型也可以看成是一個變量用來接收數據類型
ArrayList<E>，E表示未知類型，在創建集合對象時，確定泛型的數據類型
不使用泛型的好處：使用泛型，默認類型時Object類型，可以存儲任意類型的數據
不適用泛型的弊端：不安全，會引發異常

public static void main(String[] args) {Collection ArrayList = new ArrayList();//以Object類型存入任意類型的數據ArrayList.add("a");ArrayList.add(1);Iterator it = ArrayList.iterator();while(it.hasNext()){//取出也是Object類型System.out.println(it.next());//引發異常舉例：//想要使用String類特有的方法不能使用//多態：Object obj = "a"不能使用子類特有的方法//除非向下轉型(String)"a"Object o = it.next();//當o=1時，java.lang.ClassCastException:String s = (String) o;System.out.println(s.length());}}

使用泛型的好處：避免了類型轉換的麻煩，把運行期異常，提升到了編譯期（IDE會報錯）
使用泛型的弊端：只能存儲泛型定義的類型

5 泛型的定義和使用

5.1 定義和使用泛型類

泛型類

package Collection;public class GenericClass<E> {private E name;public E getName() {return name;}public void setName(E name) {this.name = name;} }

泛型測試類

package Collection;public class GenericClassTest {public static void main(String[] args) {GenericClass<String> gcs = new GenericClass<>();gcs.setName("張三");System.out.println(gcs.getName());GenericClass<Integer> gci = new GenericClass<>();gci.setName(1);System.out.println(gci.getName());} }

5.2 定義和使用泛型的方法

泛型定義在方法修飾符和返回值類型之間
在調用方法時確定泛型的數據類型，傳遞什么類型的參數，泛型就是什么類型

修飾符 <泛型> 返回值類型 方法名（參數表（使用泛型））

定義類和方法

public class GenericMethod {//成員方法public <M> void method(M m){System.out.println(m);}//靜態方法public static <M> void methodStatic(M m){System.out.println(m);} }

測試類調用

public class GenericMethodTest {public static void main(String[] args) {//創建對象GenericMethod gm = new GenericMethod();gm.method(10);gm.method("abc");gm.method(9.99);GenericMethod.methodStatic(5);GenericMethod.methodStatic("zxc");} }

5.3 定義和使用泛型接口

方法1：使用實現類，指定接口的泛型

定義接口：

public interface GenericInterface<I> {public abstract void method(I i); }

定義實現類：【指定泛型類型】

public class GenericInterfaceImpl implements GenericInterface<String> {@Overridepublic void method(String s) {System.out.println(s);} }

定義測試類：

public class GenericInterfaceTest {public static void main(String[] args) {GenericInterfaceImpl gi = new GenericInterfaceImpl();gi.method("abc");} }

方法2：接口使用什么泛型實現類就用什么泛型

定義接口

public interface GenericInterface<I> {public abstract void method(I i); }

定義實現類【不指定泛型類型】

public class GenericInplementImpl2<I> implements GenericInterface<I>{@Overridepublic void method(I i) {System.out.println(i);} }

定義測試類【創建對象時，指定泛型類型】

public class GenericInterfaceTest {public static void main(String[] args) {GenericInplementImpl2<Integer> gi2 = new GenericInplementImpl2<>();gi2.method(123);} }

5.3 泛型通配符

不知道使用什么類型來接收數據的時候，可以使用<?>表示未知通配符
此時只能接收數據，不能往集合中存儲數據
定義的時候不能用 只有參數傳遞的時候可以用

import java.util.ArrayList; import java.util.Iterator;public class Generic {//定義一個方法，可以遍歷有所ArrayList集合//不知道集合的數據類型，可以使用泛型來接受數據類型//注意！！泛型沒有繼承概念，所以不能用Object // 錯誤寫法： // public static void printArray(ArrayList<Object> list){ // // } // 正確寫法：public static void printArray(ArrayList<?> list){Iterator<?> it = list.iterator();while(it.hasNext()){//it.next()取出的時Object類型Object obj = it.next();System.out.print(obj + " ");}System.out.println();}public static void main(String[] args) {ArrayList<Integer> list1 = new ArrayList<>();list1.add(1);list1.add(2);ArrayList<String> list2 = new ArrayList<>();list2.add("a");list2.add("b");//？= IntegerprintArray(list1);//? = StringprintArray(list2);} }

泛型通配符的高級使用——受限泛型【看源碼的時候可能會用】
泛型的上限限定：? extends E 表示使用的泛型只能是E的子類/本身
泛型的下限限定：? super E 表示使用的泛型只能時E的父類/本身

import java.util.ArrayList; import java.util.Collection;public class GenericUpDown {//上限限定，？只能是子類/本身public static void getElementUp(Collection<? extends Number> coll){}//下限限定，？只能是父類/本身public static void getElementDown(Collection<? super Number> coll){}public static void main(String[] args) {// 繼承關系// int extends num extends obj// str extends objCollection<Integer> intList = new ArrayList<>();Collection<String> strList = new ArrayList<>();Collection<Number> numList = new ArrayList<>();Collection<Object> objList = new ArrayList<>();getElementUp(intList); // getElementDown(intList); // 報錯 int是num的子類// getElementUp(strList); // 報錯 str和num沒關系 // getElementDown(strList); // 報錯 str和num沒關系getElementUp(numList);getElementDown(numList); // getElementUp(objList); // 報錯 obj是num的父類getElementDown(objList);} }

案例：斗地主-1

package DouDiZhu;import java.util.ArrayList; import java.util.Collection; import java.util.Collections; import java.util.Iterator;public class DouDiZhu {public static void main(String[] args) {//1. 準備牌面ArrayList<String> all = new ArrayList<>();all.add("BK");all.add("SK");String[] colors = {"?","?","?","?"};String[] nums = {"A","K","Q","J","10","9","8","7","6","5","4","3","2"};for(String num: nums){for(String color: colors){all.add(color+num);}}//2. 洗牌Collections.shuffle(all);//打亂順序ArrayList<String> left = new ArrayList<>();ArrayList<String> p1 = new ArrayList<>();ArrayList<String> p2 = new ArrayList<>();ArrayList<String> p3 = new ArrayList<>();for (int i = 0; i < all.size(); i++) {String p = all.get(i);if(i>=51){left.add(p);}else{if(i%3 == 0){p1.add(p);}else if(i%3 == 1){p2.add(p);}else{p3.add(p);}}}//3. 看牌System.out.println(p1);System.out.println(p2);System.out.println(p3);System.out.println(left);} }

總結

以上是生活随笔為你收集整理的【Java】Collection集合和泛型的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。