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

最新推荐文章于 2015-11-05 16:55:33 发布

chen_yying

最新推荐文章于 2015-11-05 16:55:33 发布

阅读量350

点赞数

分类专栏： JAVA基础加强

本文链接：https://blog.csdn.net/chen_yying/article/details/8292607

版权

JAVA基础加强专栏收录该内容

3 篇文章 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[])方法就将形参定义为可变参数
调用此方法分别测试传入多个参、传引用类型数组、传基本数据类型数组、传数组又传参的情况

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

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