jdk5新特性用法详解

一.自动拆装箱(AutoBoxing&unBoxing)

jdk1.5之前基本类型和包装类型是不能直接转换的，jdk1.5之后底层直接可以相互转换，这样提高了效率。

package cn.jasonjdk01;

public class AutoBox {
	public static void main(String[] args) {
		// 自动装箱
		Integer i = 10;// 这里相当是Integer i=Integer.valueOf(10)；这叫自动装箱
		// 先拆箱在装箱
		i = Integer.valueOf(10);// 这里相当做了这样一个动作。先把之前装好箱的i，在拆箱成基本类型10，和20运算后再把30装箱成Integer类型。
		// 也就是代码。i=Integer.valueOf(Integer.valueOf(10).intValue()+20);
	}
}

总结：

基本类型转换 包装类型用的是valueOf方法，

包装类型转换基本类型用的是intValue方法。

通过反编译看看底层是不是这样实现的：

package cn.jasonjdk01;

import java.io.PrintStream;

public class AutoBox
{

	public AutoBox()
	{
	}

	public static void main(String args[])
	{
		Integer i = Integer.valueOf(10);
		i = Integer.valueOf(i.intValue() + 20);
		System.out.println(i);
	}
}

总结：

int类型转换成Integer类型方法：Integer.valueOf()方法；

 Integer类型装换成int类型方法：用的是intValue方法。

二.可变参数(Varargs)

现象：有时定义函数的时候，需要根据用户传递的参数的个数来决定传几个参数。而不是自己直接在函数上就把参数的个数限定。这种问题就可以使用可变参数来解决。

package cn.jasonjdk01;

/**
 * 可变参数用法
 * 
 * @author Jason
 *
 */
public class Varargs {
	public static void main(String[] args) {	
		
		// 求若干参数之和
		getSum(661, 5, 0);
		// 若是对于某个参数单独处理
		getMax(888, 5, 2, 1);
	}

	// 可变参数格式：参数类型...数组名
	private static void getSum(int... arr) {
		// 定义求和变量
		int sum = 0;
		// 遍历数组
		for (int i : arr) {
			sum += i;
		}
		// StringBuilder类也重写的toString方法，所以底层会默认转换为字符串
		System.out.println(new StringBuilder("c参数之和是：").append(sum));
	}

	// 获取第一个参数和后面三个参数之和的最大值
	private static void getMax(int i, int... arr) {
		// 定义求和变量
		int sum = 0;
		// 遍历数组，求后面三个参数之和
		for (int j : arr) {
			sum += j;
		}
		// 比较最值
		int max = Math.max(i, sum);
		System.out.println(new StringBuilder("最大值是：").append(max));
	}
}

其实可变参数的底层就是一个数组，getSum(661,5,0)其实是传的是数组getSum(new int[] {661, 5, 0})，传的是一个静态初始化的一个数组而已。方法 private static transient void getSum(int arr[])的可变参数列表底层就是一个数组。

看看底层吧

<span style="font-size:14px;">package cn.jasonjdk01;

import java.io.PrintStream;

public class VariableArguments
{

	public VariableArguments()
	{
	}

	public static void main(String args[])
	{
		getSum(new int[] {
			661, 5, 0
		});
		getMax(888, new int[] {
			5, 2, 1
		});
	}

	private static transient void getSum(int arr[])
	{
		int sum = 0;
		int ai[];
		int k = (ai = arr).length;
		for (int j = 0; j < k; j++)
		{
			int i = ai[j];
			sum += i;
		}

		System.out.println((new StringBuilder("c参数之和是：")).append(sum).toString());
	}

	private static transient void getMax(int i, int arr[])
	{
		int sum = 0;
		int ai[];
		int l = (ai = arr).length;
		for (int k = 0; k < l; k++)
		{
			int j = ai[k];
			sum += j;
		}

		int max = Math.max(i, sum);
		System.out.println((new StringBuilder("最大值是：")).append(max).toString());
	}
}

总结：

1.可变参数列表底层就是一个数组。其实在main方法里面直接写一个数组也是可以验证的。

2.可变参数的好处

①可以简化代码

②使用可变参数可以接收不确定参数的个数

注意：

1.若是有某个参数单独处理，参数列表必须放在可变参数列表之前， 因为第一个参数是可变参数，可以接收传递过来的所有参数，第二个参数就变得没有意义了。
2.对于某个单独处理的参数，函数名不能相同，否则产生不确定性
3.参数列表不同可以以重载方式存在.

三.静态导入(Static imports)

静态导入和导包其实道理一样，只是在导入包的时候把这些静态的内容提前导入进来。

我并没有发现这样有多简单，反倒觉得麻烦，代码body简单了，但是head重了，给人头重脚轻的，看看就行。

静态导入格式：

import  static  包名.类名.静态成员变量/方法名

package cn.jasonjdk01;

import java.util.Arrays;

import static java.util.Arrays.sort;
import static java.lang.System.out;

//静态导入
//格式：import static 包名.类名.静态成员变量/方法名
//这里的类没有构造方法，方法或成员都是静态的
public class StaticDemo {
	public static void main(String[] args) {
		// 定义一个数组
		int[] arr = { 1, 6, 2, 4, 0 };
		// 对数组进行排序
		Arrays.sort(arr);

		// 静态导入方法
		sort(arr);
		// 把数组转换成字符串表示
		String string = Arrays.toString(arr);
		System.out.println(string);

		// 静态导入方法
		out.println(string);
	}
}

四.foreach、增强for或者高级for

这个请查看之前博客增强for底层用法解析