黑馬程序員——【Java基礎】——泛型、Utilities工具類、其他對象API

2019-11-14 21:15:48

字體：大中小

來源：轉載

供稿：網友

黑馬程序員——【java基礎】——泛型、Utilities工具類、其他對象API

---------- android培訓、java培訓、期待與您交流！ ----------

一、泛型

　　（一）泛型概述

　　1、泛型：JDK1.5版本以后出現的新特性，用于解決安全問題，是一個類型安全機制。

　　2、泛型技術是給編譯器使用的技術，用于編譯時期，確保類型的安全。

　　3、泛型的擦除：運行時，會將泛型去掉，生成class文件中的是不帶泛型的，這個稱為“泛型的擦除”。擦除泛型的原因是為了兼容運行時的類加載器。

　　4、泛型的好處：（1）將運行時期出現的問題ClassCastException，轉移到了編譯時期。方便于程序員解決問題，讓運行時期問題減少、安全。（2）避免了強制轉換的麻煩。

　　5、泛型的格式：通過<>來定義要操作的引用數據類型，例如：ArrayList<String>表示存入ArrayList集合中的元素必須為String類型

　　6、泛型補償：在運行時，通過反射通過獲取元素的類型（如Class clazz = “aa”.getClass(); clazz.getName();），不用使用再強制轉換類型了。

　　7、在使用Java提供的對象時，什么時候寫泛型呢？

　　通常在集合框架中很常見，只要見到<>就要定義泛型。其實<>是用來接收引用類型的，但使用集合時，將集合中要存儲的數據類型作為參數傳遞到<>中即可。

　　8、關于參數化類型的幾點說明：

　　（1）參數化類型與原始類型的兼容性

　　* 參數化類型可引用一個原始類型的對象，編譯只是報警告。如：Collection<String>coll = new Vector();

　　* 原始類型可引用一個參數化類型的對象，編譯報告警告。如：Collectioncoll = new Vector<String>(); 原來的方法接受一個集合參數，新類型也要能傳進去。

　　（2）參數的類型不考慮類型參數的繼承關系：

　　Vector<String> v = newVector<Objec>();//錯誤的。不寫Object沒錯，寫了就是明知故犯

　　Vector<Objec> v = newVector<String>();//錯誤的

　　（3）編譯器不允許創建泛型變量的數組。即在創建數組實例時，數組的元素不能使用參數化的類型。如：Vector<Integer>vectorList[] = newVector<Integer>[10];//錯誤的

　　（二）泛型限定

　　1、通配符“?”

　　當傳入的類型不確定時，可以使用通配符“?”，也可以理解為占位符。使用通配符可以不用明確傳入的類型，這樣在使用泛型類或泛型方法時，提高了擴展性。

　　2、泛型限定

　　對于一個范圍內的一類事物，可以通過泛型限定的方式定義，有兩種方式：

　　（1）? extends E：可接收E類型或E類型的子類型，稱為上限界定。如：ArrayList<? extends Number> x = new ArrayList<Integer>();

　　（2）? super E：可接收E類型或E類型的父類型；稱為下限界定。如：ArrayList<? super Integer> x = new ArrayList<Number>();

　　3、泛型限定代碼示例：

 1 //人  父類 2 class Person{ 3     PRivate String name; 4     Person(String name){ 5         this.name = name; 6     } 7     public String getName(){ 8         return name; 9     }10 }11 //學生  繼承父類12 class Student extends Person{13     Student(String name){14         super(name);15     }16 }17 class  Demo{18     public static void main(String[] args){19         ArrayList<Person> al = new ArrayList<Person>();20         al.add(new Person("abc1"));21         al.add(new Person("abc2"));22         al.add(new Person("abc3"));23         printColl(al);//父類對象的元素集合可以調用24         ArrayList<Student> al1 = new ArrayList<Student>();25         al1.add(new Student("abc--1"));26 al1.add(new Student("abc--2"));27         al1.add(new Student("abc--3"));28         printColl(al1);  //子類對象的元素集合也可以調用29     }30 //定義一個上限的泛型方法31 public static void printColl(Collection<? extends Person> al){32         Iterator<? extends Person> it = al.iterator();33         while(it.hasNext()){34             System.out.println(it.next().getName());35         }36     }37 }

　　（三）泛型類

　　1、什么時候定義泛型類來完成擴展？

　　當類中要操作的引用數據類型不確定的時候，早期（1.4version）之前定義Object類來完成擴展。現在（version1.5）開始通過定義泛型來完成擴展。

　　2、泛型類定義的泛型，在整個類中有效。如果被方法使用，那么泛型類的對象明確要操作的具體類型后，所有要操作的類型就已經固定了。

　　3、類級別的泛型是根據引用該類名時指定的類型信息來參數化類型變量的。

　　4、泛型類示例代碼：

 1 //定義工具泛型類Utils 2 class Utils<QQ>{ 3     private QQ q; 4     public void setObject(QQ q){ 5     this.q == q; 6 } 7 Public QQ getObject(){ 8     Return q; 9 }10 }11 public class GenericClassDemo{12     public static void main(String[] args) {13         Utils<Worker> u = new Utils<Worker>();14         u.setObject(new Worker());15         Worker w = u.getObject();16     }17 }18 class Worker extends Person {19     public Worker() {20         super();21 }22 public Worker(String name, int age) {23         super(name, age);24     }25     @Override26     public String toString() {27     return "Worker:"+getName()+":"+getAge();28     }29 }

　　（四）泛型方法

　　1、一般泛型方法

　　（1）為了讓不同方法可以操作不同類型，而且類型還不確定，那么可以將泛型定義在方法上。

　　（2）方法中上定義的泛型可以不和類泛型相同。

　　（3）泛型方法示例：

1 class Demo{2     public <T> void show( T t){3     System.out.println(t);4     }5     Public <Q> void print( Q q){6     System.out.println(q);7     }8 }

　　2、靜態方法泛型

　　（1）特殊之處：Static方法不可以訪問類上定義的泛型。

　　（2）如果靜態方法操作的應用數據類型不確定，可以將方法泛型定義在方法上。

　　（3）如果靜態方法使用泛型，只能將泛型定義在方法上。

　　（4）泛型代碼示例：

1 public static <W> void method( W t){ 2        System.out.println( “method” + t ); 3 }

　　3、泛型方法的特點

　　（1）位置：用于放置泛型的類型參數的<>應出現在方法的其他所有修飾符之后和在方法的返回類型之前，也就是緊鄰返回值之前，按照慣例，類型參數通常用單個大寫字母表示。

　　（2）只有引用類型才能作為泛型方法的實際參數。

　　（3）除了在應用泛型時可以使用extends限定符，在定義泛型時也可以使用extends限定符。

　　（4）普通方法、構造函數和靜態方法中都可以使用泛型。

　　（5）可以用類型變量表示異常，稱之為參數化的異常，可用于方法的throws列表中，但是不能用于catch子句中。

　　（6）在泛型中可同時有多個類型參數，在定義它們的<>中用逗號分開。

二、Utilities工具類

　　（一）概述

　　Utilites工具類包括：類Collections和類Arrays。它們包含的方法都是靜態方法，不要創建對象，直接可以用類名調用。

　　（二）Collections

　　1、Collections是用于對“集合”進行操作的工具類。它里邊的方法都是靜態的，不需要創建對象。

　　2、Collections常見方法

　　（1）查找

　　max(Collection<? extends T> coll)：根據集合的自然順序，獲取coll集合中的最大元素

　　max(Collection<? extends T> coll,Comparator<? super T> comp)：根據指定比較器comp的順序，獲取coll集合中的最大元素

　　int binarySearch(Lsit<? extends Comparable<? super T>> list,Tkey)：二分法搜索list集合中的指定對象

　　（2）替換

　　void fill(List<? super T> list, T obj)：將list集合中的全部元素替換成指定對象obj

　　boolean replaceAll(List<T> lsit,T oldVal,T newVal)：用newVal替換集合中的oldVal值

　　void swap(Listlist,int i,int j);/在指定列表的指定位置處交換元素

　　（3）排序：

　　void shuffle(List<?> list)：使用默認隨機源對list集合中的元素進行隨機排序

　　void sort(Lsit<T> list)：根據自然順序對list集合中的元素進行排序

　　void sort(List<T> lsit,Comparator<? super T> c)：根據指定比較器c的排序方式對list集合進行排序

　　（4）反轉

　　reverse(List<?> list)：反轉list集合中元素的順序

　　Comparator reverSEOrder()：返回一個比較器，強行逆轉了實現Comparable接口的對象的自然順序

　　Comparator reverseOrder(Comparator<T> cmp)：返回一個比較器，強行逆轉了指定比較器的順序

　　（5）同步的集合

　　synchronizedList(List<T> list)：返回支持的同步（線程安全的）List集合

　　synchronizedList(Map<K,V> m)：返回支持的同步（線程安全的）Map集合

　　（三）Arrays

　　1、Arrays是用于操作數組的工具類，它包括的方法也全是靜態的，不需要創建對象。

　　2、Arrays常見方法

　　（1）數組轉成集合

　　Lsit<T> asList(T... a)：將數組轉換為集合。

　　注意：① 將數組轉換成集合，不可使用集合的增刪方法，因為數組的長度是固定的。如果進行增刪操作，則會產生UnsupportedOperationException的編譯異常。② 如果數組中的元素都是對象，則轉成集合時，直接將數組中的元素作為集合中的元素進行存儲。③ 如果數組中的元素都是基本數據類型，那么會將該數組作為集合中的元素進行存儲。

　　（2）查找、替換和排序

　　binarySearch()：二分查找方法。

　　fill()：替換方法。

　　sort()：排序方法

　　（3）Arrays.toString()：可以接收各種數組類型參數，并返回指定數組內容的字符串表現形式。

　　3、數組轉成集合，代碼示例：

 1 class  ArraysDemo{ 2     public static void main(String[] args){ 3         int[] arr = {2,4,5}; 4         System.out.println(Arrays.toString(arr));//轉換為字符串形式 5         String[] arr = {"abc","cc","kkkk"};//字符串數組 6         List<String> list = Arrays.asList(arr); 7         sop("contains:"+list.contains("cc"));//判斷是否存在"cc"這個元素 8         Integer[] nums = {2,4,5}; 9         List<Integer> li = Arrays.asList(nums);10         sop("asList--Integer[]轉集合:" + li);11     }12 　　//打印方法13     public static void sop(Object obj) {14         System.out.println(obj);15     }16 }

　　（四）集合轉數組

　　1、集合轉數組：使用的是Cellction接口中的toArray方法。定義格式：<T> T[] toArray(T[] a);

　　2、集合轉數組：可以對集合中的元素操作的方法進行限定，不允許對其進行增刪。

　　3、toArray方法需要傳入一個指定類型的數組，長度如何定義呢？

　　（1）如果數組長度小于了集合的size，方法會創建一個同類型并和集合相同size的數組。

　　（2）如果數組長度大于了集合的size，那么該方法會使用指定的數組存儲集合中的元素，其他默認為null。

　　4、代碼示例：

 1 import java.util.ArrayList; 2 import java.util.Arrays; 3 import java.util.List; 4 public class ToArray { 5     public static void main(String[] args) { 6         List<String> list = new ArrayList<String>(); 7         list.add("abc1"); 8         list.add("abc2"); 9         list.add("abc3");10         String[] arr = list.toArray(new String[list.size()]);    11         System.out.println(Arrays.toString(arr));12     }13 }

三、JDK1.5新特性

　　（一）增強型for循環

　　1、格式：

　　for( 數據類型變量名 : Collection集合或者數組) {

　　執行語句

　　}

　　2、說明

　　（1）對集合進行遍歷。只能獲取集合元素。但是不能對集合進行操作。可以看作是迭代器的簡寫形式。

　　（2）迭代器除了遍歷，還可以進行remove集合中元素的動作。如果使用ListIterator，還可以在遍歷過程中對集合進行增、刪、改、查的操作。

　　3、傳統for和高級for的區別：

　　（1）傳統for循環可以完成對語句的多次操作，因為可以控制循環增量條件。

　　（2）高級for循環是一種簡化形式，它必須有遍歷目標，該目標要么是array或Collection單列集合，不可以直接遍歷Map集合，但可以將Map集合轉化為單列的Set集合，就可以使用。例如：

1 for( Map.Entry<Integer , String>) me : map.entrySet()){2     Integer key = me.getKey();3     String value = me.getValue();4     System.out.println(key + “::” +value);5 }

　　（二）函數可變參數

　　1、在JDK1.5版本后，就提供了一個新特性：可變參數。用來解決一個方法在參數列表中傳入多個參數，個數不確定而每次都要復寫該方法的問題。

　　2、可變參數其實就是數組參數的簡寫形式。只要將要操作的元素作為參數傳遞，就可以隱式將這些參數封裝成了數組。

　　3、注意：可變參數一定要定義在參數列表的最后面。

　　4、示例代碼如下

1 public static int newAdd(int a , int&hellip; arr){2     int sum = 0;3     for( int i = 0 ; i < arr.length ; i ++){4         sum + = arr[i];5 }6 return sum;7 }

　　（三）靜態導入

　　1、寫法示例：import static java.util.Collections.*;

　　加上static導入的是某一個類中所有的靜態成員。這樣寫在調用該類的靜態方法時可以不用再寫類名。如Collections.max(list)可以簡寫為max(list)。

　　2、注意：

　　（1）當導入的兩個類中有同名成員時，需要在成員前加上相應的類名。

　　（2）當類名重名時，需要指定具體包名。當方法重名時，指定具體所屬的對象或者類。

　　3、靜態導入示例：

 1 import java.util.ArrayList; 2 import java.util.Collections; 3 import java.util.List; 4 import static java.util.Collections.*;//靜態導入，其實到入的是類中的靜態成員。 5 import static java.lang.System.*; 6 public class StaticImportDemo { 7     public static void main(String[] args) { 8         List<String> list = new ArrayList<String>();     9         list.add("abc3");10         list.add("abc7");11         list.add("abc1");12         out.println(list);13         sort(list);    14         System.out.println(list);15         String max = max(list);16         System.out.println("max="+max);    17     }18 }

三、其他對象API

　　（一）System類

　　1、概述：System是描述系統一些信息的類，類中的屬性和方法都是static的。

　　2、字段摘要

　　　　out：標準輸出流。默認是控制臺。

　　　　in：標準輸入流。默認是鍵盤。

　　3、static方法

　　（1）Properties getProperties()：獲取系統的屬性信息。

　　（2）String getProperty(String key)：獲取指定屬性信息

　　（3）String setProperty(String key , String value)：在系統內定義特有信息。

　　（4）Long currentTimeMillis()：獲取當前時間毫秒值。

　　（二）Runtime類