JDK1.5 后的特性总结……

持续整理中……

【无论什么东西升级的目的无非 以下几点：】

1.简化书写；

2.提高效率；

3.提高安全性；

新特性一： StringBuilder ——jdk1.5版本出现了一个新的字符串缓冲区。

【JDK1.5新出来的】

StringBuilder含义：——新的字符串缓冲区；

功能和StringBuffer一模一样。可变字符序列。

两者到底啥区别呢？

【StringBuilder 和 StringBuffer的区别】——

对于容器，被多线程操作，容易出现安全问题。

【原因：】一个线程负责添加，一个线程负责删除，因为线程的随机性就会出现安全问题。

加锁，一个线程在执行容器中的内容时，其他线程不可以执行。

所以凡是可以操作容器数据的方法，都需要明确这个锁。

每调用一次操作容器的方法，（添加，删除）都需要判断这个锁。

对应多线程——安全，但效率低。对单线程——不涉及安全，但效率低，所以，对线程提供了StringBuilder .不需要同步的缓冲区。

实际开发时，建议使用StringBuilder ,只有在多线程时，才使用StringBuffer.

新特性二：自动拆箱，装箱机制。

【基本数据类型对象包装类JDk1.5以后的新特性】——【自动拆箱，装箱】

简化书写。

以——Integer i = new Integer(5)为例;

基本数据类型对象包装类，对象创建的简化写法Integer i = 5;

1. Integer i = 5;(其实在内存中也是通过 new Integer(5)这种方式创建的！)

这种方式称为——自动装箱，其实是通过Integer.valueOf(5)自动完成了对象创建的动作。

2. 在进行 Integer  i = i + 5，运算时——

等号 右边的i 会先转成基本数据值（自动拆箱）i.intValue()，其实质为：

i = i.intValue() + 5 ；然后再和5进行加法运算。

等号 右边运算完的结果，再次被自动装箱变成Integer对象赋给i.

一旦简化就有弊端：多具备一个值null. 使用自动装箱拆箱时，进行null的健壮性判断。

【实例】

Integer x = null;

x = x.intValue() + 4;

System.out.println(x);

将会抛出异常： java.lang.NullPointerException

————————————————————————————————

Boolean b = true; boolean b = true;的区别

答：前者：类类型变量指向一个对象，true为一个对象；

        后者：true为基本类型变量。

————————————————————————————————

在JdK1.5的新特性自动装箱中，如果数值在byte类型范围内（-128 ~ 127）。如果该对象数值重复出现

多个引用其实是指向同一个Integer对象，节省空间！但是超出了byte范围，都会生产新的Integer对象。

Integer m = 127;

Integer n = 127;

System.out.println( m == n); //true

System.out.println(m.equals(n));  //true

____________________________________

Object x = 5；Object x 接受到了一个Integer对象,自动装箱。

然而 Object不可以接受基本数据类型。

新特性三： 多线程：Lock代替了同步！

同步函数和同步代码块 所做的都是隐式的锁操作。  

同步函数和同步代码块 使用的锁和监视器是同一个。

Lock接口：是将锁进行单独对象的封装。而且提供了对锁对象很多功能。

比如：lock（）获取锁，unlock（）释放锁。

Lock对锁的操作都是显示操作。 所以它的出现要比同步函数更或者同步代码块明确的多。更符合面向对象的思想。

简单一句话：Lock接口的出现替代同步。

在同步里，锁和监视器是同一个对象。 升级后，锁是一个单独的对象。 而且将监视器的方法也单独封装到了

一个对象中，这个对象就是升级后——Condition. 升级后，都进行了单独的封装。锁被封装成了Lock对象。监视器方

法都被封装到了Condition对象（监视器对象）中。

——Lock代替了 同步。Condition代替了Object中的监视器方法。

Condition中提供了监视器的方法：await() , signal()   signalAll()

如何让锁和监视器产生联系？

直接通过Lock接口中的newCondition()方法就可以获取到能绑定到该Lock 对象上的监视器对象Condition上。

特性四：可变参数列表

以计算数的和为例：

当我们需要计算两个数的和时：可以将这两个数作为参数传入;需要计算3个数的和时，将这三个数作为参数传入；

而当我们需要计算的数很多时，而且都是同一类型，可以定义数组类型的参数。 但是传递时，必须先有数组对

象。 JDK1.5后，为了简化书写，出现了特性，可变参数。  同样还是代表数组，但是不需要在创建数组对象了，直接将

数组中的元素作为参数传入即可。 它会自动的将这些参数封装到数组中。 

【代码体现如下】

public class ParamDemo {
	
	public static void main(String[] args) {
		
		int num = add(5 , 6);
		System.out.println("这两个数的和为 ——> " +num);
		
		int num1 = add1(8 , 9 , 2);
		System.out.println("这三个数和为 ——> " + num1);
		
		int[] num2 = {1 , 2 , 4, 5, 6, 9}; 
		int sum = add2(num2);
		System.out.println("数组的和为 ——> " + sum);
		
		int sum2 = add(1 , 2 , 4, 5, 6, 9);
		System.out.println("可变参数后的 ——>" + sum2);
		

	}
	/* 
	 * 局限性。可变参数必须定义在参数列表的最后面。
	 */
	
	public static int add(int... arr ) {
		int sum = 0;
		for(int x=0; x<arr.length; x++){
			sum+=arr[x];
		}
		return sum;		
	}
	public static int add2(int[] num2) {
		int sum = 0;
		for (int i = 0; i < num2.length; i++) {
			sum+=num2[i];
		}
		return sum;
	}

	public static int add1(int i, int j, int k) {
		return i + j + k;
	}

	public static int add(int i, int j) {		
		return i + j;
	}
}

特性五: 泛型

JDK1.5后的安全机制——泛型

特性六：增强型 for 循环语句；

Collection有了一个父接口，Iterable 该接口封装了iterator方法，同时提供了一个新的语句。foreach语句。

格式：

for(变量类型  变量：Collection集合 or 数组){

System.out.println("Xxxxx");
}

【代码体现 】

import java.util.ArrayList;

public class ForEachDemo {

	/**
	 * @param args
	 */
	public static void main(String[] args) {

		ArrayList<String> al = new ArrayList<String>();
		
		al.add("abc1");
		al.add("abc2");
		al.add("abc3");
		al.add("abc5");
		
		for(String s : al){
			System.out.println(s);
		}

		
		int[] arr = {7,23,1,67,90,8};
		
		for(int i : arr){//只为遍历元素，无法操作角标。 
			System.out.println("i="+i);
		}
		
	}
}

【增强型的for循环 和 传统 for 循环的区别？】

1.foreach循环简化了迭代器，依旧还使用迭代器，因为迭代过程中还可以remove（），一般只对基本遍历简化使用。

2.和传统for循环有什么区别呢？
     foreach 循环特点：

  必须明确被遍历的目标。没有目标没用。目标只能是数组 或者Collection集合。但是不能通过角标操作。

如果要对数组中的元素进行特定操作时，建议使用传统for循环，通过角标完成。