一、泛型

* 為什么要使用泛型？
- 一般使用在集合上
** 比如現在把一個字符串類型的值放入到集合里面，這個時候，這個值放入到集合之后，失去本事的類型，只能是object類型，
這個時候，比如想要對這個值進行類型轉換，很容易出現類型轉換錯誤，怎么解決這個問題，可以使用泛型來解決。

* 在集合上如何使用泛型
- 常用集合 list ?set ?map
- 泛型語法 集合<String> ?比如 List<String>
* 在泛型里面寫是一個對象，String 不能寫基本的數據類型 比如int (****)
** 寫基本的數據類型對應包裝類

byte -- Byte
short -- Short
int -- Integer
long -- Long
float -- Float
double -- Double
char ? -- Character

boolean -- Boolean

* 在List上使用泛型

List：有序，存入和取出的順序一致，元素都有索引，元素可以重復

????????????????????ArrayList :內部是數組數據結構，不同步。替代了Vector。查詢速度快。

????????????????????linkedList: 內部是鏈表數據結構，不同步。增刪快。

????????????????????Vector:內部是數組數據結構，是同步的。

//遍歷list集合 有三種方式
//普通for循環 ?迭代器 ?增強for

List<String> list=new ArrayList<String>();list.add("hello");list.add("world");list.add("java");//增強for遍歷for (String s : list) {System.out.println(s);}System.out.println("-------------");//普通for遍歷for(int i=0;i<list.size();i++){String s1=list.get(i);System.out.println(s1);}System.out.println("-------------");//迭代器迭代Iterator<String> it=list.iterator();while(it.hasNext()){System.out.println(it.next()); * 在Set上使用泛型

Set:元素不能重復，無序?

????????????????????HashSet：內部數據結構是哈希表，不同步

????????????????????TreeSet：可以對Set集合中的元素進行排序，通過Comparable接口或覆蓋comPareTo方法。

//遍歷set 有兩種方式

//迭代器 ?增強for

Set<String> set = new HashSet<String>();set.add("hello");set.add("world");set.add("java");// 增強forfor (String string : set) {System.out.println(string);}System.out.println("-------------");// 迭代器迭代Iterator<String> it = set.iterator();while (it.hasNext()) {System.out.println(it.next());}結果為: ? ? ?(內部哈希算法排序，無序） hello java world ------------- hello java world * 在map上面使用泛型

- map結構：key-value形式

????????????????? ? Hashtable:內部結構是哈希表，同步。不允許null作為鍵和值。

????????????????? ? HashMap:內部結構是哈希表，不同步。允許null作為鍵和值。

????????????????? ? TreeSet:內部結構是二叉樹，不同步。可以對Map集合中的鍵進行排序。

//遍歷map有兩種方式
//1、獲取所有的key，通過key得到value 使用get方法
//2、獲取key和value的關系

Map<Integer, String> hm = new HashMap<Integer, String>();hm.put(1, "張三");hm.put(2, "李四");hm.put(3, "王五");//獲取所有的key，遍歷key獲取valueSet<Integer> set=hm.keySet();for (Integer integer : set) {System.out.println(integer+"---"+hm.get(integer));}System.out.println("-------------");//獲取key和value的關系Set<Entry<Integer, String>> set2=hm.entrySet();for (Entry<Integer, String> entry : set2) {Integer key=entry.getKey();String value=entry.getValue();System.out.println(key+"---"+value);}

二、泛型定義在方法上

????? ? public <T> void show(T str){ ? ? ? ?}

???????? * 寫在返回值之前 ?void之前 <T>
????????*?表示定義了一個類型 這個類型是 T
????????* 在下面就可以使用這個類型了 ?T

* 定義一個數組，實現指定位置上數組元素的交換

????????public static <T> void swap1(T[] arr ,int a,int b) {
????????T temp = arr[a];
????????arr[a] = arr[b];
????????arr[b] = temp;

????????}

練習:實現一個泛型方法，接受任意一個數組，顛倒數組中所有元素

public static void main(String[] args) {Integer[] integers = { 1, 2, 3, 4, 5, 6, 9, 15 };reverseArr(integers);String[] strings = { "hello", "world", "java" };reverseArr(strings);}public static <T> void reverseArr(T[] arr) {for (int i = 0; i < arr.length / 2; i++) {T t = arr[i];arr[i] = arr[arr.length - 1 - i];arr[arr.length - 1 - i] = t;}System.out.println(Arrays.toString(arr));}

三、泛型在類上的使用

* 在一個類上定義一個類型，這個類型可以在類里面直接使用
* public class TestDemo04<T> {

//在類里面可以直接使用T的類型
T aa;
public void test11(T bb) {}

//寫一個靜態方法 在類上面定義的泛型，不能再靜態方法里面使用
public static <A> void test12(A cc) {}

}

四、泛型的通配符

? ??? ? ? ?:可以對類型進行限定

????????????? ? ? extends E:接收E類型或者E類型的子類型對象 ? ? ? ?上限

????????????? ? ? super E:接收E類型或者E類型的父類型 ? ? ? ? ? ? ? ? ?下限

????? ? 一般存儲元素的時候使用上限，因為這樣取出都是按照上限類型來運算的。不會出現安全隱患。

????? ? 對集合中的元素進行取出操作時，用下限。

五、枚舉的簡介

* 什么是枚舉？
** 需要在一定的范圍內取值，這個值只能是這個范圍內中的任意一個。
** 現實場景：交通信號燈，有三種顏色，但是每次只能亮三種顏色里面的任意一個

* 使用一個關鍵字 enum
** enum Color{
RED,GREEN,YELLOW;
}
* 枚舉的構造方法也是私有的

* 特殊枚舉的操作（了解）
** 在枚舉類里面有構造方法
** 構造方法里面有參數，需要在每個實例上面都寫參數
** 在枚舉類里面有抽象方法
** 在枚舉的每個實例里面都重寫這個抽象方法

六、枚舉的API操作

** name() ：返回枚舉的名稱
** ordinal() ：枚舉的下標，下標從0開始
** valueOf(Class<T> enumType, String name) ：得到枚舉的對象

** 還有兩個方法，但是這兩個方法不在api里面，編譯的時候生成兩個方法
*** valueof(String name) ?轉換枚舉對象
*** values() ?獲得所有枚舉對象數組

* 練習：枚舉對象、枚舉對象下標、枚舉對象名稱表示之間的轉換
- //知道枚舉的對象，得到枚舉名稱和下標
@Test
public void test1() {
//得到枚舉對象
Color col = Color.RED;
//枚舉名稱
String name = col.name();
//枚舉的下標
int idx = col.ordinal();
System.out.println(name+" "+idx);
}

- //知道枚舉的名稱，得到枚舉的對象和下標
@Test
public void test2() {
String name1 = "GREEN";
//得到對象
Color col = Color.valueOf(name1);
//枚舉下標
int idx1 = col.ordinal();
System.out.println(idx1);
}

- //知道枚舉的下標，得到枚舉的對象和名稱
@Test
public void test3() {
int idx2 = 2;
//得到枚舉的對象
Color[] cols = Color.values();
//根據下標得到對象
Color col = cols[idx2];
//得到枚舉的名稱
String name = col.name();
System.out.println(name);
}

七、靜態導入（了解）

* 可以在代碼里面，直接使用靜態導入方式，導入靜態方法或者常量
* import static XX.XX.xxx

import static java.lang.System.out; import static java.util.Arrays.sort; import static java.util.Arrays.toString; public class TestDemo1 {public static void main(String[] args) {out.println("hello");int[] arr1 = {10,1,3,20,15};sort(arr1);//System.out.println(toString(arr1));} }

八、自動拆裝箱

* 裝箱
** 把基本的數據類型轉換成包裝類
* 拆箱
** 把包裝類轉換成基本的數據類型


** //自動裝箱
Integer i = 10;

//自動拆箱
int m = i;

** 在jdk1.4里面如何實現裝箱和拆箱
- //在jdk1.4里面實現拆裝箱
public void test1() {
//裝箱
Integer m = new Integer(10);
//拆箱
int a = m.intValue();
}
** jdk是會向下兼容
- 比如 jdk1.4里面寫的代碼，這個時候到5.0里面也可以運行


** 練習：向下兼容
== 執行的結果是會調用 ?doSomething(double m)
== 首先在jdk1.4里面肯定調用這個方法，如果調用下面的方法，需要類型轉換，但是jdk1.4不能實現自動拆裝箱
== 由于jdk是向下兼容，所以，在jdk1.4調用這個方法，在jdk5.0里面還是會調用這個方法
public static void main(String[] args) {
doSomething(10); ? ?//double......
}
public static void doSomething(double m) {
System.out.println("double......");
}
public static void doSomething(Integer a){
System.out.println("integer.....");
}?

九、增強for循環

* 語法 for(變量類型 ?變量名: 要迭代的數組或集合) {}
- for(String s : list) {
System.out.println(s);
}
* 使用場景： 數組；實現Iterable接口的集合 可以使用增強for循環

* 在集合上使用增強for循環遍歷
list ?set 實現了Iterator接口，所以可以使用增強for循環
map不能使用增強for循環，沒有實現Iterator接口，所以不能使用增強for循環
????????????????????? ? 可以通過Map的entrSet方法或者KeySet方法現獲取到Set集合在使用增強for
* 增強for循環出現目的：為了替代迭代器
** 增強for底層就是迭代器實現的

十、可變參數

* 可變參數可以應用在什么場景：
** 實現兩個數的相加，實現三個數的相加 四個數的相加
-- 如果實現的多個方法，這些方法里面邏輯基本相同，唯一不同的是傳遞的參數的個數，可以使用可變參數

* 可變參數的定義方法：數據類型...數組的名稱
* 理解為一個數組，這個數組存儲傳遞過來的參數
- 代碼
public static void add1(int...nums) {
//nums理解為一個數組，這個數組存儲傳遞過來的參數
//System.out.println(nums.length);
int sum = 0;
//遍歷數組
for(int i=0;i<nums.length;i++) {
sum += nums[i];
}
System.out.println( sum);
}

* 注意的地方
（1）可變參數需要寫在方法的參數列表中，不能單獨定義
（2）在方法的參數列表中只能有一個可變參數
（3）方法的參數列表中的可變參數，必須放在參數最后
- add1(int a,int...nums)

總結

以上是生活随笔為你收集整理的JDK5的一些新特性的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。