123 / 3 页下一页

老虎来了,你准备好了吗?(增加for-each) [复制链接]

jianan

家境小康

论坛徽章:: 0

11楼 [报告]

发表于 2004-03-06 13:22 |只看该作者

老虎来了,你准备好了吗?(增加for-each)

你的动漫是不错但有点太生硬了.

实战分享：从技术角度谈机器学习入门| 【大话IT】RadonDB低门槛向MySQL集群下战书 | ChinaUnix打赏功能已上线！ | 新一代分布式关系型数据库RadonDB知多少？

apoorzhj

白手起家

论坛徽章:: 0

12楼 [报告]

发表于 2004-03-07 23:17 |只看该作者

老虎来了,你准备好了吗?(增加for-each)

HoHo，Java也开始支持Generic了，原来的那个小不点也开始向巨无霸发展了

实战分享：从技术角度谈机器学习入门| 【大话IT】RadonDB低门槛向MySQL集群下战书 | ChinaUnix打赏功能已上线！ | 新一代分布式关系型数据库RadonDB知多少？

rollingpig

版主

论坛徽章:: 0

13楼 [报告]

发表于 2004-03-08 18:27 |只看该作者

老虎来了,你准备好了吗?(增加for-each)

AutoBoxing-Unboxing

在Tiger之前,往Colletion里存取Object是很烦人的事,Tiger中用Genric解决了这个难题.还有一件挺烦而无谓的事情,那就是往Colletion里存取原始类型(primitive type).
比如有一个Hashtable,你需要在里面记录某种操作的次数.在没用Genric前是这样的

//AccessRecord.java
import java.util.*;
public class AccessRecord{
private Hashtable accessRecord = new Hashtable();
public void addAccessRecord(String accessType){
int i = getAccessRecord(accessType);
accessRecord.put(accessType,new Integer(i+1));
}
public int getAccessRecord(String accessType){
Integer i = (Integer)(accessRecord.get(accessType));
if(i==null)
return 0;
else
return i.intValue();
}
}

复制代码

可以看出来,为了能够让Hashtable接受,我们必须用Integer来做一个wrapper,取出来之后还需要还原它.
就算现在有了Genric,也无济于事

//AccessRecordGenric.java
import java.util.*;
public class AccessRecordGenric{
private Hashtable<String,Integer>; accessRecord = new Hashtable<String,Integer>;();
public void addAccessRecord(String accessType){
int i = getAccessRecord(accessType);
accessRecord.put(accessType,new Integer(i+1));
}
public int getAccessRecord(String accessType){
Integer i = accessRecord.get(accessType);
if(i==null)
return 0;
else
return i.intValue();
}
}

复制代码

通过加入Genric特性,也仅仅是省了Cast的一步.
于是,Tiger引入了另一个特性,AutoBoxing-Unboxing(呵呵,第一次看到时,误认为是自动拳击手套,很想买一个来玩玩).
AutoBoxing指的是:在需要使用Object的场合中,我们可以只提供原始类型,编译器会自动为我们转换成相应的Wrapper类
AutoUnboxing指的是:在需要使用原始类型的场合中,我们可以只提供Wrapper类,编译器会自动为我们转换成相应的primitive type

现在我们就用AutoBoxing-unBoxing来改写刚才的class

//AccessRecordBoxing.java
import java.util.*;
public class AccessRecordBoxing{
private Hashtable<String,Integer>; accessRecord = new Hashtable<String,Integer>;();
public void addAccessRecord(String accessType){
accessRecord.put(accessType,getAccessRecord(accessType)+1);
}
public int getAccessRecord(String accessType){
Integer i = accessRecord.get(accessType);
return i==null?0:i;//hehe,想起oracle的nvl()函数 :）
}
public static void main(String args[]){
AccessRecordBoxing t = new AccessRecordBoxing();
t.addAccessRecord("asd");
System.out.println(t.accessRecord);
t.addAccessRecord("asd");
System.out.println(t.accessRecord);
t.addAccessRecord("sadfsd");
System.out.println(t.accessRecord);
t.addAccessRecord("df");
System.out.println(t.accessRecord);
t.addAccessRecord("sdf");
System.out.println(t.accessRecord);
}
}

复制代码

代码简洁了好多了吧!
你甚至可以这样使用

...
Integer i = 10;
j = i+10;
...

复制代码

使用AutoBoxing-unBoxing时点需要注意null object
必须检查被unboxing的object是否为null
不然会有NullPointerException

Interge i = null
;
int j = i+1;//NullPointerException

复制代码

实战分享：从技术角度谈机器学习入门| 【大话IT】RadonDB低门槛向MySQL集群下战书 | ChinaUnix打赏功能已上线！ | 新一代分布式关系型数据库RadonDB知多少？

rollingpig

版主

论坛徽章:: 0

14楼 [报告]

发表于 2004-03-09 17:02 |只看该作者

老虎来了,你准备好了吗?(增加for-each)

Type Safe Enum

Tiger的改进其实真的称得上是顺应民意,里面的好多特性都可以在两本Java巨著<<Think In Java>;>;和<<Effective Java>;>;发现一些端倪.
(不得不承认,<<Think In Java>;>;和<<Effective Java>;>;是Java历史上最经典的两本书,多读多受益)
比如,之前提到过的Genric,在<<Think In Java>;>; 第九章介绍Colletion时就对Genric作出了预期,同时也实现某种形式的Genric(TIJ 2ND,P449-P455).
另外,Think In Java里也提及了利用interface来定义一组常量的方法(P358-P360),不少标准的Java库类也使用了这种方法(如java.util.zip.ZipConsts.不过,你将会发现,在Tiger里它已经不复存在了)
这种做法叫做Const Interface,大家也许或多或少都使用过.但是,Const Interface的方式在<<Effective Java>;>;受到了极大的否定(Item 17).书里提出了使用Type Safe Enum的方法(Item 21)来取代Const Interface.让我们对比一下以下两段代码

Const Interface

//SeasonConst.java
// Constant interface pattern - do not use!
public interface SeasonConst {
public static final int SPRING = 1;
public static final int SUMMER = 2;
public static final int AUTUMN = 3;
public static final int WINTER = 4;
}
//TestConst.java
//using of Constant interface
public class TestConst implements SeasonConst{
public void seasonLiving(int season){
if(season==SPRING){
System.out.println("we BBQ at SPRING");
}
else if(season==SUMMER){
System.out.println("we swim at SUMMER");
}
else if(season==AUTUMN){
System.out.println("we kite at AUTUMN");
}
else if(season==WINTER){
System.out.println("we skate at WINTER");
}
else{
System.out.println("What ?");
}
}
public static void main(String args[]){
TestConst t = new TestConst();
t.seasonLiving(SPRING);
t.seasonLiving(WINTER);
t.seasonLiving(WINTER+1);
//t.sersonLiving(WEEK_DAY.MONDAY);//程序无法和其他常数完整的区分
}
}

复制代码

Type Safe Enum

//SeasonEnum.java
// The typesafe enum (j2sdk1.4)pattern
public class SeasonEnum {
private final String name;
private SeasonEnum(String name) {
this.name = name;
}
public String toString() { return name; }
public static final SeasonEnum SPRING = new SeasonEnum("SPRING");
public static final SeasonEnum SUMMER = new SeasonEnum("SUMMER");
public static final SeasonEnum AUTUMN = new SeasonEnum("AUTUMN");
public static final SeasonEnum WINTER = new SeasonEnum("WINTER");
}
//TestEnum.java
//using of typesafe enum (j2sdk1.4)
public class TestEnum{
public void seasonLiving(SeasonEnum season){
if(season==SeasonEnum.SPRING){
System.out.println("we BBQ at "+season);
}
else if(season==SeasonEnum.SUMMER){
System.out.println("we swim at "+season);
}
else if(season==SeasonEnum.AUTUMN){
System.out.println("we kite at "+season);
}
else if(season==SeasonEnum.WINTER){
System.out.println("we skate at "+season);
}
else{
System.out.println("What ?");
}
}
public static void main(String args[]){
TestEnum t = new TestEnum();
t.seasonLiving(SeasonEnum.SPRING);
t.seasonLiving(SeasonEnum.WINTER);
//t.seasonLiving(WINTER+1);no way to put a season not in the SeasonEnum
}
}

复制代码

可以看出,Type Safe Enum在以下几个方面优于Const Interface
1.不会违背OO继承的意义.
2.类型安全,不会有无意义的常数混进正常常数中
3.保持自己的独立性,不像Const interface再编译后就失去了意义
4.可直接用于print
5.作为一个Object,可以拥有自己的方法,变量,可以继承,implement interface

但是,相对的,Type Safe Enum在使用中也有几点不利的地方

1.不能直接用于switch
2.必须跟上类名,增加复杂性
3.繁琐

于是,Tiger中引入了 typesafe Enum和static import ,同时启用了一个新的关键字enum(这也是Tiger中引入的唯一一个关键字).再配合上Genric,使得整个结构变得严谨而易用.

让我们还是使用方才的例子来说明吧,先来一个最简单的例子.

public class TestEnumTiger1{
public enum SeasonSimpliest { SPRING, SUMMER, AUTUMN, WINTER}
public void seasonLiving(SeasonSimpliest season){
if(season==SeasonSimpliest.SPRING){
System.out.println("we BBQ at "+season);
}
else if(season==SeasonSimpliest.SUMMER){
System.out.println("we swim at "+season);
}
else if(season==SeasonSimpliest.AUTUMN){
System.out.println("we kite at "+season);
}
else if(season==SeasonSimpliest.WINTER){
System.out.println("we skate at "+season);
}
else{
System.out.println("What ?");
}
}
public static void main(String args[]){
TestEnumTiger1 t = new TestEnumTiger1();
t.seasonLiving(SeasonSimpliest.SPRING);
t.seasonLiving(SeasonSimpliest.WINTER);
System.out.println("the seasong is :"+SeasonSimpliest.SPRING);
//t.seasonLiving(WINTER+1);no way to put a season not in the SeasonEnum
//t.seasonLiving(new SeasonSimpliest("Five Season"));no way to put a season not in the SeasonEnum
}
}

复制代码

这里面的常量直接用enum修饰,再加上一个名字和所需常量就可以了.
enum SeasonSimpliest { SPRING, SUMMER, AUTUMN, WINTER}
不过,不要被这种形式所迷惑,以为enum是一个primtive type,与int,boolean一样,那就错了.
让我们编译一下这个文件,再看看编译后的目录
里面除了有TestEnumTiger1.java,TestEnumTiger1.class之外,还有一个TestEnumTiger1$SeasonSimpliest.class,这就暴露了enum的某些行为方式,它在某种意义上是一个class.
在上面的源码中,它成了一个inner-class.

OK.让我们改改代码,把enum作为一个独立个体来处理

//SeasonSimpliest.java
package test;
public enum SeasonSimpliest {SPRING,SUMMER,AUTUMN,WINTER}

复制代码

//enum & static import
package test;
import static test.SeasonSimpliest.*;
public class TestEnumTiger2{
public void seasonLiving(SeasonSimpliest season){
switch(season){
case SPRING:
System.out.println("we BBQ at "+season);
break;
case SUMMER:
System.out.println("we swim at "+season);
break;
case AUTUMN:
System.out.println("we kite at "+season);
break;
case WINTER:
System.out.println("we skate at "+season);
break;
default:throw new AssertionError("something must be wrong,no such a season");
}
}
public static void main(String args[]){
TestEnumTiger2 t = new TestEnumTiger2();
t.seasonLiving(SPRING);
t.seasonLiving(WINTER);
System.out.println("the season is :"+SUMMER);
//t.seasonLiving(WINTER+1);no way to put a season not in the SeasonEnum
//t.seasonLiving(new SeasonSimpliest("Five Season"));no way to put a season not in the SeasonEnum
}
}

复制代码

为了使整个代码显得更加简洁,我引入import static ,稍后再作更详细介绍,现在先来看看enum的好处.
1.避免了使用Const interface
2.很简单的定义方式
3.Type Safe,类型安全的,不会和其他的常量混绕.
4.可以使用switch
5.作为一个Class,它可以有自己Method,Field,也可以implements interface.

为了更好的说明第5点,我给大家展示一个复杂的enum type.

//SeasonComplex.java
//implements interface,owner method & field
public enum SeasonComplex implements Comparable<SeasonComplex>; {
SPRING(1),
SUMMER(2),
AUTUMN(3),
WINTER(4);
private final int seasonNumber;
Season(int value){
seasonNumber=value;
}
public int seasonNumber(){
return seasonNumber;
}
public int compare(Season c){
return seasonNumber - c.seasonNumber;
}
public String description(){
return this+":第"+ seasonNumber +"季";
}
};

复制代码

具体的我就不一一写清楚,大家好好体会吧.

时间不早,关于static import 明天再慢慢说.

实战分享：从技术角度谈机器学习入门| 【大话IT】RadonDB低门槛向MySQL集群下战书 | ChinaUnix打赏功能已上线！ | 新一代分布式关系型数据库RadonDB知多少？

rollingpig

版主

论坛徽章:: 0

15楼 [报告]

发表于 2004-03-12 13:53 |只看该作者

老虎来了,你准备好了吗?(增加for-each)

static import
static import就是允许在代码中直接引用别的类的static变量和方法（当然，在权限许可范围内），我们可以简单的把它当成import的延续。
它的语法如下：
import static CLASS_NAME.MEMBER_NAME;
或者 import static CLASS_NAME.×;

事实上，Tiger引入static import最主要考虑到两个需要，第一个就是对一些工具性的，常用的静态方法进行直接引用。
比如,java.lang.Math里的一大堆数学方法abs,exp等。
第二个就是对常数变量进行直接引用，其中也包扩对enum的直接引用（参考上一篇文章Season的例子）

//StaticImportTest.java
import static java.lang.Math.*;
public class StaticImportTest{
public static void main(String arsg[]){
System.out.println("1 ＋ 1 ="+(1+1));
System.out.println("abs(-1)="+abs(-1));
System.out.println("exp(1.5)="+exp(1.5));
System.out.println("Pi = "+PI);
System.out.println("E = "+E);
}
}

复制代码

这样的代码不仅省却了Programmer的劳动，在可读性上也是有所增强。

static import的限制和import也基本一样，就是不能出现二义性。
另外，static import不支持先import类，然后import static 类.*(不加package)的形式
如

import java.util.*;
import static Calendar.*;
......

复制代码

就算在同一个包也是如此。

值得注意的是，过多的static import也许可能影响程序的可读性，如：

//StaticImportTest2.java
import static java.lang.Integer.parseInt;
import static java.lang.Double.*;
public class StaticImportTest{
public static void main(String arsg[]){
String iv = "1239";
String dv = "123.3456";
System.out.println(iv+":"+parseInt(iv));
System.out.println(dv+":"+parseDouble(dv));
System.out.println("Double's MaxValue is:"+MAX_VALUE );
}

复制代码

虽然能编译通过，但是却很容易混绕读者视线。

实战分享：从技术角度谈机器学习入门| 【大话IT】RadonDB低门槛向MySQL集群下战书 | ChinaUnix打赏功能已上线！ | 新一代分布式关系型数据库RadonDB知多少？

rollingpig

版主

论坛徽章:: 0

16楼 [报告]

发表于 2004-03-12 16:33 |只看该作者

老虎来了,你准备好了吗?(增加for-each)

Variable-Arity Methods(Varargs)
可匹配不同长度的自变量的函数，意思就是说，定义好的同一个Method,可以接收个数不一样的变量，看起来有点类似于过载。
我们还是先来看一个例子吧。

//TestVarargs.java
public class TestVarargs{
//这个方法展示了varargs的基本语法
// 类型（Type）,加3个点，再加变量名,中间可以有或无空格
// 而使用该变量时，是以一个Type[]的形式的,等于是一个Array
//public static void out(int... i){//这种可以
//public static void out(int ...i){//这种也可以
//public static void out(int ... i){//这种也可以
public static void out(int...i){//这种也可以
System.out.println("method:out(int... i),vararg.length:"+i.length);
if(i.length==0)
return;
//for-each featrue
for(Object ii:i)
System.out.print("\t "+ii);
System.out.println();
}
//和 out(Object... i) 存在二义性
//public static void out(int i1,int... i){...}
//varargs 只能出现在parameter的最后
//public static void out(int... i,String s){...}
//当然，其他变量可以出现在前面。
public static void out(String s,int... i){
System.out.println("method:out(String s,int... i),vararg.length:"+i.length);
if(i.length==0)
return;
//for-each future
for(int ii:i)
System.out.print("\t "+ii);
System.out.println();
}
public static void main(String args[]){
out(123,1343,4542,677675);
out(12323,43243,00);
out("",12);
out("");
out();
}
}

复制代码

该说明的基本上都在源码的注释里头了。
值得一提的是，根据JSR201的说法，对它的支持主要是在complier上，在VM的层面上是不需要支持的。在某种意义上，我们可以把它看作

out(int...i){};
out(123,1343,4542,677675);
==
out(int[] i){};
out(new Int[]{123,1343,4542,677675});

复制代码

实战分享：从技术角度谈机器学习入门| 【大话IT】RadonDB低门槛向MySQL集群下战书 | ChinaUnix打赏功能已上线！ | 新一代分布式关系型数据库RadonDB知多少？

rollingpig

版主

论坛徽章:: 0

17楼 [报告]

发表于 2004-03-15 14:14 |只看该作者

老虎来了,你准备好了吗?(增加for-each)

for-each(enhanced for loop )
接下来向你介绍的Tiger新特性,应该是大家比较期待的一个，在前面的例子里已经数次出现。
对了，就是 for-each(enhanced for loop )特性了。

for-each(enhanced for loop ),说得全一点应该是 for each element in the aggregation 。顾名思义，就是在for循环中逐个取出集合中的元素。
它的语法是
for(Type i : 集合){
i ...
}

这里的集合包括两种：
第一种是实现java.lang.Iterable接口的类，第二种就是array(数组)。
java.lang.Iterable是一个Tiger新引入的接口.在Tiger中，java.util.Colletcion 接口直接继承了 Iterable 接口。所以，所有Colletcion的子类都可以用于for-each语法里。同时，由于java.util.Map 接口里有 Collection<V>; values(),Set<Map.Entry<K,V>;>; entrySet() 和 Set<K>; keySet()三个方法返回Collention的子类。所以所有Map的子类也是可以间接的使用在for-each语句里的。
还是先来看一个例子吧.

//TestForEach.java
import java.util.*;
public class TestForEach{
public static void main(String arg[]){
ArrayList list = new ArrayList();
list.add("asdf");
list.add("fdaf");
list.add("dfafds");
list.add("dsafdsaf");
int i=1;
for(Object s : list){
list.remove(s);
System.out.println("element "+i+" is:"+s);
i++;
}
i=1;
Object o[] = list.toArray();
for(Object s : o){
System.out.println("element "+i+" is:"+s);
i++;
}
}
}

复制代码

for-each使我们更方便对集合里的元素进行遍历。实际上，编译器在处理Iterable和array时,分别采用如下的方法进行转换

Iterable:
for ( Iterator<E>; #i = Expression.iterator(); #i.hasNext(); ) {
FormalParameter = #i.next();
Statement
}
array:
Type[] #a = Expression;
L1: L2: ... Lm://The possibly empty sequence of labels preceding the enhanced for loop is represented by L1: L2: ... Lm. This sequence is moved beyond the assignment to #a so that continue and break statements with labels will work properly.
for (int #i = 0; #i < #a.length; #i++) {
FormalParameter = #a[ #i ] ;
Statement
}

复制代码

不过，值得注意的是，在Iterable中，for-each遍历是concurrent的，也就是说，在对Iterable进行遍历时，Iterable对象是不能改变的。这意味着我们不可以通过for-each进行移除以及修改的动作.

//TestForEach2.java
import java.util.*;
public class TestForEach2{
public static void main(String arg[]){
ArrayList list = new ArrayList();
list.add("asdf");
list.add("fdaf");
list.add("dfafds");
list.add("dsafdsaf");
int i=1;
for(Object s : list){
System.out.println("removing element "+i+" :"+s);
list.remove(s);//java.util.ConcurrentModificationException
i++;
}
}
}
//运行
removing element 1 :asdf
java.util.ConcurrentModificationException
at java.util.AbstractList$Itr.checkForComodification(AbstractList.java:449)
at java.util.AbstractList$Itr.next(AbstractList.java:420)
at TestForEach.main(TestForEach.java:11)
Exception in thread "main" Normal Termination

复制代码

创建我们的可以直接用于for-each的类

通常，我们都通过数组或者是Collection/Map的子类来使用for-each语句，当然我们也可以创建自己的for-each类（Iterable）
java.lang.Iterable是一个Tiger新引入的接口，它要求实现的方法只有一个，就是 Iterator<T>; iterator().这就要求我们需要去构造一个Iterator.Iterator接口有三个方法：boolean hasNext(),Type next()和remove()，其中remove为optional opreration，可以不必实现。

下面的例子使用了一个Iterator的内部类,就其意义来说，是实现一组的平方数的一个迭代。（现实中也许永远不需这种用法 :））