黑马程序员--Java高新技术--JDK1.5新特性(上)

JDK 1.5后新特性


1.增强for循环


增强for循环是JDK 1.5 出现的   它的出现是为了简化书写.


增强for循环:foreach语句,foreach简化了迭代器


格式:for(元素类型 变量名: Collection集合或数组) {
  
}

增强for循环和传统for循环的区别:   
 
增强for在使用时,必须要明确被遍历的目标.这个目标可以是Collection集合或者数组,如果遍历Collection集合,在遍历的过程中还需要对元素进行操作,例如删除等,这就需要使用迭代器.

如果遍历数组,并且需要对数组元素进行操作,建议使用传统for循环因为可以定义角标,通过角标操作数组元素,如果只为了遍历获取,可以简化成增强for循环,它的出现是为了简化书写.

增强for循环不能直接遍历map集合.


如果要用增强for循环遍历map集合,就需要将map集合转成set集合然后再使用增强for循环对其进行遍历.

1).作用:对存储对象的容器进行迭代:  数组   collection   map

1.增强for循环遍历数组:

[java] view plaincopyprint?

1. <span style="white-space:pre">            </span>int[] arr = {1,2,3,4};  
2.             for(int in : arr){  
3.              System.out.println(in);  
4.             }  

<span style="white-space:pre"></span>int[] arr = {1,2,3,4};for(int in : arr){ System.out.println(in);}

2.增强for循环遍历单列集合Collection:

[java] view plaincopyprint?

1. <span style="white-space:pre">            </span>List list = new ArrayList();  
2.             list.add("a");  
3.             list.add("b");  
4.             list.add("c");  
5.             for(Object obj : list){  
6.                 String s = (String) obj;  //向下转型    String类重写了toString()方法  
7.                 System.out.println(s);  
8.             }  

<span style="white-space:pre"></span>List list = new ArrayList();list.add("a");list.add("b");list.add("c");for(Object obj : list){String s = (String) obj;  //向下转型    String类重写了toString()方法System.out.println(s);}

3.增强for循环遍历Map:

[java] view plaincopyprint?

1. <span style="white-space:pre">            </span>Map map = new HashMap();  
2.             map.put("a","aa","aaa");  
3.         //传统方式遍历:  
4.           
5.               
6.             Set entrys = map.entrySet();//获得所有的键值对Entry对象  
7.             iter = entrys.iterator();//迭代出所有的entry  
8.             while(iter.hasNext()){  
9.                 Map.Entry entry = (Entry)iter.next();  
10.                 String key = (String)entry.getKey();//分别获得key和value  
11.                 String value = (String)entry.getValue();  
12.                 System.out.println(key + " = " + value);  
13.             }  
14.               
15.         //增强for循环遍历:  
16.           
17.             //由于增强for循环只能对实现了Iterable接口的集合进行遍历,增强for循环底层是iterator方法实现的.   

<span style="white-space:pre"></span>Map map = new HashMap();map.put("a","aa","aaa");//传统方式遍历:Set entrys = map.entrySet();//获得所有的键值对Entry对象iter = entrys.iterator();//迭代出所有的entrywhile(iter.hasNext()){Map.Entry entry = (Entry)iter.next();String key = (String)entry.getKey();//分别获得key和valueString value = (String)entry.getValue();System.out.println(key + " = " + value);}//增强for循环遍历://由于增强for循环只能对实现了Iterable接口的集合进行遍历,增强for循环底层是iterator方法实现的. 

[java] view plaincopyprint?

1. <span style="white-space:pre">            </span>//我们可以通过一种方式来用增强for循环对其遍历  
2.             for(Object obj : map.entrySet()) {  
3.                 Map.Entry entry = (Entry) obj;  // obj 依次表示Entry  
4.                 System.out.println(entry.getKey() + "=" + entry.getValue());  
5.             }  

<span style="white-space:pre"></span>//我们可以通过一种方式来用增强for循环对其遍历for(Object obj : map.entrySet()) {Map.Entry entry = (Entry) obj;  // obj 依次表示EntrySystem.out.println(entry.getKey() + "=" + entry.getValue());}

4.增强for循环注意问题：在使用增强for循环时，不能对元素进行赋值；

[java] view plaincopyprint?

1. <span style="white-space:pre">                </span>int[] arr = {1,2,3};  
2.                 for(int num : arr) {  
3.                     num = 0; //不能改变数组的值  
4.                 }  
5.                 System.out.println(arr[1]); //2  

<span style="white-space:pre"></span>int[] arr = {1,2,3};for(int num : arr) {num = 0; //不能改变数组的值}System.out.println(arr[1]); //2

----------------------------------------------------------------------------------------------------------------------------

2.可变参数

可变参数的出现解决了一个方法接受的参数个数不固定的问题.



格式:
修饰符 返回值 方法名(可变参数...变量名){

}

[java] view plaincopyprint?

1. <span style="white-space:pre">        </span>public class Demo {   
2.   
3.             public static void main(String[] args) {   
4.   
5.                 System. out.println(add(1, 2));   
6.   
7.                 System. out.println(add(1, 2, 3));   
8.   
9.             }   
10.   
11.             public static int add(int x,int... args){   
12.   
13.                     int sum = x;   
14.   
15.                 for(int i = 0; i < args.length; i++){   
16.                     sum += args[i];   
17.                 }   
18.                 return sum;   
19.             }   
20.         }   

<span style="white-space:pre"></span>public class Demo { public static void main(String[] args) { System. out.println(add(1, 2)); System. out.println(add(1, 2, 3)); } public static int add(int x,int... args){ int sum = x; for(int i = 0; i < args.length; i++){ sum += args[i]; } return sum; } } 

可变参数的原理： 


调用可变参数的方法时, 编译器将自动创建一个数组保存传递给方法的可变参数。 


因此，程序员可以在方法体中以数组的形式访问可变参数可变参数只能处于参数列表的最后。 


所以一个方法最多只能有一个可变参数。




注意:
1.这里的变量其实是一个数字,会自动把参数封装成数组的元素.

2.如果一个方法中有可变参数,那么可变参数只能是参数列表中的最后一个.

3.可变参数只能在参数中只能有一个。

-----------------------------------------------------------------------------------------

3.静态导入


静态导入可以导入静态方法，这样就不必写类名而可以直接省略类名调用静态方法了。




语法：import static 包名.类名.静态方法; 




也可以直接导入某个类中的所以静态方法。 


语法：import static 包名.类名.*; 


代码示例:

[java] view plaincopyprint?

1. <span style="white-space:pre">        </span>import static java.lang.Math.*;   
2.   
3.         import static java.lang.System.out;   
4.   
5.         public class StaticImport {   
6.   
7.             public static void main(String[] args) {   
8.   
9.                 out.println("接近数最小值： "+floor(PI));   
10.   
11.                 out.println("接近数最大值： "+ceil(PI));   
12.   
13.                 out.println("2的3次幂："+pow(2, 3));   
14.   
15.                 out.println("四舍五入："+round(PI));   
16.   
17.             }   
18.   
19.         }   

<span style="white-space:pre"></span>import static java.lang.Math.*; import static java.lang.System.out; public class StaticImport { public static void main(String[] args) { out.println("接近数最小值： "+floor(PI)); out.println("接近数最大值： "+ceil(PI)); out.println("2的3次幂："+pow(2, 3)); out.println("四舍五入："+round(PI)); } } 

好处： 

使用静态导入可以简化程序对类静态属性和方法的调用，并且简化了程序代码的书写。
弊端:

如果我们自己定义了一个类且定义了一个方法,和导入的类的静态方法名一样就会出项调用的不确定性,JVM不知道到底是调哪个方法.

--------------------------------------------------------------------------------------------


4.自动拆装箱


基本数据类型只能做一些就基本的运算,将其转换成对应的包装类对象,是对象就可以调用方法,这样就可以进行更多的运算.
int      Integer
char     Character
byte     Byte
short    Short
long     Long
float    Float
double   Double
boolean  Boolean

包装类:  对基本数据类型进行包装

两个作用:

1. 将基本数据类型包装成对象------基本类型-----Object类转换
2. 包装类可以在基本数据类型和字符串之间做转换

自动装箱:就是将基本类型变量直接赋值给其对应的包装类变量.

自动拆箱:就是将以包装类变量直接赋值给其对应的基本类型变量,正好相反.

代码示例:

[java] view plaincopyprint?

1. <span style="white-space:pre">            </span>public class Demo1 {  
2.               
3.                 public static void main(String[] args) {  
4.                     Integer it = 20;//自动装箱  
5.                      it += 20; //自动拆箱  
6.                     System.out.println(it);  
7.                 }  
8.           
9.             }