摘要：集合的長度是可變的。演示下列代碼當集合明確類型后，存放類型不一致就會編譯報錯集合已經明確具體存放的元素類型，那么在使用迭代器的時候，迭代器也同樣會知道具體遍歷元素類型當使用控制元素類型后，就不需要強轉了。

 *A:集合使用的回顧
   *a.ArrayList集合存儲5個int類型元素
      public static void main(String[] args) {
           ArrayList list = new ArrayList();
        list.add(111);
        list.add(222);
        list.add(333);
        list.add(444);
        list.add(555);
        for(int i=0; i list = new ArrayList();
      list.add(new Person(“小強”));
      list.add(new Person(“老王”));
      list.add(new Person(“小虎”));
      list.add(new Person(“小澤”));
      list.add(new Person(“小紅”));
      for(int i=0; i
02集合的學習目標
   集合，集合是java中提供的一種容器，可以用來存儲多個數據。
 在前面的學習中，我們知道數據多了，可以使用數組存放或者使用ArrayList集合進行存放數據。那么，集合和數組既然都是容器，它們有啥區別呢？
 ?  數組的長度是固定的。集合的長度是可變的。
 ?  集合中存儲的元素必須是引用類型數據

03集合繼承關系圖
A:集合繼承關系圖
 a:ArrayList的繼承關系:
 查看ArrayList類發現它繼承了抽象類AbstractList同時實現接口List，而List接口又繼承了Collection接口。Collection接口為最頂層集合接口了。
 源代碼：
  interface List extends Collection {
  }
  public class ArrayList extends AbstractList implements List{
  }

b:集合繼承體系
 這說明我們在使用ArrayList類時，該類已經把所有抽象方法進行了重寫。那么，實現Collection接口的所有子類都會進行方法重寫。
 ?  Collecton接口常用的子接口有：List接口、Set接口
 ?  List接口常用的子類有：ArrayList類、LinkedList類
 ?  Set接口常用的子類有：HashSet類、LinkedHashSet類
 
                          Collection 接口     
                               |
 ----------------------------------------------------------------
 |                                                              |
List接口                                                       Set接口
 |                                                              |
----------------                                             -------------
 |              |                                             |            |
ArrayList類    LinkedList類                                 HashSet類     LinkedHashSet類
04集合Collection的方法
A:集合Collection的方法
 /*
  *  Collection接口中的方法
  *  是集合中所有實現類必須擁有的方法
  *  使用Collection接口的實現類,程序的演示
  *  ArrayList implements List
  *  List extends Collection
  *  方法的執行,都是實現的重寫
  */
 public class CollectionDemo {
  public static void main(String[] args) {
    function_2();
  }
  
  
  /*  Collection接口方法
   *  Object[] toArray() 集合中的元素,轉成一個數組中的元素, 集合轉成數組
   *  返回是一個存儲對象的數組, 數組存儲的數據類型是Object
   */
  private static void function_2() {
    Collection coll = new ArrayList();
    coll.add("abc");
    coll.add("itcast");
    coll.add("itheima");
    coll.add("money");
    coll.add("123");
    
    Object[] objs = coll.toArray();
    for(int i = 0 ; i < objs.length ; i++){
      System.out.println(objs[i]);
    }
  }
  /*
   * 學習Java中三種長度表現形式
   *   數組.length 屬性  返回值 int
   *   字符串.length() 方法,返回值int
   *   集合.size()方法, 返回值int
   */
  
  /*
   * Collection接口方法
   * boolean contains(Object o) 判斷對象是否存在于集合中,對象存在返回true
   * 方法參數是Object類型
   */
  private static void function_1() {
    Collection coll = new ArrayList();
    coll.add("abc");
    coll.add("itcast");
    coll.add("itheima");
    coll.add("money");
    coll.add("123");
    
    boolean b = coll.contains("itcast");
    System.out.println(b);
  }

  /*
   * Collection接口的方法
   * void clear() 清空集合中的所有元素
   * 集合容器本身依然存在
   */
  public static void function(){
    //接口多態的方式調用
    Collection coll = new ArrayList();
    coll.add("abc");
    coll.add("bcd");
    System.out.println(coll);
    
    coll.clear();
    
    System.out.println(coll);
    
  }
 }

05集合Collection的remove方法
A:05集合Collection的remove方法
/*
 * Collection接口方法
 * boolean remove(Object o)移除集合中指定的元素
 */
private static void function_3(){
  Collection coll = new ArrayList();
  coll.add("abc");
  coll.add("money");
  coll.add("itcast");
  coll.add("itheima");
  coll.add("money");
  coll.add("123");  
  System.out.println(coll);
  
  boolean b = coll.remove("money");
  System.out.println(b);
  System.out.println(coll);
}

=======================第二節課開始=============================================
06迭代器的概述
A:迭代器概述:
   a:java中提供了很多個集合，它們在存儲元素時，采用的存儲方式不同。
我們要取出這些集合中的元素，可通過一種通用的獲取方式來完成。

b:Collection集合元素的通用獲取方式：在取元素之前先要判斷集合中有沒有元素，
  如果有，就把這個元素取出來，繼續在判斷，如果還有就再取出出來。一直把集合中的所有元素全部取出。這種取出方式專業術語稱為迭代。
c:每種集合的底層的數據結構不同,例如ArrayList是數組,LinkedList底層是鏈表,但是無論使用那種集合,我們都會有判斷是否有元素
 以及取出里面的元素的動作,那么Java為我們提供一個迭代器定義了統一的判斷元素和取元素的方法 

07迭代器的實現原理
*A:迭代器的實現原理
  /*
 *  集合中的迭代器:
 *    獲取集合中元素方式
 *  接口 Iterator : 兩個抽象方法
 *     boolean hasNext() 判斷集合中還有沒有可以被取出的元素,如果有返回true
 *     next() 取出集合中的下一個元素
 *     
 *  Iterator接口,找實現類.
 *    Collection接口定義方法 
 *       Iterator  iterator()
 *    ArrayList 重寫方法 iterator(),返回了Iterator接口的實現類的對象
 *    使用ArrayList集合的對象
 *     Iterator it =array.iterator(),運行結果就是Iterator接口的實現類的對象
 *     it是接口的實現類對象,調用方法 hasNext 和 next 集合元素迭代
 */

08迭代器的代碼實現
*A:迭代器的代碼實現
  public class IteratorDemo {
    public static void main(String[] args) {
      Collection coll = new ArrayList();
      coll.add("abc1");
      coll.add("abc2");
      coll.add("abc3");
      coll.add("abc4");
      //迭代器,對集合ArrayList中的元素進行取出
      
      //調用集合的方法iterator()獲取出,Iterator接口的實現類的對象
      Iterator it = coll.iterator();
      //接口實現類對象,調用方法hasNext()判斷集合中是否有元素
      //boolean b = it.hasNext();
      //System.out.println(b);
      //接口的實現類對象,調用方法next()取出集合中的元素
      //String s = it.next();
      //System.out.println(s);
      
      //迭代是反復內容,使用循環實現,循環的條件,集合中沒元素, hasNext()返回了false
      while(it.hasNext()){
        String s = it.next();
        System.out.println(s);
      }
      
     
      
    }
  }
09迭代器的執行過程
A:迭代器的執行過程
 a:迭代器的原理:
   while(it.hasNext()) {
        System.out.println(it.next());
   }
   
   //cursor記錄的索引值不等于集合的長度返回true,否則返回false
     public boolean hasNext() {       
       return cursor != size; //cursor初值為0
                       
     }

    //next()方法作用:
    //①返回cursor指向的當前元素 
    //②cursor++
    public Object next() {            
             int i = cursor; 
             cursor = i + 1;  
             return  elementData[lastRet = i]; 
         
         }
 b:for循環迭代寫法:
    for (Iterator it2 = coll.iterator(); it2.hasNext();  ) {
     System.out.println(it2.next());
   } 

10集合迭代中的轉型
A:集合迭代中的轉型
 a:在使用集合時，我們需要注意以下幾點：
 ?  集合中存儲其實都是對象的地址。
 ?  集合中可以存儲基本數值嗎？jdk1.5版本以后可以存儲了。
     因為出現了基本類型包裝類，它提供了自動裝箱操作（基本類型?對象），這樣，集合中的元素就是基本數值的包裝類對象。

b:存儲時提升了Object。取出時要使用元素的特有內容，必須向下轉型。
 Collection coll = new ArrayList();
 coll.add("abc");
 coll.add("aabbcc");
 coll.add("shitcast");
 Iterator it = coll.iterator();
 while (it.hasNext()) {
  //由于元素被存放進集合后全部被提升為Object類型
 //當需要使用子類對象特有方法時，需要向下轉型
  String str = (String) it.next();
  System.out.println(str.length());
 }
 注意：如果集合中存放的是多個對象，這時進行向下轉型會發生類型轉換異常。


c:Iterator接口也可以使用<>來控制迭代元素的類型的。代碼演示如下：
 Collection coll = new ArrayList();
 coll.add("abc");
 coll.add("aabbcc");
 coll.add("shitcast");
 Iterator it = coll.iterator();
 while (it.hasNext()) {
  String str =  it.next(); 
 //當使用Iterator控制元素類型后，就不需要強轉了。獲取到的元素直接就是String類型
  System.out.println(str.length());
 }

=========================第三節課開始====================================
11增強for循環遍歷數組
*A:增強for循環遍歷數組
 a:格式:
 /*
  *  JDK1.5新特性,增強for循環
  *  JDK1.5版本后,出現新的接口 java.lang.Iterable
  *    Collection開是繼承Iterable
  *    Iterable作用,實現增強for循環
  *    
  *    格式:
  *      for( 數據類型  變量名 : 數組或者集合 ){
  *         sop(變量);
  *      }
  */
 public static void function_1(){
    //for對于對象數組遍歷的時候,能否調用對象的方法呢
    String[] str = {"abc","itcast","cn"};
    for(String s : str){
      System.out.println(s.length());
    }
  }
  
  /*
   *  實現for循環,遍歷數組
   *  好處: 代碼少了,方便對容器遍歷
   *  弊端: 沒有索引,不能操作容器里面的元素
   */
  public static void function(){
    int[] arr = {3,1,9,0};
    for(int i : arr){
      System.out.println(i+1);
    }
    System.out.println(arr[0]);
  }
12增強for循環遍歷集合
  A:增強for循環遍歷集合  
    /*
     *  增強for循環遍歷集合
     *  存儲自定義Person類型
     */
    public static void function_2(){
      ArrayList array = new ArrayList();
      array.add(new Person("a",20));
      array.add(new Person("b",10));
      for(Person p : array){
        System.out.println(p);// System.out.println(p.toString());
      }
    }
    
13泛型的引入
A:泛型的引入
在前面學習集合時，我們都知道集合中是可以存放任意對象的，
只要把對象存儲集合后，那么這時他們都會被提升成Object類型。
當我們在取出每一個對象，并且進行相應的操作，這時必須采用類型轉換。比如下面程序：
public class GenericDemo {
  public static void main(String[] args) {
    List list = new ArrayList();
    list.add("abc");
    list.add("itcast");
    list.add(5);//由于集合沒有做任何限定，任何類型都可以給其中存放
                //相當于:Object obj=new Integer(5);
    
    Iterator it = list.iterator();
    while(it.hasNext()){
      //需要打印每個字符串的長度,就要把迭代出來的對象轉成String類型
      String str = (String) it.next();//String str=(String)obj;
                                      //編譯時期僅檢查語法錯誤,String是Object的兒子可以向下轉型
                                      //運行時期String str=(String)(new Integer(5))
                                      //String與Integer沒有父子關系所以轉換失敗
                                      //程序在運行時發生了問題java.lang.ClassCastException
      System.out.println(str.length());
    }
  }
}



14泛型的定義和使用
A:泛型的定義和使用
/*
 * JDK1.5 出現新的安全機制,保證程序的安全性
 *   泛型: 指明了集合中存儲數據的類型  <數據類型>
 */

public class GenericDemo {
  public static void main(String[] args) {
    function();
  }
  
  public static void function(){
    Collection coll = new ArrayList();
    coll.add("abc");
    coll.add("rtyg");
    coll.add("43rt5yhju");
//    coll.add(1);
    
    Iterator it = coll.iterator();
    while(it.hasNext()){
      String s = it.next();
      System.out.println(s.length());
    }
  }
}

15Java中的偽泛型
 A:Java中的偽泛型：
   泛型只在編譯時存在,編譯后就被擦除,在編譯之前我們就可以限制集合的類型,起到作用
 例如:ArrayList al=new ArrayList();
 編譯后:ArrayList al=new ArrayList();

================================第四節課開始======================================================
16泛型類
A:泛型類:
a:定義格式：
  修飾符 class 類名<代表泛型的變量> {  }
  
  例如，API中的ArrayList集合：
  class ArrayList{ 
       public boolean add(E e){ }
    public E get(int index){  }
  }

b:使用格式：
  創建對象時，確定泛型的類型
 
  例如，ArrayList list = new ArrayList();
  此時，變量E的值就是String類型
  class ArrayList{ 
    public boolean add(String e){ }
    public String get(int index){  }
  }
 
  例如，ArrayList list = new ArrayList();
  此時，變量E的值就是Integer類型
  class ArrayList{ 
       public boolean add(Integer e){ }
       public Integer get(int index){  }
  }

17泛型的方法
A:泛型的方法
a:定義格式：修飾符 <代表泛型的變量> 返回值類型 方法名(參數){  }
b:泛型方法的使用:
 1:例如，API中的ArrayList集合中的方法：
  public  T[] toArray(T[] a){  } 
  //該方法，用來把集合元素存儲到指定數據類型的數組中，返回已存儲集合元素的數組

  使用格式：調用方法時，確定泛型的類型
?例如:
      ArrayList list = new ArrayList();
      String[] arr = new String[100];
      String[] result = list.toArray(arr);
   此時，變量T的值就是String類型。變量T，可以與定義集合的泛型不同
   public  String[] toArray(String[] a){  } 
?

  例如:
      ArrayList list = new ArrayList();
      Integer[] arr = new Integer[100];
      Integer [] result = list.toArray(arr);
  
  此時，變量T的值就是Integer類型。變量T，可以與定義集合的泛型不同
  public  Integer[] toArray(Integer[] a){  } 

18泛型的接口
A:泛型的接口:
 /*
  *  帶有泛型的接口
  *  
  *  public interface List {
  *    abstract boolean add(E e);
  *  }
  * 
  *  實現類,先實現接口,不理會泛型
  *  public class ArrayList implements List{
  *  }
  *  調用者 : new ArrayList() 后期創建集合對象的時候,指定數據類型
  *  
  *  
  *  實現類,實現接口的同時,也指定了數據類型
  *  public class XXX implements List{
  *  }
  *  new XXX()
  */
 public class GenericDemo2 {
  
 }

19泛型的好處
A:泛型的好處
?a:將運行時期的ClassCastException，轉移到了編譯時期變成了編譯失敗。
?b:避免了類型強轉的麻煩。
演示下列代碼：
public class GenericDemo {
  public static void main(String[] args) {
    List list = new ArrayList();
    list.add("abc");
    list.add("itcast");
    //list.add(5);//當集合明確類型后，存放類型不一致就會編譯報錯
                 //集合已經明確具體存放的元素類型，那么在使用迭代器的時候，迭代器也同樣會知道具體遍歷元素類型
   
    Iterator it = list.iterator();
    while(it.hasNext()){
       String str = it.next();
       System.out.println(str.length()); //當使用Iterator      
                                        //控制元素類型后，就不需要強轉了。獲取到的元素直接就是String類型
    }
  }
}

20泛型的通配符
A:泛型的通配符
   /*
*  泛型的通配符
*/
public class GenericDemo {
public static void main(String[] args) {
  ArrayList array = new ArrayList();
  
  HashSet set = new HashSet();
  
  array.add("123");
  array.add("456");
  
  set.add(789);
  set.add(890);
  
  iterator(array);
  iterator(set);
}
/*
 *  定義方法,可以同時迭代2個集合
 *  參數: 怎么實現 , 不能寫ArrayList,也不能寫HashSet
 *  參數: 或者共同實現的接口
 *  泛型的通配,匹配所有的數據類型  ?
 */
public static void iterator(Collection coll){
  Iterator it = coll.iterator();
  while(it.hasNext()){
    //it.next()獲取的對象,什么類型
    System.out.println(it.next());
  }
}
}
21泛型的限定
A:泛型的限定
   /*
*  將的酒店員工,廚師,服務員,經理,分別存儲到3個集合中
*  定義方法,可以同時遍歷3集合,遍歷三個集合的同時,可以調用工作方法
*/
import java.util.ArrayList;
   import java.util.Iterator;
   public class GenericTest {
public static void main(String[] args) {
  //創建3個集合對象
  ArrayList cs = new ArrayList();
  ArrayList fwy = new ArrayList();
  ArrayList jl = new ArrayList();
  
  //每個集合存儲自己的元素
  cs.add(new ChuShi("張三", "后廚001"));
  cs.add(new ChuShi("李四", "后廚002"));
  
  fwy.add(new FuWuYuan("翠花", "服務部001"));
  fwy.add(new FuWuYuan("酸菜", "服務部002"));
  
  jl.add(new JingLi("小名", "董事會001", 123456789.32));
  jl.add(new JingLi("小強", "董事會002", 123456789.33));
  
//   ArrayList arrayString = new ArrayList();
  iterator(jl);
  iterator(fwy);
  iterator(cs);

}
/*
 * 定義方法,可以同時遍歷3集合,遍歷三個集合的同時,可以調用工作方法 work
 * ? 通配符,迭代器it.next()方法取出來的是Object類型,怎么調用work方法
 * 強制轉換:  it.next()=Object o ==> Employee
 * 方法參數: 控制,可以傳遞Employee對象,也可以傳遞Employee的子類的對象
 * 泛型的限定  本案例,父類固定Employee,但是子類可以無限?
 *   ? extends Employee 限制的是父類, 上限限定, 可以傳遞Employee,傳遞他的子類對象
 *   ? super   Employee 限制的是子類, 下限限定, 可以傳遞Employee,傳遞他的父類對象
 */
public static void iterator(ArrayList array){
  
   Iterator it = array.iterator();
   while(it.hasNext()){
     //獲取出的next() 數據類型,是什么Employee
     Employee e = it.next();
     e.work();
   }
}
}