01集合使用的回顧
　　A:集合使用的回顧
　　　　a.ArrayList集合儲存5個int型別元素
          public static void main(String[] args) {
               ArrayList<Integer> list = new ArrayList<Integer>();
            list.add(111);
            list.add(222);
            list.add(333);
            list.add(444);
            list.add(555);
            for(int i=0; i<list.size(); i++){
                   System.out.println(list.get(i));
           }
          }

　　　　b.ArrayList集合儲存5個Person型別元素
         public static void main(String[] args) {
          ArrayList<Person> list = new ArrayList<Person>();
          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<list.size(); i++){
            Person p = list.get(i);
                  System.out.println(p);
           }
         }


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<String> coll = new ArrayList<String>();
        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<String> coll = new ArrayList<String>();
        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<String> coll = new ArrayList<String>();
        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<String> coll = new ArrayList<String>();
      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<String> coll = new ArrayList<String>();
          coll.add("abc1");
          coll.add("abc2");
          coll.add("abc3");
          coll.add("abc4");
          //迭代器,對集合ArrayList中的元素進行取出
          
          //呼叫集合的方法iterator()獲取出,Iterator介面的實現類的物件
          Iterator<String> 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<String> 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<String> coll = new ArrayList<String>();
     coll.add("abc");
     coll.add("aabbcc");
     coll.add("shitcast");
     Iterator<String> it = coll.iterator();
     while (it.hasNext()) {
      String str =  it.next(); 
     //當使用Iterator<String>控制元素型別後，就不需要強轉了。獲取到的元素直接就是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<Person> array = new ArrayList<Person>();
          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<String> coll = new ArrayList<String>();
        coll.add("abc");
        coll.add("rtyg");
        coll.add("43rt5yhju");
    //    coll.add(1);
        
        Iterator<String> it = coll.iterator();
        while(it.hasNext()){
          String s = it.next();
          System.out.println(s.length());
        }
      }
    }

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


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

    b:使用格式：
      建立物件時，確定泛型的型別
     
      例如，ArrayList<String> list = new ArrayList<String>();
      此時，變數E的值就是String型別
      class ArrayList<String>{ 
        public boolean add(String e){ }
        public String get(int index){  }
      }
     
      例如，ArrayList<Integer> list = new ArrayList<Integer>();
      此時，變數E的值就是Integer型別
      class ArrayList<Integer>{ 
           public boolean add(Integer e){ }
           public Integer get(int index){  }
      }

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

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

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

 
18泛型的介面 
   A:泛型的介面:
     /*
      *  帶有泛型的介面
      *  
      *  public interface List <E>{
      *    abstract boolean add(E e);
      *  }
      * 
      *  實現類,先實現介面,不理會泛型
      *  public class ArrayList<E> implements List<E>{
      *  }
      *  呼叫者 : new ArrayList<String>() 後期建立集合物件的時候,指定資料型別
      *  
      *  
      *  實現類,實現介面的同時,也指定了資料型別
      *  public class XXX implements List<String>{
      *  }
      *  new XXX()
      */
     public class GenericDemo2 {
      
     }
 
19泛型的好處
  A:泛型的好處
    a:將執行時期的ClassCastException，轉移到了編譯時期變成了編譯失敗。
    b:避免了型別強轉的麻煩。
    演示下列程式碼：
    public class GenericDemo {
      public static void main(String[] args) {
        List<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();
           System.out.println(str.length()); //當使用Iterator<String>      
                                            //控制元素型別後，就不需要強轉了。獲取到的元素直接就是String型別
        }
      }
    }

20泛型的萬用字元   
   A:泛型的萬用字元
   /*
    *  泛型的萬用字元
    */
   public class GenericDemo {
    public static void main(String[] args) {
      ArrayList<String> array = new ArrayList<String>();
      
      HashSet<Integer> set = new HashSet<Integer>();
      
      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<ChuShi> cs = new ArrayList<ChuShi>();
      ArrayList<FuWuYuan> fwy = new ArrayList<FuWuYuan>();
      ArrayList<JingLi> jl = new ArrayList<JingLi>();
      
      //每個集合儲存自己的元素
      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<String> arrayString = new ArrayList<String>();
      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<? extends Employee> array){
      
       Iterator<? extends Employee> it = array.iterator();
       while(it.hasNext()){
         //獲取出的next() 資料型別,是什麼Employee
         Employee e = it.next();
         e.work();
       }
    }
   }