赵雅智_Java JDK 5.0 新特性

静态导入
自动装包/拆包
for-each循环
可变参数

 

静态导入

JDK 1.5 增加的静态导入语法用于导入指定类的某个静态属性值(方法)或全部静态属性值(方法)

语法：

Import static 包名.类名.静态属性|静态方法|*

静态导入语句使用 import static 语句

• 导入指定类的单个静态属性：import static java.lang.System.out
• 导入指定类静态方法：import static java.lang.Math.max
• 导入指定类全部静态属性和方法：import static java.lang.Math.*

package com.hbsi.base;

import static java.lang.System.out;
import static java.lang.Math.*;

public class Demo1 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		out.println("hello world");
		out.println(PI);
		System.out.println(Math.sqrt(4));//平方根
		

	}

}

自动装包/拆包

自动装箱(autoboxing)：把一个基本数据类型直接赋给对应的包装类变量, 或者赋给 Object 变量

自动拆箱：把包装类对象直接赋给一个对应的基本类型变量

典型应用：
List list = new ArrayList();
list.add(1);
int j = (Integer)list.get(0);

package com.hbsi.base;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class Demo2 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Integer i=1; //自动装箱
		//Integer i=new Integer(1);
		
		int j=i;  //自动拆箱
		
		//应用
		List list=new ArrayList();
		list.add(1); //list.add(new Integer(1));
		list.add(2);
		list.add(3);
		
		Iterator it=list.iterator();
		
		while(it.hasNext()){
			int num=(Integer)it.next();
			System.out.println(num);
		}
		
		//int num=(Integer)list.get(0);

	}

}

 

for-each循环

引入增强for循环的原因：

在JDK5以前的版本中，遍历数组或集合中的元素，需先获得数组的长度或集合的迭代器，比较麻烦！
因此JDK5中定义了一种新的语法——增强for循环，以简化此类操作。增强for循环只能用在数组、或实现Iterator接口的集合类上

使用 foreach 循环遍历数组和集合元素时, 无须获得数组和集合长度, 无须根据索引来访问数组元素和集合元素, foreach 循环自动遍历数组和集合的每个元素

语法格式：
for ( type 变量名：集合变量名 )  { … }
           for(type varName : array | collection){
                  //varName 自动迭代访问每一个元素
            }

package com.hbsi.base;

public class Person{
	private String name;
	private int age;
	
	public Person(String name,int age){
		this.name=name;
		this.age=age;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}
	

}

 

package net.csdn.high;

import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

import org.junit.Test;

public class ForDemo {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub

		ForDemo fd = new ForDemo();
		fd.TeseArr();
		fd.TeseObj();
		fd.TestList();
		fd.TestListObj();
		fd.testMap();
	}
	
	@Test
	public void TeseArr(){
		String name[] = {"aa","bb","cc"};
		for(String str : name){
			System.out.println(str);
		}
	}

	@Test
	public void TeseObj(){
		Person[] person = new Person[3];
		person[0] = new Person("张三",21);
		person[1] = new Person("李四",28);
		person[2] = new Person("王五",22);
		for(Person per : person){
			System.out.println(per.getName()+"..."+per.getAge());
		}
	}
	
	@Test
	public void TestList(){
		List<String> list = new ArrayList<String>();
		list.add("aaa");
		list.add("bbb");
		list.add("ccc");
		for(String l : list){
			System.out.println(l);
		}
	}
	
	@Test
	public void TestListObj(){
		List<Person> list = new ArrayList<Person>();
		list.add(new Person("aaa",18));
		list.add(new Person("bbb",21));
		list.add(new Person("ccc",26));
		for(Person l : list){
			System.out.println(l.getName()+"..."+l.getAge());
		}
	}
	
	public void testMap(){
		Map map = new LinkedHashMap();
		map.put("1","aaa");
		map.put("2","bbb");
		map.put("3","ccc");
		//通过map.keySet()把键值取出，遍历
		/*Set keys = map.keySet();
		Iterator it = keys.iterator();
		while(it.hasNext()){
			String key=(String)it.next();
			System.out.println(key+"="+map.get(key));
			
		}*/
		//使用map.entrySet()方法
		/*Set set=map.entrySet();
		Iterator it=set.iterator();
		while(it.hasNext()){
			Map.Entry me=(Map.Entry) it.next();
			String key=(String)me.getKey();
			String value=(String)me.getValue();
			System.out.println(key+"="+value);
		}*/
				
		//for循环
				
		for(Object obj:map.entrySet()){
			Map.Entry me=(Map.Entry)obj;
			System.out.println(me.getKey()+"="+me.getValue());
		}
				
	}

}

使用增强for循环的几个注意事项(以下程序的输出结果？)

不改变结果

可变参数

• 从 JDK 1.5 开始, Java 允许定义形参长度可变的参数，从而允许为方法指定数量不确定的形参
• 若在定义方法时, 在最后一个形参的类型后增加三点(…, ...位于变量类型和变量名之间，前后有无空格都可以)则表明该形参可以接受多个参数值, 多个参数值被当成数组传入
• 可变形参只能处于形参列表的最后, 所以一个方法最多只能有一个长度可变的形参
• 调用包含一个可变形参的方法时, 可以为该形参传入多个参数或一个数组
• 调用可变参数的方法时, 编译器为该可变参数隐含创建一个数组, 在方法体中以数组的形式访问可变参数

引入:定义一个方法求数组中元素的和

 

测试JDK中具有可变参数的类Arrays.asList()方法。分别传多个参、传数组的情况
注意：传入基本数据类型数组的问题