java基础--JDK 1.5 新特性

JDK 1.5的新特性

一、静态导入

1、当类名重名时。需要指定具体的包名

2、当方法重名时。指定具备所属的对象或者类。

package study.part1.day012.collection;
import java.util.Arrays;
import static java.util.Arrays.*;	//导入的是Arrays这个类中的所有静态成员。
import static java.lang.System.*;	//导入了System类中所有静态成员。
public class StaticImportDemo {
	public static void main(String[] args) {
		int[] arr = {1,2,8,9,5,7};
		//排序一下,顺序排序
		Arrays.sort(arr);
		System.out.println(Arrays.toString(arr));
		int index = Arrays.binarySearch(arr, 1);
		System.out.println("index:"+index);
		//通过静态导入了Arrays，就可以直接不用Arrays.
		sort(arr);
		out.print("xxx");
	}
}<span style="color: rgb(63, 95, 191); font-family: Arial, Helvetica, sans-serif;"> </span>

二、方法的可变参数

1) 使用注意：可变参数，一定要定义在参数列表的后面。

2) 可变参数传递的使用方式：其实就是上一种数组的参数简写形式，不用每次都动手的建立数组对象，只要将操作的元素作为参数传递即可，隐式的将这些参数封装成了数组。

3) 可变参数的写法：public static void show2(String s,int...arr){}

4) Demo:

public class ParamMethodDemo {
	public static void main(String[] args) {
		show(1,2,3,5);
	}
	public static void show(int...arr){
		System.out.println(arr);
		System.out.println(arr.length);
	}
	public static void show2(String s,int...arr){
		System.out.println(arr);
		System.out.println(arr.length);
	}
}

三、高级 for 循环

1）格式：

for(数据类型 变量名：被遍历的集合(collection) 或者数组){

}

2）for 对集合的遍历，只能获取元素，但是不能对集合进行操作。迭代器除了对集合进行遍历，还能进行 remove 集合中元素的动作。如果是用 ListIterator，还可以在遍历过程中对集合进行增删改查的动作。 

3）高级 for 循环的局限性：高级 for 有一个局限性，必须有被遍历的目标。

4）建议：在遍历数组的时候，还是希望使用传统的 for ，因为传统 for 可以定义脚标。高级for：只能对集合中的数据取出，不能做到修改集合中的元素，即使是赋值也没办法。

5）Demo：

package study.part1.day012.collection;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class ForHighLevelDemo {
	public static void main(String[] args) {
		ArrayList<String> al = new ArrayList<String>();
		al.add("xx");
		al.add("OOO");
		for(String s : al){
			s = "XXXX";
			System.out.println("s:"+s);
		}
		System.out.println(al);
		/**
		Iterator<String> it = al.iterator();
		while(it.hasNext()){
			System.out.println(it.next());
		}
		*/
		int[] intarr = {1,2,5};
		for(int i : intarr){
			System.out.println("i:"+i);
		}
		//HashMap 的遍历
		HashMap<Integer,String> hm = new HashMap<Integer,String>();
		hm.put(1, "sss");
		hm.put(2, "XX");
		hm.put(3, "OOs");
		//用 set 方法取键。
		Set<Integer> keySet = hm.keySet();
		//高级 for 循环
		for(Integer i : keySet){
			System.out.println(i+":"+hm.get(i));
		}
		System.out.println("============");
		//Map.Entry 方法的高级 for
		Set<Map.Entry<Integer,String>> entrySet = hm.entrySet();
		for(Map.Entry<Integer, String> me : entrySet){
			System.out.println(me.getKey()+"-----"+me.getValue());
		}
	}
}

四、JDK 1.5 自动装箱与拆箱

1)Integer i = 5;//自动装箱new Integer(5);

2)i = i+2;   //i进行自动拆箱，变成了 int 类型，再和 2 相加，再进行装箱赋值给 i 。

3)byte范围是-128~127之间，所以Integer m,n = 128;已经超出byte范围，所以虽然看似相同，其实他们指向了两个不同的 Integer 对象。

4)Demo:

package study.base.day010.ThreadTX;
public class BaseDateObject2 {
	public static void main(String[] args) {
		Integer x = new Integer("123");
		Integer y = new Integer(123);
		System.out.println("x==y吗？\n\t"+(x==y));
		System.out.println("x.equals(y)吗？\n\t"+x.equals(y));
		Integer xi = 5;//自动装箱	new Integer(5);
		xi = xi+2;	   //x进行自动拆箱，变成了 int 类型，再和 2 相加，再进行装箱赋值给 xi
		Integer m = 128;	//超出byte范围，
		Integer n = 128;
		//结果为 false ，因为 m 和 n 指向了不同的 Integer 对象。
		System.out.println("mn相等吗："+(m==n));		
		Integer a = 127;	//byte范围是<=127
		Integer b = 127;
		//结果为 true ，因为 a 和 b 指向了同一个 Integer 对象。
		//因为当前值在 byte 范围内容，对于新特性，如果该数值已经存在，则不会再开辟新的空间。
		System.out.println("ab相等吗："+(a==b));
	}
}