Java基礎 -- 11 Collection、泛型

Collection集合
集合的定義：集合是java提供的一種容器，可以用來存儲多個數據
集合和數組的區別：
1、數組的長度是固定的，集合的長度是可變的
2、數組存儲的數據類型都是基本類型，必須存儲是同一類型的元素。集合裏面存儲的是對象，而且對象的類型可以不一致，在對象多的時候可以使用集合存儲
集合分爲單列集合java.util.Collection和雙列集合java.util.Map
Collection：單列集合的根接口，它有兩個重要的子接口，java.util.List和java.util.Set。
List：元素有序，可重複，元素有索引值，主要實現類有java.util.ArrayList和java.util.LinkedList
Set：元素無序，不可重複，元素沒有索引值，主要實現類有java.util.HashSet和java.util.TreeSet。

Collection 常用功能：
public boolean add（E e）：把給定的對象添加到集合中。
public boolean contains(E e):判斷當前集合中是否包含給定的對象
public boolean remove(E e): 把給定的對象在當前集合中刪除。
public int size(): 返回集合中元素的個數。
public Object[] toArray(): 把集合中的元素，存儲到數組中。
public void clear() :清空集合中所有的元素。
public boolean isEmpty(): 判斷當前集合是否爲空。

方法演示
import java.util.ArrayList;
import java.util.Collection;

public class Demo0 1Collection {
    public static void main(String[] args) {
		// 創建集合對象 
    	// 使用多態形式
    	Collection<String> coll = new ArrayList<String>();
    	// 使用方法
    	// 添加功能  boolean  add(String s)
    	coll.add("小李廣");
    	coll.add("掃地僧");
    	coll.add("石破天");
    	System.out.println(coll);

    	// boolean contains(E e) 判斷o是否在集合中存在
    	System.out.println("判斷  掃地僧 是否在集合中"+coll.contains("掃地僧"));

    	//boolean remove(E e) 刪除在集合中的o元素
    	System.out.println("刪除石破天："+coll.remove("石破天"));
    	System.out.println("操作之後集合中元素:"+coll);
    	
    	// size() 集合中有幾個元素
		System.out.println("集合中有"+coll.size()+"個元素");

		// Object[] toArray()轉換成一個Object數組
    	Object[] objects = coll.toArray();
    	// 遍歷數組
    	for (int i = 0; i < objects.length; i++) {
			System.out.println(objects[i]);
		}

		// void  clear() 清空集合
		coll.clear();
		System.out.println("集合中內容爲："+coll);
		// boolean  isEmpty()  判斷是否爲空
		System.out.println(coll.isEmpty());  	
	}
}

Iterator迭代器
Iterator接口
java.util.Iterator是一個接口，也是Java集合中的一員，但是它與Collection、Map接口有所不同，Collection接口與Map接口主要用於存儲元素，而Iterator主要用於迭代訪問（即遍歷）Collection中的元素，因此Iterator對象也被稱爲迭代器。
Iterator接口的常用方法如下：

public boolean hasNext():如果仍有元素可以迭代，則返回 true。
public E next():返回迭代的下一個元素。
public void remove():刪除元素
使用步驟
獲取迭代器
判斷是否有下一個元素
獲取元素
重複執行2和3步驟，直到2判斷沒有下一個元素。

在以上每重複2、3步驟一次，我們稱爲一次迭代。
代碼實現

第一步中獲取迭代器，無需我們自己創建實現類，在Collction接口中如下方法進行獲取：

public Iterator iterator(): 獲取集合對應的迭代器，用來遍歷集合中的元素的。

接下來我們通過案例學習如何使用Iterator迭代集合中元素：

public class IteratorDemo {
  	public static void main(String[] args) {
        // 使用多態方式 創建集合對象
        Collection<String> coll = new ArrayList<String>();
        // 添加元素到集合
        coll.add("串串星人");
        coll.add("吐槽星人");
        coll.add("汪星人");
        //遍歷
        //使用迭代器 遍歷   每個集合對象都有自己的迭代器
        Iterator<String> it = coll.iterator();
        //  泛型指的是 迭代出 元素的數據類型
        while(it.hasNext()){ //判斷是否有迭代元素
            String s = it.next();//獲取迭代出的元素
            System.out.println(s);
        }
  	}
}

tips：在進行集合元素取出時，如果集合中已經沒有元素了，還繼續使用迭代器的next方法，將會發生java.util.NoSuchElementException沒有集合元素的錯誤。

迭代器的實現原理
當使用迭代器遍歷集合時，首先通過調用集合的iterator()方法獲得迭代器對象，然後使用hashNext()方法判斷集合中是否存在下一個元素，如果存在，則調用next()方法將元素取出，否則說明已到達了集合末尾，停止遍歷元素。

Iterator迭代器對象在遍歷集合時，內部採用指針的方式來跟蹤集合中的元素，爲了讓初學者能更好地理解迭代器的工作原理，接下來通過一個圖例來演示Iterator對象迭代元素的過程：

在調用Iterator的next方法之前，迭代器的索引位於第一個元素之前，不指向任何元素，當第一次調用迭代器的next方法後，迭代器的索引會向後移動一位，指向第一個元素並將該元素返回，當再次調用next方法時，迭代器的索引會指向第二個元素並將該元素返回，依此類推，直到hasNext方法返回false，表示到達了集合的末尾，終止對元素的遍歷。

增強for循環：
增強for循環(也稱foreach循環)是JDK1.5以後出來的一個高級for循環，專門用來遍歷數組和集合的。它的內部原理其實是個個Iterator迭代器。

格式：

for(元素數據類型  變量 : Collection集合或數組){ 
  	//寫操作代碼
}

增強for循環必須有被遍歷的目標。目標只能是Collection或者是數組。增強for僅僅作爲遍歷操作出現。

數組使用增強for循環案例：

public class Demo01ForEach_Array {
    public static void main(String[] args) {
        int[] arr = {10, 100, 1000, 10000};
        //使用增強for循遍歷數組
        for (int num : arr) {
            //num 中的值就當此循環獲取數組元素的值
            System.out.println("num = " + num);
        }
    }
}

Colloection集合增強for循環案例：

public class Demo02ForEach_Collection {
    public static void main(String[] args) {
        Collection<String> coll=new ArrayList<>();
      	coll.add("迪麗熱巴");
      	coll.add("古力娜扎");
      	coll.add("馬兒扎哈");
        //使用增強for循遍歷數組
        for (String str : coll) {
            //str 中的值就當此循環獲取集合的值
            System.out.println("str = " + str);
        }
    }
}

迭代器使用注意事項：
使用Iterator迭代器遍歷集合過程中特別要注意不能同時對集合中的元素進行增刪操作。否則會報錯ConcurrentModificationException。
例如：

public class Demo03Notice {
    public static void main(String[] args) {
        Collection<String> coll = new ArrayList<>();
        coll.add("古力娜扎");
        coll.add("迪麗熱巴");
        coll.add("馬兒扎哈");

        Iterator<String> iter = coll.iterator();
        while (iter.hasNext()) {
            String next = iter.next();
            System.out.println(next);
            coll.remove("馬兒扎哈");//報錯
        }

    }
}

增強for循環底層也是迭代器實現的，也不能進行增刪操作
如下圖：
1.迭代器用來遍歷集合元素，使用簡單，步驟如下：

獲取迭代器： Iterator iter = 集合對象.iterator()
判斷是否有下一個元素:boolean hasNext = iter.hasNext();
獲取下一個元素: 變量 = iter.next();
重複2，3步驟，直到沒有下一個元素：使用while循環操作

2.增強for循環：底層實現也是迭代器，可以對集合和數組進行遍歷，使用非常方便

for( 類型 變量： 集合或者數組){  }： 中的變量就是每次循環獲取的元素

泛型：

在創建集合ArrayList對象的時候，我們需要使用泛型指定存儲的數據類型。如果集合不指定數據類型，就可以存儲任意類型的數據了，此時這些數據都會向上轉型爲Object類型。取出集合中數據進行處理時，必定需要進行類型轉換。

大家觀察下面代碼：

public class GenericDemo {
	public static void main(String[] args) {
		Collection coll = new ArrayList();
		coll.add("abc");
		coll.add("itcast");
		coll.add(5);//由於集合沒有做任何限定，任何類型都可以給其中存放
		Iterator it = coll.iterator();
		while(it.hasNext()){
			//需要打印每個字符串的長度,就要把迭代出來的對象轉成String類型
			String str = (String) it.next();
			System.out.println(str.length());
		}
	}
}

程序在運行時發生了問題java.lang.ClassCastException，爲什麼會發生類型轉換異常呢？很好理解，由於集合中什麼類型的元素都可以存儲。導致取出的數據實際並不是強轉對應的數據，從而引發運行時 ClassCastException。

怎麼來解決這個問題呢？ Collection雖然可以存儲各種對象，但實際上通常Collection只存儲同一類型對象，例如都是存儲字符串對象。因此在JDK5之後，新增了泛型(Generic)語法，讓你在設計API時可以指定類，接口或方法支持泛型，這樣我們使用API的時候也變得更爲簡潔，並得到了編譯時期的語法檢查。
泛型：定義在類，接口或方法中可以預先使用的未知引用類型。

tips:一般在創建對象時，將未知的類型確定具體的類型。當沒有指定泛型時，默認類型爲Object類型。

將運行時期的ClassCastException，轉移到了編譯時期變成了編譯失敗。
避免了類型強轉的麻煩。

通過我們如下代碼體驗一下：

public class GenericDemo2 {
	public static void main(String[] args) {
        Collection<String> list = new ArrayList<String>();
        list.add("abc");
        list.add("itcast");
        // list.add(5);//當集合明確類型後，存放類型不一致就會編譯報錯
        // 集合已經明確具體存放的元素類型，那麼在使用迭代器的時候，
        迭代器也同樣會知道具體遍歷元素類型
        Iterator<String> it = list.iterator();
        while(it.hasNext()){
            String str = it.next();
            //當使用Iterator<String>控制元素類型後，就不需要強轉了。
            獲取到的元素直接就是String類型
            System.out.println(str.length());
        }
	}
}

tips:泛型是數據類型的一部分，我們將類名與泛型合併一起看做數據類型。

泛型定義格式

修飾符 class 類名 <代表泛型的變量>{  }

泛型變量一般爲大寫的字母表示。

例如，API中的ArrayList集合：

class ArrayList<E>{ 
    public boolean add(E e){ }

    public E get(int index){ }
   	....
}

使用泛型

使用泛型即什麼時候確定泛型的具體類型。泛型類可以在創建對象的時候確定泛型

例如集合類ArrayList: ArrayList list = new ArrayList();

此時，變量E的值就是String類型,那麼我們的類型就可以理解爲：

class ArrayList<String>{ 
     public boolean add(String e){ }

     public String get(int index){  }
     ...
}

再例如，ArrayList list = new ArrayList();

此時，變量E的值就是Integer類型,那麼我們的類型就可以理解爲：

 class ArrayList<Integer> {    
   public boolean add(Integer e) { }    
    public Integer get(int index) {  }    
     ...}

自定義泛型類並使用

步驟：
按格式定義泛型類
創建對象的時候，給泛型指定具體類型
代碼實現如下

1 按格式定義泛型類

public class MyGenericClass<MVP> {
	//沒有M類型，在這裏代表 未知的一種數據類型 未來傳遞什麼就
	是什麼類型
	private MVP mvp;
     
    public void setMVP(MVP m) {
        this.m = m;
    }
     
    public MVP getMVP() {
        return mvp;
    }
}

2 創建對象的時候，給泛型指定具體類型

public class GenericClassDemo {
  	public static void main(String[] args) {		 
         // 創建一個泛型爲String的類
         MyGenericClass<String> my = new MyGenericClass<String>();    	
         // 調用setMVP
         my.setMVP("大鬍子登登");
         // 調用getMVP
         String mvp = my.getMVP();
         System.out.println(mvp);
         //創建一個泛型爲Integer的類
         MyGenericClass<Integer> my2 = new MyGenericClass<Integer>(); 
         my2.setMVP(123);   	  
         Integer mvp2 = my2.getMVP();
    }
}

含有方法的泛型
定義格式

修飾符<代表泛型的變量>  返回值類型 方法名(參數){  }

如下：

public class MyGenericMethod {	  
    public <MVP> void show(MVP mvp) {
    	System.out.println(mvp.getClass());
    }
    
    public <MVP> MVP show2(MVP mvp) {	
    	return mvp;
    }
}

使用格式
調用方法時，確定泛型的類型

public class GenericMethodDemo {
    public static void main(String[] args) {
        // 創建對象
        MyGenericMethod mm = new MyGenericMethod();
        // 演示看方法提示
        mm.show("aaa"); // MVP -> String
        mm.show(123); // MVP -> Integer
        mm.show(12.45); // MVP -> Double
    }
}

含有泛型的接口
定義格式

修飾符 interface 接口名<代表泛型的變量> {  }

例如

public interface MyGenericInterface<E>{
	public abstract void add(E e);
	
	public abstract E getE();  
}

定義實現類時確定泛型的類型

例如:

public class MyImp1 implements MyGenericInterface<String> {
	 @Override
   public void add(String e) {
        // 省略...
   }

	@Override
	public String getE() {
		return null;
	}
}

此時泛型E就是String類型

始終不確定泛型的類型，直到創建對象時，確定泛型的類型
此時一定要先在本類類名後面先聲明一個泛型，然後再使用
例如

public class MyImp2<E> implements MyGenericInterface <E> {
	@Override
	public void add(E e) {
       	 // 省略...
	}

	@Override
	public E getE() {
		return null;
	}
}

確定泛型：

/*
 * 使用
 */
public class GenericInterface {
    public static void main(String[] args) {
        MyImp2<String>  my = new MyImp2<String>();  
        my.add("aa");
    }
}

泛型通配符
當使用泛型類或者接口時，傳遞的數據中，若泛型類型不確定，可以通過通配符<?>表示。 ?就是泛型通配符，用來指定任意的數據類型

通配符使用的案例

public static void main(String[] args) {
    Collection<Intger> list1 = new ArrayList<Integer>();
    getElement(list1);
    Collection<String> list2 = new ArrayList<String>();
    getElement(list2);
}
public static void getElement(Collection<?> coll){ }
//？代表可以接收任意類型

tips:泛型不存在繼承關係 Collection list = new ArrayList();這種是錯誤的。

通配符高級使用----受限泛型

之前設置泛型的時候，實際上是可以任意設置的，只要是類就可以設置。但是在JAVA的泛型中可以指定一個泛型的上限和下限。

泛型的上限:

格式：類型名稱 <? extends 類 > 對象名稱
意義：只能接收該類型及其子類

泛型的下限：

格式： 類型名稱 <? super 類 > 對象名稱
意義：只能接收該類型及其父類型

比如：現已知Object類，String 類，Number類，Integer類，其中Number是Integer的父類

public static void main(String[] args) {
    Collection<Integer> list1 = new ArrayList<Integer>();
    Collection<String> list2 = new ArrayList<String>();
    Collection<Number> list3 = new ArrayList<Number>();
    Collection<Object> list4 = new ArrayList<Object>();
    
    getElement(list1);
    getElement(list2);//報錯
    getElement(list3);
    getElement(list4);//報錯
  
    getElement2(list1);//報錯
    getElement2(list2);//報錯
    getElement2(list3);
    getElement2(list4);
  
}
// 泛型的上限：此時的泛型?，必須是Number類型或者Number類型的子類
public static void getElement1(Collection<? extends Number> coll){}
// 泛型的下限：此時的泛型?，必須是Number類型或者Number類型的父類
public static void getElement2(Collection<? super Number> coll){}

使用泛型時當無法確定具體類型時，我們可以使用泛型通配符？來表示任意的數據類型。
1. 集合使用了泛型通配符：元素會自動提升爲Object，只能取，不能存
泛型的通配符更高級的用法就是受限的泛型了：
1. *泛型的上限<? extends 類> *:只能使用該類或其子類
2. 泛型的下限 <? super 類>：只能接收該類型及其父類型
  案例

按照鬥地主的規則，完成洗牌發牌的動作。
具體規則：
使用54張牌打亂順序,三個玩家參與遊戲，三人交替摸牌，每人17張牌，最後三張留作底牌。

分析：
1.準備牌
牌可以設計爲一個ArrayList,每個字符串爲一張牌。
每張牌由花色數字兩部分組成，我們可以使用花色集合與數字集合嵌套迭代完成每張牌的組裝。
牌由Collections類的shuffle方法進行隨機排序。
2.發牌
將每個人以及底牌設計爲ArrayList,將最後3張牌直接存放於底牌，剩餘牌通過對3取模依次發牌。
3.看牌
直接打印每個集合

代碼實現：

import java.util.ArrayList;
import java.util.Collections;

public class Poker {
    public static void main(String[] args) {
        /*
        * 1: 準備牌操作
        */
        //1.1 創建牌盒 將來存儲牌面的 
        ArrayList<String> pokerBox = new ArrayList<String>();
        //1.2 創建花色集合
        ArrayList<String> colors = new ArrayList<String>();

        //1.3 創建數字集合
        ArrayList<String> numbers = new ArrayList<String>();

        //1.4 分別給花色 以及 數字集合添加元素
        colors.add("♥");
        colors.add("♦");
        colors.add("♠");
        colors.add("♣");

        for(int i = 2;i<=10;i++){
            numbers.add(i+"");
        }
        numbers.add("J");
        numbers.add("Q");
        numbers.add("K");
        numbers.add("A");
        //1.5 創造牌  拼接牌操作
        // 拿出每一個花色  然後跟每一個數字 進行結合  存儲到牌盒中
        for (String color : colors) {
            //color每一個花色 
            //遍歷數字集合
            for(String number : numbers){
                //結合
                String card = color+number;
                //存儲到牌盒中
                pokerBox.add(card);
            }
        }
        //1.6大王小王
        pokerBox.add("小☺");
        pokerBox.add("大☠");	  
        // System.out.println(pokerBox);
        //洗牌 是不是就是將  牌盒中 牌的索引打亂 
        // Collections類  工具類  都是 靜態方法
        // shuffer方法   
        /*
         * static void shuffle(List<?> list) 
         *     使用默認隨機源對指定列表進行置換。 
         */
        //2:洗牌
        Collections.shuffle(pokerBox);
        //3 發牌
        //3.1 創建 三個 玩家集合  創建一個底牌集合
        ArrayList<String> player1 = new ArrayList<String>();
        ArrayList<String> player2 = new ArrayList<String>();
        ArrayList<String> player3 = new ArrayList<String>();
        ArrayList<String> dipai = new ArrayList<String>();	  

        //遍歷 牌盒  必須知道索引   
        for(int i = 0;i<pokerBox.size();i++){
            //獲取 牌面
            String card = pokerBox.get(i);
            //留出三張底牌 存到 底牌集合中
            if(i>=51){//存到底牌集合中
                dipai.add(card);
            } else {
                //玩家1   %3  ==0
                if(i%3==0){
                  	player1.add(card);
                }else if(i%3==1){//玩家2
                  	player2.add(card);
                }else{//玩家3
                  	player3.add(card);
                }
            }
        }
        //看看
        System.out.println("令狐沖："+player1);
        System.out.println("田伯光："+player2);
        System.out.println("綠竹翁："+player3);
        System.out.println("底牌："+dipai);  
	}
}

Java基礎 -- 11 Collection、泛型

DAPPER 事務 TRANSACTION

Java基礎 -- 11 Collection、泛型

IBM X3650M4硬盤故障處理，硬盤指示燈沒有亮起

Java基礎 --08 接口、多態

Java基礎--02 流程控制語句、方法

Java基礎 --06 String類、static關鍵字、Arrays類、Math類

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結