<黑马程序员>java基础加强--JDK 5.0 新特性

----------- android培训、java培训、java学习型技术博客、期待与您交流！ ------------

1. 静态导入

1) 导入类的静态属性

为了简化对类的静态成员的引用，JDK 5.0增加的静态导入语法用于导入类的某个静态属性或方法。

语法：
import static 包名.类名.静态属性|静态方法|*
例如：
导入System类的静态属性out
import static java.lang.System.out
在程序中直接使用out.print(str) 输出到控制台

2)导入Math类的所有静态方法
import static java.lang.Math.*
在程序中使用  abs(num) 直接调用类的静态成员方法

int num = abs(-10);

2，自动装箱/拆箱

在java中有8种基本数据类型，为了方便将基本数据类型当做对象来处理，sun公司定义了对应的包装类，如：int  Integer
包装类就是对基本数据类型值的封装
JDK5.0之前，开发人员若想将一个基本数据类型赋值给包装类变量, 需要进行手动包装， 如： Integer x = new Integer(98);
JDK5.0中定义了新特性自动拆箱与自动装箱，开发人员可以直接将基本数据类型的值直接赋值给包装类对象，反之一样。不需要任何的手动装箱与拆箱。
典型应用：
List list = new ArrayList();
list.add(19);
Int num = (Integer) list.get(0);

 基本数据类型的包装类

int --> Integer

byte --> Byte

short --> Short

long --> Long

char --> Character

double --> Double

float --> Float

boolean --> Boolean

1) Integer x = 1; x = x + 1;  经历了什么过程？ 装箱à 拆箱 à 装箱

2) 为了优化，虚拟机为包装类提供了缓冲池， Integer池的大小 -128~127 一个字节的大小

3) String池

 Java为了优化字符串操作 提供了一个缓冲池

 面试题：

String s = “abc” 和 String s = new String(“abc”) 的区别

String s = new String(“abc”) 创建了几个对象 

String s = “a” + “b” + “c” + “d” 创建了几个对象

String s1 = “a” String s2 = “b”  String s3 = s1 + s2;  s3==”ab”?

/*1. String s = "abc"， 虚拟机首先会检查String池里有没有"abc"对象(通过equals方法)

// 如果有，直接返回引用，如果没有，会在池里创建一个“abc”对象，并返回引用

String s1 = "abc";

String s2 = "abc";

System.out.println(s1==s2); // result: true

*/

/* 2. String str = new String("abc"); 

不管缓冲池是否有"abc", 都会在堆内存创建一个"abc"对象，返回引用

// 此时，负责检查并维护缓冲池，其实堆内存的对象是缓冲池中"abc"对象的一个拷贝

String s1 = new String("abc");

String s2 = new String("abc");

System.out.println(s1==s2); // result: false

*/

/* 3. String s = "a" + "b" + "c" + "d";  java编译器有个合并已知量的优化功能

// 在编译阶段就把"a" + "b" + "c" + "d" 合并为 ”abcd“

String s = "a" + "b" + "c" + "d"; 

// String s = "abcd"; 

System.out.println(s=="abcd");// result: true

*/

/* 4.  String s1 = "a"; String s2 = "b"; String s3 = s1 + s2;

// String是常量，不能相加的，java如何实现的？

 StringBuilder sb = new StringBuidler(s1);

 sb.append(s2);

 s3 = sb.toString();

 

 也就是说实际上s3是方法返回的String对象

 凡是方法返回的字符串对象都是在堆内存的

*/

 String s1 = "a";

 String s2 = "b"; 

 String s3 = s1 + s2; // 堆内存的对象

 System.out.println(s3=="ab");// result: false

3. 增强for循环

JDK5.0以前，遍历数组或集合中的元素都需要些迭代的代码

JDK5.0中定义了一种新的语法——增强for循环，专门用于对
存储对象的容器进行迭代(数组和集合)，注意，对于集合，只
能对实现了Iterable接口的对象进行迭代，原因在于，Iterable
接口中定义了iterator方法

语法格式：                                              
for(变量类型 变量　：需迭代的数组或集合){
// 使用变量引用容器中的元素
}

实现原理：
获得对象的迭代器，针对集合对象进行迭代，将每次迭代的值付给for循环
中定义的变量

1，增强for循环迭代数组

String [] arr = {"a", "b", "c"}; //数组的静态定义方式，只试用于数组首次定义的时候

// 传统方式

for(int i=0; i<arr.length; i++) {

// i依次表示数组的角标

String s = arr[i];

System.out.println(s);

}

System.out.println("-------------------------------------");

// 在jdk5中我们可以使用增强for循环迭代

// 增强for循环括号里写两个参数，第一个是声明一个变量，变量类型必须是数组元素的类型

// 第二个就是需要迭代的容器

// for循环会循环容器的length次, 每次都将容器的第n-1个元素赋值给声明的变量

for(String s : arr) {

// 循环体， 执行arr.length

// 每次都将arr中的第n-1个元素给s

System.out.println(s); //

}

,2，增强for循环迭代单列集合collection

List list = new ArrayList();

list.add("aaa");

list.add("bbb");

list.add("ccc");

// 传统方式1

/* 1.获得迭代器

Iterator iter = list.iterator();

// 2.循环判断迭代器是否有下一个

while(iter.hasNext()) {

String str = (String) iter.next(); // 将迭代器的指针移向下一个，并将迭代当前指向的元素返回

System.out.println(str);

}

*/

// 传统方式2

for(Iterator iter=list.iterator(); iter.hasNext(); ) {

String s = (String) iter.next();

System.out.println(s);

}

System.out.println("--------------------------------");

// 增强for循环, 没有使用泛型的集合能不能使用增强for循环迭代？能

for(Object obj : list) {

String s =  (String) obj;

System.out.println(s);

}

3，增强for循环迭代双列集合Map

Map map = new HashMap();

map.put("a", "aaa");

map.put("b", "bbb");

map.put("c", "ccc");

// 传统方式迭代1

// 1. 获得所有的key

Set keys = map.keySet();

// 2.迭代keys获得所有的key

Iterator iter = keys.iterator();

while(iter.hasNext()) {

String key = (String) iter.next(); // a b c

// 3.根据key获得对应的value

String value = (String) map.get(key);

System.out.println(key + "=" + value);

}

System.out.println("---------------------------------");

// 传统方式2，必须掌握这种方式

// 1.获得所有的键值对Entry对象

Set entrys = map.entrySet();

// 2.迭代出所有的entry

iter = entrys.iterator();

while(iter.hasNext()) {

Map.Entry entry = (Entry) iter.next();

// 分别获得key和value

String key = (String) entry.getKey();

String value = (String) entry.getValue();

System.out.println(key + "=" + value);

}

System.out.println("-------------------------------------");

System.out.println("增强for循环迭代，");

// 增强for循环迭代，

// 原则上map集合是无法使用增强for循环来迭代的，

// 因为增强for循环只能针对实现了Iterable接口的集合进行迭代

// Iterable是jdk5中新定义的接口，就一个方法iterator方法

// 只有实现了Iterable接口的类，才能保证一定有iterator方法

// java有这样的限定是因为增强for循环内部还是用迭代器实现的

// 而实际上，我们可以通过某种方式来使用增强for循环

for(Object obj : map.entrySet()) {

// obj 依次表示Entry

Map.Entry entry = (Entry) obj;

System.out.println(entry.getKey() + "=" + entry.getValue());

}

4，迭代集合时应该注意的问题

// 在使用迭代器迭代集合的过程中，不能对集合进行增删操作

@Test

public void test4() {

List list = new ArrayList();

list.add("wangwu");

list.add("zhangsan");

list.add("lisi");

Iterator iter = list.iterator();

while(iter.hasNext()) {

String name = (String) iter.next();

if("wangwu".equals(name)) {

// 从集合中删掉

//list.remove(name);

// 迭代过程中删除元素需要调用迭代器的方法

iter.remove(); // 删除我迭代的集合被我迭代的最后一个元素

}

}

// 1 2 4

System.out.println(list.size());

}

@Test

public void test5() {

List list = new ArrayList();

list.add("aa");

list.add("bb");

// 使用ListIterator迭代器

ListIterator listIterator = list.listIterator();

while(listIterator.hasNext()) {

listIterator.next();

// 迭代过程中增加元素

listIterator.add("cc");

}

System.out.println(list.size());

}

5，增强for循环注意的问题

//在使用增强for循环时，不能对元素进行赋值

int[] arr = {1,2,3};

for(int num : arr) {

num = 0;

}

System.out.println(arr[1]);

4. 可变参数

从JDK 5开始, Java 允许为方法定义长度可变的参数。
即方法定义一个形参，但是可以传入0~n个实参，
方法定义如下：
public void foo(int … args){
args
}

Util包中的工具类Arrays的asList(Object[])方法就将形参定义为可变参数
调用此方法分别测试传入多个参、传引用类型数组、传基本数据类型数组、传数组又传参的情况

细节：
调用可变参数的方法时, 编译器将自动创建一个数组保存传递给方法的
可变参数，因此，程序员可以在方法体中以数组的形式访问可变参数

可变参数只能处于参数列表的最后, 因此一个方法最多只能有一个可变的参数

1，设计一个方法求n个数的和

public static int getSum(int... arr) {

// 可变参数在方法中仍被看做一个数组

int sum = 0;

for(int num : arr)

sum += num;

return sum;

}

2)Arrays.asList为例演示传入不同参数的情况

// list长度为3

List list = Arrays.asList("a","b","c");

// list长度为1， 因为考虑1.4语法

String[] arr = {"a","b","c"};

List list = Arrays.asList(arr);

// 同时符合1.4和1.5的语法,此时会优先考虑1.4的语法

// 原因是有了新功能要保证以前的代码不出错，向后兼容

// 现在就需要将arr作为一个元素存入集合

Object obj = arr;

List list2 = Arrays.asList(obj); // 此时只符合1.5的语法，不符合1.4的语法，没有歧义

List list3 = Arrays.asList(new Object[]{arr}); // 优先考虑1.4，所以数组会拆开

//System.out.println(list3.size());

// 基本数据类型数组只符合1.5的语法

int[] nums = {1,2,3};

list = Arrays.asList(nums);

System.out.println(list.size());