1、集合 2、Iterator迭代器 3、增強(qiáng)for循環(huán) 4、泛型

Hwg 發(fā)布于2019-08-14 18:41 / 2654人閱讀

摘要：集合的長(zhǎng)度是可變的。演示下列代碼當(dāng)集合明確類(lèi)型后，存放類(lèi)型不一致就會(huì)編譯報(bào)錯(cuò)集合已經(jīng)明確具體存放的元素類(lèi)型，那么在使用迭代器的時(shí)候，迭代器也同樣會(huì)知道具體遍歷元素類(lèi)型當(dāng)使用控制元素類(lèi)型后，就不需要強(qiáng)轉(zhuǎn)了。

01集合使用的回顧

 *A:集合使用的回顧
   *a.ArrayList集合存儲(chǔ)5個(gè)int類(lèi)型元素
      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(“小強(qiáng)”));
      list.add(new Person(“老王”));
      list.add(new Person(“小虎”));
      list.add(new Person(“小澤”));
      list.add(new Person(“小紅”));
      for(int i=0; i
02集合的學(xué)習(xí)目標(biāo)
   集合，集合是java中提供的一種容器，可以用來(lái)存儲(chǔ)多個(gè)數(shù)據(jù)。
 在前面的學(xué)習(xí)中，我們知道數(shù)據(jù)多了，可以使用數(shù)組存放或者使用ArrayList集合進(jìn)行存放數(shù)據(jù)。那么，集合和數(shù)組既然都是容器，它們有啥區(qū)別呢？
 ?  數(shù)組的長(zhǎng)度是固定的。集合的長(zhǎng)度是可變的。
 ?  集合中存儲(chǔ)的元素必須是引用類(lèi)型數(shù)據(jù)

03集合繼承關(guān)系圖
A:集合繼承關(guān)系圖
 a:ArrayList的繼承關(guān)系:
 查看ArrayList類(lèi)發(fā)現(xiàn)它繼承了抽象類(lèi)AbstractList同時(shí)實(shí)現(xiàn)接口List，而List接口又繼承了Collection接口。Collection接口為最頂層集合接口了。
 源代碼：
  interface List extends Collection {
  }
  public class ArrayList extends AbstractList implements List{
  }

b:集合繼承體系
 這說(shuō)明我們?cè)谑褂肁rrayList類(lèi)時(shí)，該類(lèi)已經(jīng)把所有抽象方法進(jìn)行了重寫(xiě)。那么，實(shí)現(xiàn)Collection接口的所有子類(lèi)都會(huì)進(jìn)行方法重寫(xiě)。
 ?  Collecton接口常用的子接口有：List接口、Set接口
 ?  List接口常用的子類(lèi)有：ArrayList類(lèi)、LinkedList類(lèi)
 ?  Set接口常用的子類(lèi)有：HashSet類(lèi)、LinkedHashSet類(lèi)
 
                          Collection 接口     
                               |
 ----------------------------------------------------------------
 |                                                              |
List接口                                                       Set接口
 |                                                              |
----------------                                             -------------
 |              |                                             |            |
ArrayList類(lèi)    LinkedList類(lèi)                                 HashSet類(lèi)     LinkedHashSet類(lèi)
04集合Collection的方法
A:集合Collection的方法
 /*
  *  Collection接口中的方法
  *  是集合中所有實(shí)現(xiàn)類(lèi)必須擁有的方法
  *  使用Collection接口的實(shí)現(xiàn)類(lèi),程序的演示
  *  ArrayList implements List
  *  List extends Collection
  *  方法的執(zhí)行,都是實(shí)現(xiàn)的重寫(xiě)
  */
 public class CollectionDemo {
  public static void main(String[] args) {
    function_2();
  }
  
  
  /*  Collection接口方法
   *  Object[] toArray() 集合中的元素,轉(zhuǎn)成一個(gè)數(shù)組中的元素, 集合轉(zhuǎn)成數(shù)組
   *  返回是一個(gè)存儲(chǔ)對(duì)象的數(shù)組, 數(shù)組存儲(chǔ)的數(shù)據(jù)類(lèi)型是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]);
    }
  }
  /*
   * 學(xué)習(xí)Java中三種長(zhǎng)度表現(xiàn)形式
   *   數(shù)組.length 屬性  返回值 int
   *   字符串.length() 方法,返回值int
   *   集合.size()方法, 返回值int
   */
  
  /*
   * Collection接口方法
   * boolean contains(Object o) 判斷對(duì)象是否存在于集合中,對(duì)象存在返回true
   * 方法參數(shù)是Object類(lèi)型
   */
  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(){
    //接口多態(tài)的方式調(diào)用
    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);
}

=======================第二節(jié)課開(kāi)始=============================================
06迭代器的概述
A:迭代器概述:
   a:java中提供了很多個(gè)集合，它們?cè)诖鎯?chǔ)元素時(shí)，采用的存儲(chǔ)方式不同。
我們要取出這些集合中的元素，可通過(guò)一種通用的獲取方式來(lái)完成。

b:Collection集合元素的通用獲取方式：在取元素之前先要判斷集合中有沒(méi)有元素，
  如果有，就把這個(gè)元素取出來(lái)，繼續(xù)在判斷，如果還有就再取出出來(lái)。一直把集合中的所有元素全部取出。這種取出方式專(zhuān)業(yè)術(shù)語(yǔ)稱(chēng)為迭代。
c:每種集合的底層的數(shù)據(jù)結(jié)構(gòu)不同,例如ArrayList是數(shù)組,LinkedList底層是鏈表,但是無(wú)論使用那種集合,我們都會(huì)有判斷是否有元素
 以及取出里面的元素的動(dòng)作,那么Java為我們提供一個(gè)迭代器定義了統(tǒng)一的判斷元素和取元素的方法 

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

08迭代器的代碼實(shí)現(xiàn)
*A:迭代器的代碼實(shí)現(xiàn)
  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");
      //迭代器,對(duì)集合ArrayList中的元素進(jìn)行取出
      
      //調(diào)用集合的方法iterator()獲取出,Iterator接口的實(shí)現(xiàn)類(lèi)的對(duì)象
      Iterator it = coll.iterator();
      //接口實(shí)現(xiàn)類(lèi)對(duì)象,調(diào)用方法hasNext()判斷集合中是否有元素
      //boolean b = it.hasNext();
      //System.out.println(b);
      //接口的實(shí)現(xiàn)類(lèi)對(duì)象,調(diào)用方法next()取出集合中的元素
      //String s = it.next();
      //System.out.println(s);
      
      //迭代是反復(fù)內(nèi)容,使用循環(huán)實(shí)現(xiàn),循環(huán)的條件,集合中沒(méi)元素, hasNext()返回了false
      while(it.hasNext()){
        String s = it.next();
        System.out.println(s);
      }
      
     
      
    }
  }
09迭代器的執(zhí)行過(guò)程
A:迭代器的執(zhí)行過(guò)程
 a:迭代器的原理:
   while(it.hasNext()) {
        System.out.println(it.next());
   }
   
   //cursor記錄的索引值不等于集合的長(zhǎng)度返回true,否則返回false
     public boolean hasNext() {       
       return cursor != size; //cursor初值為0
                       
     }

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

10集合迭代中的轉(zhuǎn)型
A:集合迭代中的轉(zhuǎn)型
 a:在使用集合時(shí)，我們需要注意以下幾點(diǎn)：
 ?  集合中存儲(chǔ)其實(shí)都是對(duì)象的地址。
 ?  集合中可以存儲(chǔ)基本數(shù)值嗎？jdk1.5版本以后可以存儲(chǔ)了。
     因?yàn)槌霈F(xiàn)了基本類(lèi)型包裝類(lèi)，它提供了自動(dòng)裝箱操作（基本類(lèi)型?對(duì)象），這樣，集合中的元素就是基本數(shù)值的包裝類(lèi)對(duì)象。

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


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

=========================第三節(jié)課開(kāi)始====================================
11增強(qiáng)for循環(huán)遍歷數(shù)組
*A:增強(qiáng)for循環(huán)遍歷數(shù)組
 a:格式:
 /*
  *  JDK1.5新特性,增強(qiáng)for循環(huán)
  *  JDK1.5版本后,出現(xiàn)新的接口 java.lang.Iterable
  *    Collection開(kāi)是繼承Iterable
  *    Iterable作用,實(shí)現(xiàn)增強(qiáng)for循環(huán)
  *    
  *    格式:
  *      for( 數(shù)據(jù)類(lèi)型  變量名 : 數(shù)組或者集合 ){
  *         sop(變量);
  *      }
  */
 public static void function_1(){
    //for對(duì)于對(duì)象數(shù)組遍歷的時(shí)候,能否調(diào)用對(duì)象的方法呢
    String[] str = {"abc","itcast","cn"};
    for(String s : str){
      System.out.println(s.length());
    }
  }
  
  /*
   *  實(shí)現(xiàn)for循環(huán),遍歷數(shù)組
   *  好處: 代碼少了,方便對(duì)容器遍歷
   *  弊端: 沒(méi)有索引,不能操作容器里面的元素
   */
  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增強(qiáng)for循環(huán)遍歷集合
  A:增強(qiáng)for循環(huán)遍歷集合  
    /*
     *  增強(qiáng)for循環(huán)遍歷集合
     *  存儲(chǔ)自定義Person類(lèi)型
     */
    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:泛型的引入
在前面學(xué)習(xí)集合時(shí)，我們都知道集合中是可以存放任意對(duì)象的，
只要把對(duì)象存儲(chǔ)集合后，那么這時(shí)他們都會(huì)被提升成Object類(lèi)型。
當(dāng)我們?cè)谌〕雒恳粋€(gè)對(duì)象，并且進(jìn)行相應(yīng)的操作，這時(shí)必須采用類(lèi)型轉(zhuǎn)換。比如下面程序：
public class GenericDemo {
  public static void main(String[] args) {
    List list = new ArrayList();
    list.add("abc");
    list.add("itcast");
    list.add(5);//由于集合沒(méi)有做任何限定，任何類(lèi)型都可以給其中存放
                //相當(dāng)于:Object obj=new Integer(5);
    
    Iterator it = list.iterator();
    while(it.hasNext()){
      //需要打印每個(gè)字符串的長(zhǎng)度,就要把迭代出來(lái)的對(duì)象轉(zhuǎn)成String類(lèi)型
      String str = (String) it.next();//String str=(String)obj;
                                      //編譯時(shí)期僅檢查語(yǔ)法錯(cuò)誤,String是Object的兒子可以向下轉(zhuǎn)型
                                      //運(yùn)行時(shí)期String str=(String)(new Integer(5))
                                      //String與Integer沒(méi)有父子關(guān)系所以轉(zhuǎn)換失敗
                                      //程序在運(yùn)行時(shí)發(fā)生了問(wèn)題java.lang.ClassCastException
      System.out.println(str.length());
    }
  }
}



14泛型的定義和使用
A:泛型的定義和使用
/*
 * JDK1.5 出現(xiàn)新的安全機(jī)制,保證程序的安全性
 *   泛型: 指明了集合中存儲(chǔ)數(shù)據(jù)的類(lèi)型  <數(shù)據(jù)類(lèi)型>
 */

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中的偽泛型：
   泛型只在編譯時(shí)存在,編譯后就被擦除,在編譯之前我們就可以限制集合的類(lèi)型,起到作用
 例如:ArrayList al=new ArrayList();
 編譯后:ArrayList al=new ArrayList();

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

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

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

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

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

18泛型的接口
A:泛型的接口:
 /*
  *  帶有泛型的接口
  *  
  *  public interface List {
  *    abstract boolean add(E e);
  *  }
  * 
  *  實(shí)現(xiàn)類(lèi),先實(shí)現(xiàn)接口,不理會(huì)泛型
  *  public class ArrayList implements List{
  *  }
  *  調(diào)用者 : new ArrayList() 后期創(chuàng)建集合對(duì)象的時(shí)候,指定數(shù)據(jù)類(lèi)型
  *  
  *  
  *  實(shí)現(xiàn)類(lèi),實(shí)現(xiàn)接口的同時(shí),也指定了數(shù)據(jù)類(lèi)型
  *  public class XXX implements List{
  *  }
  *  new XXX()
  */
 public class GenericDemo2 {
  
 }

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

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);
}
/*
 *  定義方法,可以同時(shí)迭代2個(gè)集合
 *  參數(shù): 怎么實(shí)現(xiàn) , 不能寫(xiě)ArrayList,也不能寫(xiě)HashSet
 *  參數(shù): 或者共同實(shí)現(xiàn)的接口
 *  泛型的通配,匹配所有的數(shù)據(jù)類(lèi)型  ?
 */
public static void iterator(Collection coll){
  Iterator it = coll.iterator();
  while(it.hasNext()){
    //it.next()獲取的對(duì)象,什么類(lèi)型
    System.out.println(it.next());
  }
}
}
21泛型的限定
A:泛型的限定
   /*
*  將的酒店員工,廚師,服務(wù)員,經(jīng)理,分別存儲(chǔ)到3個(gè)集合中
*  定義方法,可以同時(shí)遍歷3集合,遍歷三個(gè)集合的同時(shí),可以調(diào)用工作方法
*/
import java.util.ArrayList;
   import java.util.Iterator;
   public class GenericTest {
public static void main(String[] args) {
  //創(chuàng)建3個(gè)集合對(duì)象
  ArrayList cs = new ArrayList();
  ArrayList fwy = new ArrayList();
  ArrayList jl = new ArrayList();
  
  //每個(gè)集合存儲(chǔ)自己的元素
  cs.add(new ChuShi("張三", "后廚001"));
  cs.add(new ChuShi("李四", "后廚002"));
  
  fwy.add(new FuWuYuan("翠花", "服務(wù)部001"));
  fwy.add(new FuWuYuan("酸菜", "服務(wù)部002"));
  
  jl.add(new JingLi("小名", "董事會(huì)001", 123456789.32));
  jl.add(new JingLi("小強(qiáng)", "董事會(huì)002", 123456789.33));
  
//   ArrayList arrayString = new ArrayList();
  iterator(jl);
  iterator(fwy);
  iterator(cs);

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