------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------
八、jdk1.5新特性
1. 高级for（ForEach）
import java.util.*;
/*
高级for循环
格式：
for（数据类型 变量名：被遍历的集合或者数组）
{
}
对集合进行遍历，只能获取元素，但不能对集合进行操作
迭代器除了遍历还可以进行remove集合中元素的动作
如果使用ListIterator，还可以在便利过程中对集合进行增删改查的动作
传统for和高级for有什么区别呢？
高级for有一个局限性，必须有被遍历的目标
建议在遍历数组的时候使用传统for，传统for可以定义角标
*/
class ForEachDemo
{
public static void main(String[] args)
{
ArrayList<String> list = new ArrayList<String>();
list.add("abc01");
list.add("abc02");
list.add("abc03");
Iterator<String> it = list.iterator();
while (it.hasNext())
{
System.out.println(it.next());
}
for (String s1:list )
{
System.out.println(s1);
}
int[] arr = {3,5,1};
for (int i : arr)
{
System.out.println(i);
}
HashMap<Integer,String> hm = new HashMap<Integer,String>();
hm.put(1,"abtc");
hm.put(2,"absc");
hm.put(3,"adbc");
hm.put(4,"abfc");
Iterator it1 = hm.keySet().iterator();
while (it1.hasNext())
{
Integer i = (Integer)it1.next();
System.out.println(i+"...."+hm.get(i));
}
for (Integer i : hm.keySet() )
{
System.out.println(i+"....."+hm.get(i));
}
Set<Map.Entry<Integer,String>> en = hm.entrySet();
for(Map.Entry<Integer,String> me : en)
{
System.out.println(me.getKey()+"....."+me.getValue());
}
}
}2. 可变参数
JDk1.5出现的新特性
可变参数其实就是上一种数组参数的简写形式，不用每一次都手动的建立数组对象。
只要将要操作的元素作为参数传递即可
隐式将这些参数封装成了数组
在使用时注意，可变参数一定要定义在参数列表的最后面
class ParamMethodDemo
{
public static void main(String[] args)
{
show(2,3,4);
}
public static void show(int...arr)
{
System.out.println(arr);
}
/* public static void show(int[] arr)
{
}
public void show(int a,int b)
{
System.out.println(a+","+b);
}
public void show(int a,int b,int c)
{
}
*/
}3. 静态导入
通过使用 import static，就可以不用指定 Constants 类名而直接使用静态成员，包括静态方法。
import xxxx 和 import static xxxx的区别是前者一般导入的是类文件如import java.util.Scanner;后者一般是导入静态的方法，import static java.lang.System.out。
/*
StaticImport 静态导入
当类名重名时，需要指定具体的包名。
当方法重名时，指定具备所属的对象或者类。
*/
import static java.lang.System.*;
import java.util.*;
import static java.util.Arrays.*; //导入的是Arrays这个类中的所有静态成员
class StaticImport
{
public static void main(String[] args)
{
int[] arr = {3,1,5};
//Arrays.sort(arr);
sort(arr);
//int index = Arrays.binarySearch(arr,1);
int index = binarySearch(arr,1);
out.println(Arrays.toString());
}
}4. 泛型
C++ 通过模板技术可以指定集合的元素类型，而Java在1.5之前一直没有相对应的功能。一个集合可以放任何类型的对象，相应地从集合里面拿对象的时候我们也 不得不对他们进行强制得类型转换。猛虎引入了泛型，它允许指定集合里元素的类型，这样你可以得到强类型在编译时刻进行类型检查的好处。
泛型：jdk1.5版本以后出现的新特性，用于解决安全问题，是一个安全机制。
好处：
1.将运行时期出现问题ClassCastException，转移到了编译时期
方便程序员解决问题，让运行时期问题减少，安全。
2.避免了强制转换的麻烦
泛型格式：通过<>来定义要操作的引用数据类型。
在使用java提供的对象时，什么时候写泛型呢？
通常在集合框架中很常见，只要见到<>就要定义泛型
其实<>就是用来接收类型的，当使用集合时，将集合中要存储的数据类型作为参数传递到<>中即可
import java.util.*;
class GenericDemo
{
public static void main(String[] args)
{
ArrayList<String> a1 = new ArrayList<String>();
a1.add("abc01");
a1.add("abc0991");
a1.add("abc014");
Iterator<String> it = a1.iterator();
while(it.hasNext())
{
String s = (String)it.next();
System.out.println(s.length());
}
}
}
import java.util.*;
class GenericDemo2
{
public static void main(String[] args)
{
TreeSet<String> ts = new TreeSet<String>(new LenComparator());
ts.add("abcd");
ts.add("abcde");
ts.add("abcdef");
ts.add("abcdefth");
Iterator<String> it = ts.iterator();
while(it.hasNext())
{ String s = it.next();
System.out.println(s);
}
}
}
class LenComparator implements Comparator<String>
{
public int compare(String o1,String o2)
{
int num = new Integer(o1.length()).compareTo(new Integer(o2.length()));
if(num==0)
return o1.compareTo(o2);
return num;
}
}
//泛型定义在接口上
interface Inter<T>
{
void show(T t);
}
/*
class InterImpl implements Inter<String>
{
public void show(String t)
{
System.out.println("show:"+t);
}
}
*/
class InterImpl<T> implements Inter<T>
{
public void show(T t)
{
System.out.println("show:"+t);
}
}
class GenericDemo5
{
public static void main(String[] args)
{
//InterImpl i = new InterImpl();
//i.show("haha");
InterImpl<Integer> i = new InterImpl<Integer>();
i.show(4);
}
}
import java.util.*;
/*
? 通配符，也可以理解为占位符。
泛型的限定：
？ extends E：可以接受E类型或者E的子类型，上限限定
？ super E：可以接受E类型或者E的父类型，下限限定
*/
class GenericDemo6
{
public static void main(String[] args)
{
ArrayList<String> a1 = new ArrayList<String>();
a1.add("abcd1");
a1.add("abcd2");
a1.add("abcd3");
ArrayList<Integer> a2 = new ArrayList<Integer>();
a2.add(4);
a2.add(7);
a2.add(1);
printColl(a1);
printColl(a2);
}
public static void printColl(ArrayList<?> a1)
{
Iterator<?> it = a1.iterator();
while(it.hasNext())
{
System.out.println(it.next());
}
}
}5. 内省（Introspector）
是 Java语言对Bean类属性、事件的一种缺省处理方法。例如类A中有属性name,那我们可以通过getName,setName来得到其值或者设置新 的值。通过getName/setName来访问name属性，这就是默认的规则。Java中提供了一套API用来访问某个属性的getter /setter方法，通过这些API可以使你不需要了解这个规则（但你最好还是要搞清楚），这些API存放于包java.beans中。
一 般的做法是通过类Introspector来获取某个对象的BeanInfo信息，然后通过BeanInfo来获取属性的描述器 （PropertyDescriptor），通过这个属性描述器就可以获取某个属性对应的getter/setter方法，然后我们就可以通过反射机制来 调用这些方法。
6. 自动装箱与拆箱
自动装箱的过程：每当需要一种类型的对象时，这种基本类型就自动地封装到与它相同类型的包装中。
自动拆箱的过程：每当需要一个值时，被装箱对象中的值就被自动地提取出来，没必要再去调用intValue()和doubleValue()方法。
自动装箱，只需将该值赋给一个类型包装器引用，java会自动创建一个对象。
自动拆箱，只需将该对象值赋给一个基本类型即可。
java——类的包装器
类型包装器有：Double,Float,Long,Integer,Short,Character和Boolean
7. 枚举
把集合里的对象元素一个一个提取出来。枚举类型使代码更具可读性，理解清晰，易于维护。枚举类型是强类型的，从而保证了系统安全性。而以类的静态字段实现的类似替代模型，不具有枚举的简单性和类型安全性。
简单的用法：JavaEnum简单的用法一般用于代表一组常用常量，可用来代表一类相同类型的常量值。
复杂用法：Java为枚举类型提供了一些内置的方法，同时枚举常量还可以有自己的方法。可以很方便的遍历枚举对象。
在实际编程中，往往存在着这样的“数据集”，它们的数值在程序中是稳定的，而且“数据集”中的元素是有限的。
例如星期一到星期日七个数据元素组成了一周的“数据集”，春夏秋冬四个数据元素组成了四季的“数据集”。
在java中如何更好的使用这些“数据集”呢？因此枚举便派上了用场，以下代码详细介绍了枚举的用法。
/**
* 枚举用法详解
*/
public class TestEnum {
/**
* 普通枚举
*/
public enum ColorEnum {
red, green, yellow, blue;
}
/**
* 枚举像普通的类一样可以添加属性和方法，可以为它添加静态和非静态的属性或方法
*/
public enum SeasonEnum {
//注：枚举写在最前面，否则编译出错
spring, summer, autumn, winter;
private final static String position = "test";
public static SeasonEnum getSeason() {
if ("test".equals(position))
return spring;
else
return winter;
}
}
/**
* 性别
*
* 实现带有构造器的枚举
*/
public enum Gender{
//通过括号赋值,而且必须带有一个参构造器和一个属性跟方法，否则编译出错
//赋值必须都赋值或都不赋值，不能一部分赋值一部分不赋值；如果不赋值则不能写构造器，赋值编译也出错
MAN("MAN"), WOMEN("WOMEN");
private final String value;
//构造器默认也只能是private, 从而保证构造函数只能在内部使用
Gender(String value) {
this.value = value;
}
public String getValue() {
return value;
}
}
/**
* 订单状态
*
* 实现带有抽象方法的枚举
*/
public enum OrderState {
/** 已取消 */
CANCEL {public String getName(){return "已取消";}},
/** 待审核 */
WAITCONFIRM {public String getName(){return "待审核";}},
/** 等待付款 */
WAITPAYMENT {public String getName(){return "等待付款";}},
/** 正在配货 */
ADMEASUREPRODUCT {public String getName(){return "正在配货";}},
/** 等待发货 */
WAITDELIVER {public String getName(){return "等待发货";}},
/** 已发货 */
DELIVERED {public String getName(){return "已发货";}},
/** 已收货 */
RECEIVED {public String getName(){return "已收货";}};
public abstract String getName();
}
public static void main(String[] args) {
//枚举是一种类型，用于定义变量，以限制变量的赋值；赋值时通过“枚举名.值”取得枚举中的值
ColorEnum colorEnum = ColorEnum.blue;
switch (colorEnum) {
case red:
System.out.println("color is red");
break;
case green:
System.out.println("color is green");
break;
case yellow:
System.out.println("color is yellow");
break;
case blue:
System.out.println("color is blue");
break;
}
//遍历枚举
System.out.println("遍历ColorEnum枚举中的值");
for(ColorEnum color : ColorEnum.values()){
System.out.println(color);
}
//获取枚举的个数
System.out.println("ColorEnum枚举中的值有"+ColorEnum.values().length+"个");
//获取枚举的索引位置，默认从0开始
System.out.println(ColorEnum.red.ordinal());//0
System.out.println(ColorEnum.green.ordinal());//1
System.out.println(ColorEnum.yellow.ordinal());//2
System.out.println(ColorEnum.blue.ordinal());//3
//枚举默认实现了java.lang.Comparable接口
System.out.println(ColorEnum.red.compareTo(ColorEnum.green));//-1
//--------------------------
System.out.println("===========");
System.err.println("季节为" + SeasonEnum.getSeason());
//--------------
System.out.println("===========");
for(Gender gender : Gender.values()){
System.out.println(gender.value);
}
//--------------
System.out.println("===========");
for(OrderState order : OrderState.values()){
System.out.println(order.getName());
}
}
}
712
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
