java基礎(18):集合、Iterator迭代器、加強for循環、泛型

1. 集合

1.1 集合介紹

集合，集合是java中提供的一種容器，能夠用來存儲多個數據。
在前面的學習中，咱們知道數據多了，可使用數組存放或者使用ArrayList集合進行存放數據。那麼，集合和數組既然都是容器，它們有啥區別呢？

數組的長度是固定的。集合的長度是可變的。
集合中存儲的元素必須是引用類型數據

1.2 ArrayList集合存儲元素

練習一：ArrayList集合存儲5個int類型元素

public static void main(String[] args) { ArrayList<Integer> list = new ArrayList<Integer>(); list.add(111); list.add(111); list.add(111); list.add(111); list.add(111); for(int i=0; i<list.size(); i++){ System.out.println(list.get(i)); } }

練習二：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); } }

1.3 集合的繼承實現關係

查看ArrayList類發現它繼承了抽象類AbstractList同時實現接口List，而List接口又繼承了Collection接口。Collection接口爲最頂層集合接口了。
源代碼：

interface List extends Collection { } public class ArrayList extends AbstractList implements List{ }

這說明咱們在使用ArrayList類時，該類已經把全部抽象方法進行了重寫。那麼，實現Collection接口的全部子類都會進行方法重寫。

Collecton接口經常使用的子接口有：List接口、Set接口
List接口經常使用的子類有：ArrayList類、LinkedList類
Set接口經常使用的子類有：HashSet類、LinkedHashSet類

1.4 Collection接口概述

既然Collection接口是集合中的頂層接口，那麼它定義的全部功能子類均可以使用。查閱API中描述的Collection接口。Collection層次結構中的根接口。Collection表示一組對象，這些對象也稱爲Collection的元素。一些Collection容許有重複的元素，而另一些則不容許，一些Collection是有序的，而另一些則是無序的。

繼續查閱API，發現Collection接口中不少集合的操做方法，那麼這些方法都具體能作什麼呢？

1.5 Collection接口的基本方法

 

 

 這裏咱們不關心具體建立的Collection中的那個子類對象，這裏重點演示的是Collection接口中的方法。

建立集合的格式：

方式1：Collection<元素類型> 變量名 = new ArrayList<元素類型>(); 方式2：Collection 變量名 = new ArrayList();

方式1建立的集合，只能存儲<>中指定的元素類型，該方式爲經常使用方式。

方式2建立的集合，集合的元素類型默認爲Object類型，即任何類型的元素均可以存儲。

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); } } /* * 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); }

2. Iterator迭代器

2.1 Iterator迭代器概述

java中提供了不少個集合，它們在儲存元素時，採用的儲存方式不一樣。咱們要取出這些集合中的元素，可經過一種通用的獲取方式來完成。

Collection集合元素的通用獲取方式：在取元素以前先要判斷集合中有沒有元素，若是有，就把這個元素取出來，繼續在判斷，若是還有就再取出來。一直把集合中的全部元素所有取出。這種取出方式專業術語稱爲迭代。

集合中把這種元素的方式描述在Iterator接口中。Iterator接口的經常使用方法以下：

 

 

 2.2 Iterator迭代方式的代碼體現

在Collection接口描述了一個車箱方法iterator方法，全部Collection子類都實現了這個方法，而且有本身的迭代形式。

 

 

 

public static void main(String[] args) { //1.建立集合對象
          Collection<String> coll = new ArrayList<String>(); coll.add("abc1"); coll.add("abc2"); coll.add("abc3"); coll.add("abc4"); //2.獲取容器的迭代器對象。經過iterator方法。
          Iterator it = coll.iterator(); //3.使用具體的迭代器對象獲取集合中的元素
          while(it.hasNext()){ String s = it.next(); System.out.println(s); } /*
 迭代器for循環形式的使用 for(Iterator it = coll.iterator(); it.hasNext() ){ System.out.println(it.next()); } */ } 

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

2.3 集合元素的向下轉型

學習到這裏，基本知道了Collection接口的簡單使用。但是集合中能夠存儲任何對象，那麼存放進去的數據都仍是原來的類型嗎？固然不是了，所有提高成了Object。

在使用集合時，咱們須要注意如下幾點：

集合中存儲其實都是對象的地址。

集合中能夠存儲基本數值嗎？jdk1.5版本之後能夠存儲了。由於出現了基本類型包裝類，它提供了自動裝箱操做(基本類型--->對象)，這樣，集合中的元素就是基本數值的包裝類對象。

存儲時提高了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()); }

注意：若是集合中存放的是多個對象，這時進行向下轉型會發生類型轉換異常。

提示：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()); }

3. 加強for循環

JDK1.5新特性,加強for循環
JDK1.5版本後,出現新的接口 java.lang.Iterable
Collection開是繼承Iterable
Iterable做用,實現加強for循環

格式:

for( 數據類型 變量名 : 數組或者集合 ){ 　　System.out.println(變量); }

加強for循環用於遍歷Collection和數組。一般只進行遍歷元素，不要在遍歷的過程當中對元素進行增刪操做。

遍歷數組：

String[] str = {"abc","itcast","cn"}; for(String s : str){//遍歷s表示被遍歷到的數組元素 System.out.println(s.length()); }

遍歷集合：

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());
}

好處: 代碼少了,方便對容器遍歷
弊端: 沒有索引,不能操做容器裏面的元素

int[] arr = {3,1,9,0}; for(int i : arr){ System.out.println(i+1); } System.out.println(arr[0]);

加強for循環和老式的for循環有什麼區別？

注意：加強for循環必須有被遍歷的目標。目標只能是Collection或者是數組。

建議：遍歷數組時，若是僅爲遍歷，可使用加強for；若是要都數組的元素進行操做，使用老式for循環能夠經過索引操做

4. 泛型

4.1 泛型的引入

在前面學習集合時，咱們都知道集合中是能夠存聽任意對象的，只要把對象存儲集合後，那麼這時他們都會被提高爲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()); } } }

程序在運行時發生了問題java.lang.ClassCastException
爲何會發生類型轉換異常呢？咱們來分析下：
因爲集合中什麼類型的元素均可以存儲。致使取出時，若是出現強轉就會引起運行時ClassCastExceotion。
怎麼來解決這個問題呢？使用集合時，必須明確集合中元素的類型。這種方式稱爲：泛型。

4.2 泛型的定義與使用

咱們在集合中會大量使用到泛型，這裏來完整的學習泛型知識。

泛型，原來靈活的將數據類型應用到不一樣的類，方法、接口當中。將數據類型做爲參數進行傳遞。

4.2.1 含有泛型的類

定義格式：修飾符 class 類名<表明泛型的變量> { }
例如，API中的ArrayList集合：

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

使用格式：建立對象時，肯定泛型的類型
例如，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){ } }

4.2.2 含有泛型的方法

定義格式：修飾符 <表明泛型的變量> 返回值類型 方法名(參數){ }
例如，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){ }

4.2.3 含有泛型的接口

定義格式：修飾符 interface 接口名<表明泛型的變量>{}

例如，API中的Iterator迭代器接口

public interface List <E>{ public abstract E next(); }

使用格式：

一、定義類時肯定泛型的類型

例如：

public final class Scanner implements Iterator<String>{ public String next(){} }

此時，變量E的值就是String類型。

2.始終不肯定泛型的類型，直到建立對象時，肯定泛型的類型

例如

ArrayList<String> list = new ArrayList<String>(); Iterator<String> it = list.iterator();

 

此時，變量E的值就是String類型。

public interface Iterator<String>{ public abstract String next(); }

4.3 使用泛型的好處

將運行時期的ClassCastException，轉移到了編譯時期變成了編譯失敗。
避免了類型強轉的麻煩。
演示下列代碼：

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類型
 } } }

4.4 泛型通配符

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()); } }

4.5 泛型的限定

/* * 將的酒店員工,廚師,服務員,經理,分別存儲到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(); } } }