----------- android培訓、java培訓、java學習型技術博客、期待與您交流！ ------------
1. 靜態導入
1) 導入類的靜態屬性
爲了簡化對類的靜態成員的引用，JDK 5.0增加的靜態導入語法用於導入類的某個靜態屬性或方法。
語法：
import static 包名.類名.靜態屬性|靜態方法|*
例如：
導入System類的靜態屬性out
import static java.lang.System.out
在程序中直接使用out.print(str) 輸出到控制檯
2)導入Math類的所有靜態方法
import static java.lang.Math.*
在程序中使用 abs(num) 直接調用類的靜態成員方法
int num = abs(-10);
2，自動裝箱/拆箱
在java中有8種基本數據類型，爲了方便將基本數據類型當做對象來處理，sun公司定義了對應的包裝類，如：int Integer
包裝類就是對基本數據類型值的封裝
JDK5.0之前，開發人員若想將一個基本數據類型賦值給包裝類變量, 需要進行手動包裝， 如： Integer x = new Integer(98);
JDK5.0中定義了新特性自動拆箱與自動裝箱，開發人員可以直接將基本數據類型的值直接賦值給包裝類對象，反之一樣。不需要任何的手動裝箱與拆箱。
典型應用：
List list = new ArrayList();
list.add(19);
Int num = (Integer) list.get(0);
基本數據類型的包裝類
int --> Integer
byte --> Byte
short --> Short
long --> Long
char --> Character
double --> Double
float --> Float
boolean --> Boolean
1) Integer x = 1; x = x + 1; 經歷了什麼過程？ 裝箱à 拆箱 à 裝箱
2) 爲了優化，虛擬機爲包裝類提供了緩衝池， Integer池的大小 -128~127 一個字節的大小
3) String池
Java爲了優化字符串操作 提供了一個緩衝池
面試題：
String s = “abc” 和 String s = new String(“abc”) 的區別
String s = new String(“abc”) 創建了幾個對象
String s = “a” + “b” + “c” + “d” 創建了幾個對象
String s1 = “a” String s2 = “b” String s3 = s1 + s2; s3==”ab”?
/*1. String s = "abc"， 虛擬機首先會檢查String池裏有沒有"abc"對象(通過equals方法)
// 如果有，直接返回引用，如果沒有，會在池裏創建一個“abc”對象，並返回引用
String s1 = "abc";
String s2 = "abc";
System.out.println(s1==s2); // result: true
*/
/* 2. String str = new String("abc");
不管緩衝池是否有"abc", 都會在堆內存創建一個"abc"對象，返回引用
// 此時，負責檢查並維護緩衝池，其實堆內存的對象是緩衝池中"abc"對象的一個拷貝
String s1 = new String("abc");
String s2 = new String("abc");
System.out.println(s1==s2); // result: false
*/
/* 3. String s = "a" + "b" + "c" + "d"; java編譯器有個合併已知量的優化功能
// 在編譯階段就把"a" + "b" + "c" + "d" 合併爲 ”abcd“
String s = "a" + "b" + "c" + "d";
// String s = "abcd";
System.out.println(s=="abcd");// result: true
*/
/* 4. String s1 = "a"; String s2 = "b"; String s3 = s1 + s2;
// String是常量，不能相加的，java如何實現的？
StringBuilder sb = new StringBuidler(s1);
sb.append(s2);
s3 = sb.toString();
也就是說實際上s3是方法返回的String對象
凡是方法返回的字符串對象都是在堆內存的
*/
String s1 = "a";
String s2 = "b";
String s3 = s1 + s2; // 堆內存的對象
System.out.println(s3=="ab");// result: false
3. 增強for循環
JDK5.0以前，遍歷數組或集合中的元素都需要些迭代的代碼JDK5.0中定義了一種新的語法——增強for循環，專門用於對
存儲對象的容器進行迭代(數組和集合)，注意，對於集合，只
能對實現了Iterable接口的對象進行迭代，原因在於，Iterable
接口中定義了iterator方法
語法格式：
for(變量類型 變量 ：需迭代的數組或集合){
// 使用變量引用容器中的元素
}
實現原理：
獲得對象的迭代器，針對集合對象進行迭代，將每次迭代的值付給for循環
中定義的變量
1，增強for循環迭代數組
String [] arr = {"a", "b", "c"}; //數組的靜態定義方式，只試用於數組首次定義的時候
// 傳統方式
for(int i=0; i<arr.length; i++) {
// i依次表示數組的角標
String s = arr[i];
System.out.println(s);
}
System.out.println("-------------------------------------");
// 在jdk5中我們可以使用增強for循環迭代
// 增強for循環括號裏寫兩個參數，第一個是聲明一個變量，變量類型必須是數組元素的類型
// 第二個就是需要迭代的容器
// for循環會循環容器的length次, 每次都將容器的第n-1個元素賦值給聲明的變量
for(String s : arr) {
// 循環體， 執行arr.length
// 每次都將arr中的第n-1個元素給s
System.out.println(s); //
}
,2，增強for循環迭代單列集合collection
List list = new ArrayList();
list.add("aaa");
list.add("bbb");
list.add("ccc");
// 傳統方式1
/* 1.獲得迭代器
Iterator iter = list.iterator();
// 2.循環判斷迭代器是否有下一個
while(iter.hasNext()) {
String str = (String) iter.next(); // 將迭代器的指針移向下一個，並將迭代當前指向的元素返回
System.out.println(str);
}
*/
// 傳統方式2
for(Iterator iter=list.iterator(); iter.hasNext(); ) {
String s = (String) iter.next();
System.out.println(s);
}
System.out.println("--------------------------------");
// 增強for循環, 沒有使用泛型的集合能不能使用增強for循環迭代？能
for(Object obj : list) {
String s = (String) obj;
System.out.println(s);
}
3，增強for循環迭代雙列集合Map
Map map = new HashMap();
map.put("a", "aaa");
map.put("b", "bbb");
map.put("c", "ccc");
// 傳統方式迭代1
// 1. 獲得所有的key
Set keys = map.keySet();
// 2.迭代keys獲得所有的key
Iterator iter = keys.iterator();
while(iter.hasNext()) {
String key = (String) iter.next(); // a b c
// 3.根據key獲得對應的value
String value = (String) map.get(key);
System.out.println(key + "=" + value);
}
System.out.println("---------------------------------");
// 傳統方式2，必須掌握這種方式
// 1.獲得所有的鍵值對Entry對象
Set entrys = map.entrySet();
// 2.迭代出所有的entry
iter = entrys.iterator();
while(iter.hasNext()) {
Map.Entry entry = (Entry) iter.next();
// 分別獲得key和value
String key = (String) entry.getKey();
String value = (String) entry.getValue();
System.out.println(key + "=" + value);
}
System.out.println("-------------------------------------");
System.out.println("增強for循環迭代，");
// 增強for循環迭代，
// 原則上map集合是無法使用增強for循環來迭代的，
// 因爲增強for循環只能針對實現了Iterable接口的集合進行迭代
// Iterable是jdk5中新定義的接口，就一個方法iterator方法
// 只有實現了Iterable接口的類，才能保證一定有iterator方法
// java有這樣的限定是因爲增強for循環內部還是用迭代器實現的
// 而實際上，我們可以通過某種方式來使用增強for循環
for(Object obj : map.entrySet()) {
// obj 依次表示Entry
Map.Entry entry = (Entry) obj;
System.out.println(entry.getKey() + "=" + entry.getValue());
}
4，迭代集合時應該注意的問題
// 在使用迭代器迭代集合的過程中，不能對集合進行增刪操作
@Test
public void test4() {
List list = new ArrayList();
list.add("wangwu");
list.add("zhangsan");
list.add("lisi");
Iterator iter = list.iterator();
while(iter.hasNext()) {
String name = (String) iter.next();
if("wangwu".equals(name)) {
// 從集合中刪掉
//list.remove(name);
// 迭代過程中刪除元素需要調用迭代器的方法
iter.remove(); // 刪除我迭代的集合被我迭代的最後一個元素
}
}
// 1 2 4
System.out.println(list.size());
}
@Test
public void test5() {
List list = new ArrayList();
list.add("aa");
list.add("bb");
// 使用ListIterator迭代器
ListIterator listIterator = list.listIterator();
while(listIterator.hasNext()) {
listIterator.next();
// 迭代過程中增加元素
listIterator.add("cc");
}
System.out.println(list.size());
}
5，增強for循環注意的問題//在使用增強for循環時，不能對元素進行賦值
int[] arr = {1,2,3};
for(int num : arr) {
num = 0;
}
System.out.println(arr[1]);
4. 可變參數
從JDK 5開始, Java 允許爲方法定義長度可變的參數。
即方法定義一個形參，但是可以傳入0~n個實參，
方法定義如下：
public void foo(int … args){
args
}
Util包中的工具類Arrays的asList(Object[])方法就將形參定義爲可變參數
調用此方法分別測試傳入多個參、傳引用類型數組、傳基本數據類型數組、傳數組又傳參的情況
細節：
調用可變參數的方法時, 編譯器將自動創建一個數組保存傳遞給方法的
可變參數，因此，程序員可以在方法體中以數組的形式訪問可變參數
可變參數只能處於參數列表的最後, 因此一個方法最多隻能有一個可變的參數
1，設計一個方法求n個數的和
public static int getSum(int... arr) {
// 可變參數在方法中仍被看做一個數組
int sum = 0;
for(int num : arr)
sum += num;
return sum;
}
2)Arrays.asList爲例演示傳入不同參數的情況
// list長度爲3
List list = Arrays.asList("a","b","c");
// list長度爲1， 因爲考慮1.4語法
String[] arr = {"a","b","c"};
List list = Arrays.asList(arr);
// 同時符合1.4和1.5的語法,此時會優先考慮1.4的語法
// 原因是有了新功能要保證以前的代碼不出錯，向後兼容
// 現在就需要將arr作爲一個元素存入集合
Object obj = arr;
List list2 = Arrays.asList(obj); // 此時只符合1.5的語法，不符合1.4的語法，沒有歧義
List list3 = Arrays.asList(new Object[]{arr}); // 優先考慮1.4，所以數組會拆開
//System.out.println(list3.size());
// 基本數據類型數組只符合1.5的語法
int[] nums = {1,2,3};
list = Arrays.asList(nums);
System.out.println(list.size());