亚洲国产高清视频,91久久亚洲国产成人精品性色,亚洲av无码专区国产不乱码

redcoatjk — Fri, 27 May 2011 10:15:00 GMT

摘自:

http://www.iteye.com/topic/257191

-----------------

今天下午研究了半天hashcode()和equals()�Ҏ��Q�终于有了一点点的明白，写下来与大家分��n�Q�zhaoxudong 2008.10.23�?1.36�Q��?
1. 首先equals()和hashcode()�q�两个方法都是从object�c�M��l�承�q�来的�?
equals()�Ҏ��在object�c�M��定义如下�Q?
public boolean equals(Object obj) {
return (this == obj);
}
很明显是对两个对象的地址��D��行的比较�Q�即比较引用是否相同�Q�。但是我们必需清楚�Q�当String 、Math、还有Integer、Double。。。。等�q�些��装�c�d��使用equals()�Ҏ��Ӟ��已经覆盖了object�cȝ��equals�Q�）�Ҏ��。比如在String�c�M��如下�Q?
public boolean equals(Object anObject) {
if (this == anObject) {
    return true;
}
if (anObject instanceof String) {
    String anotherString = (String)anObject;
    int n = count;
    if (n == anotherString.count) {
char v1[] = value;
char v2[] = anotherString.value;
int i = offset;
int j = anotherString.offset;
while (n-- != 0) {
    if (v1[i++] != v2[j++])
return false;
}
return true;
    }
}
return false;
}
很明显，�q�是�q�行的内�Ҏ��较，而已�l�不再是地址的比较。依�ơ类推Double、Integer、Math。。。。等�{�这些类都是重写了equals()�Ҏ��的，从而进行的是内容的比较。当然了基本�c�d��是进行值的比较�Q�这个没有什么好说的�?
我们�q�应该注意，Java语言对equals()的要求如下，�q�些要求是必��遵循的�Q?
• 对称性：如果x.equals(y)�q�回�?#8220;true”�Q�那么y.equals(x)也应该返回是“true”�?
• 反射性：x.equals(x)必须�q�回�?#8220;true”�?
• �c�L��性：如果x.equals(y)�q�回�?#8220;true”�Q�而且y.equals(z)�q�回�?#8220;true”�Q�那么z.equals(x)也应该返回是“true”�?
• �q�有一致性：如果x.equals(y)�q�回�?#8220;true”�Q�只要x和y内容一直不变，不管你重复x.equals(y)多少�ơ，�q�回都是“true”�?
• ��M��情况下，x.equals(null)�Q�永�q�返回是“false”�Q�x.equals(和x不同�c�d��的对�?永远�q�回�?#8220;false”�?
以上�q�五�Ҏ��重写equals()�Ҏ��Ӟ��必须遵守的准则，如果�q�反会出现意想不到的�l�果�Q�请大家一定要遵守�?
2. 其次是hashcode() �Ҏ��Q�在object�c�M��定义如下�Q?
public native int hashCode();
说明是一个本地方法，它的实现是根据本地机器相关的。当然我们可以在自己写的�c�M��覆盖hashcode()�Ҏ��Q�比如String�?Integer、Double。。。。等�{�这些类都是覆盖了hashcode()�Ҏ��的。例如在String�c�M��定义的hashcode()�Ҏ��如下�Q?
    public int hashCode() {
int h = hash;
if (h == 0) {
    int off = offset;
    char val[] = value;
    int len = count;

            for (int i = 0; i < len; i++) {
                h = 31*h + val[off++];
            }
            hash = h;
        }
        return h;
}
解释一下这个程序（String的API中写刎ͼ��Q?
s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1]
使用 int ��法�Q�这�?s[i] 是字�W�串的第 i 个字�W�，n 是字�W�串的长度，^ 表示求幂。（�I�字�W�串的哈希码�?0。）

3.�q�里我们首先要明白一个问题：
equals()相等的两个对象，hashcode()一定相�{�；
equals�Q�）不相�{�的两个对象�Q�却�q�不能证明他们的hashcode()不相�{�。换句话��_��equals()�Ҏ��不相�{�的两个对象�Q�hashcode()有可能相�{�。（我的理解是由于哈希码在生成的时候��生冲�H�造成的）�?
反过来：hashcode()不等�Q�一定能推出equals()也不�{�；hashcode()相等�Q�equals()可能相等�Q�也可能不等。解�?下第3点的使用范围�Q�我的理解是在object、String�{�类中都能��用。在object�c�M��Q�hashcode()�Ҏ��是本地方法，�q�回的是对象�?地址��|��而object�c�M��的equals()�Ҏ��比较的也是两个对象的地址��|��如果equals()相等�Q�说明两个对象地址��g��相等�Q�当�?hashcode()也就相等了；在String�c�M��Q�equals()�q�回的是两个对象内容的比较，当两个对象内容相�{�时�Q?
Hashcode()�Ҏ��Ҏ��String�cȝ��重写�Q�第2炚w��面已�l�分析了�Q�代码的分析�Q�也可知道hashcode()�q�回�l�果也会相等。以此类推，可以知道Integer、Double�{�封装类中经�q�重写的equals()和hashcode()�Ҏ��也同样适合于这个原则。当然没有经�q�重写的 �c�，在��承了object�cȝ��equals()和hashcode()�Ҏ��后，也会遵守�q�个原则�?

4.谈到hashcode()和equals()��׃��能不说到hashset,hashmap,hashtable中的使用�Q�具体是怎样呢，��L��如下分析�Q?
Hashset是��承Set接口�Q�Set接口又实现Collection接口�Q�这是层�ơ关�p�R��那么hashset是根据什么原理来存取对象的呢�Q?
在hashset中不允许出现重复对象�Q�元素的位置也是不确定的。在hashset中又是怎样判定元素是否重复的呢�Q�这��是问题的关键所在，�l�过一下午的查询求证终于获得了一点启�C�，和大家分享一下，在java的集合中�Q�判断两个对象是否相�{�的规则是：
1)�Q�判断两个对象的hashCode是否相等
      如果不相�{�，认�ؓ两个对象也不相等�Q�完�?
      如果相等�Q��{�?)
�Q�这一点只是�ؓ了提高存储效率而要求的�Q�其实理��Z��没有也可以，但如果没有，实际使用时效率会大大降低�Q�所以我们这里将其做为必需的。后面会重点讲到�q�个问题。）
2)�Q�判断两个对象用equals�q�算是否相等
      如果不相�{�，认�ؓ两个对象也不相等
      如果相等�Q�认��Z��个对象相�{�（equals()是判断两个对象是否相�{�的关键�Q?
��Z��么是两条准则�Q�难道用�W�一条不行吗�Q�不行，因�ؓ前面已经说了�Q�hashcode()相等�Ӟ��equals()�Ҏ��也可能不�{�，所以必��ȝ��W?条准则进行限�Ӟ��才能保证加入的�ؓ非重复元素�?
比如下面的代码：

public static void main(String args[]){
String s1=new String("zhaoxudong");
String s2=new String("zhaoxudong");
System.out.println(s1==s2);//false
System.out.println(s1.equals(s2));//true
System.out.println(s1.hashCode());//s1.hashcode()�{�于s2.hashcode()
System.out.println(s2.hashCode());
Set hashset=new HashSet();
hashset.add(s1);
hashset.add(s2);
/*实质上在��d��s1,s2�Ӟ��q�用上面说到的两点准则，可以知道hashset认�ؓs1和s2是相�{�的�Q�是在添加重复元素，所以让s2覆盖了s1;*/
Iterator it=hashset.iterator();
            while(it.hasNext())
            {
             System.out.println(it.next());
            }
最后在while循环的时候只打印��Z��一�?#8221;zhaoxudong”�?
输出�l�果为：false
            true
            -967303459
            -967303459
�q�是因�ؓString�c�d��l�重写了equals()�Ҏ��和hashcode()�Ҏ��Q�所以在�Ҏ��上面的第1.2条原则判定时�Q�hashset认�ؓ它们是相�{�的对象�Q�进行了重复��d��?
但是看下面的�E�序�Q?
import java.util.*;
public class HashSetTest
{
   public static void main(String[] args)
    {
                 HashSet hs=new HashSet();
                 hs.add(new Student(1,"zhangsan"));
                 hs.add(new Student(2,"lisi"));
                 hs.add(new Student(3,"wangwu"));
                 hs.add(new Student(1,"zhangsan"));

                 Iterator it=hs.iterator();
                 while(it.hasNext())
                 {
                        System.out.println(it.next());
                 }
     }
}
class Student
   {
     int num;
     String name;
     Student(int num,String name)
                {
                this.num=num;
                 this.name=name;
                 }
              public String toString()
                {
                    return num+":"+name;
                 }
           }
输出�l�果为：
                      1:zhangsan
                   1:zhangsan
                   3:wangwu
                   2:lisi
问题出现了，��Z��么hashset��d��了相�{�的元素呢，�q�是不是和hashset的原则违背了呢？回答是：没有
因�ؓ在根据hashcode()对两�ơ徏立的new Student(1,"zhangsan")对象�q�行比较�Ӟ��生成的是不同的哈希码��|��所以hashset把他当作不同的对象对待了�Q�当然此时的 equals()�Ҏ��q�回的��g��不等�Q�这个不用解释了吧）。那么�ؓ什么会生成不同的哈希码值呢�Q�上面我们在比较s1和s2的时候不是生成了同样的哈希码吗？原因��在于我们自己写的Student�c�dƈ没有重新自己的hashcode()和equals()�Ҏ��Q�所以在比较�Ӟ��是��承的object�c�M��?hashcode()�Ҏ��Q�呵呵，各位�q�记得object�c�M��的hashcode()�Ҏ��比较的是什么吧�Q�！
它是一个本地方法，比较的是对象的地址�Q�引用地址�Q�，使用new�Ҏ��创徏对象�Q�两�ơ生成的当然是不同的对象了（�q�个大家都能理解吧。。。）�Q�造成的结果就是两个对象的hashcode()�q�回的��g��一栗��所以根据第一个准则，hashset会把它们当作不同的对象对待，自然也用不着�W�二个准则进�?判定了。那么怎么解决�q�个问题呢？�Q?
�{�案是：在Student�c�M��重新hashcode()和equals()�Ҏ��?
例如�Q?
class Student
{
int num;
String name;
Student(int num,String name)
{
            this.num=num;
            this.name=name;
}
public int hashCode()
{
            return num*name.hashCode();
}
public boolean equals(Object o)
{
            Student s=(Student)o;
            return num==s.num && name.equals(s.name);
}
public String toString()
{
            return num+":"+name;
}
}
�Ҏ��重写的方法，即便两次调用了new Student(1,"zhangsan")�Q�我们在获得对象的哈希码�Ӟ��Ҏ��重写的方法hashcode()�Q�获得的哈希码肯定是一��L��Q�这一点应该没有疑问吧�Q��?
当然�Ҏ��equals()�Ҏ��我们也可判断是相同的。所以在向hashset集合中添加时把它们当作重复元素看待了。所以运行修改后的程序时�Q�我们会发现�q�行�l�果是：
                      1:zhangsan
                   3:wangwu
                   2:lisi
可以看到重复元素的问题已�l�消除�?
关于在hibernate的pojo�c�M��Q�重新equals()和hashcode()的问题：
1)�Q�重�Ҏ��equals�Q�重写hashCode只是技术要求（��Z��提高效率�Q?
2)�Q��ؓ什么要重写equals呢，因�ؓ在java的集合框架中�Q�是通过equals来判断两个对象是否相�{�的
3)�Q�在hibernate中，�l�常使用set集合来保存相兛_��象，而set集合是不允许重复的。我们再来谈谈前面提到在向hashset集合中添加元素时,怎样判断对象是否相同的准则，前面说了两条�Q�其实只要重写equals()�q�一条也可以�?
但当hashset中元素比较多�Ӟ��或者是重写的equals()�Ҏ��比较复杂�Ӟ��我们只用equals()�Ҏ��q�行比较判断�Q�效率也会非�怽��Q?所以引入了hashcode()�q�个�Ҏ��Q�只是�ؓ了提高效率，但是我觉得这是非常有必要的（所以我们在前面以两条准则来�q�行hashset的元素是否重�?的判断）�?
比如可以�q�样写：
public int hashCode(){
   return 1;}//�{��h于hashcode无效
�q�样做的效果��是在比较哈希码的时候不能进行判断，因�ؓ每个对象�q�回的哈希码都是1�Q�每�ơ都必须要经�q�比较equals()�Ҏ��后才能进行判断是否重复，�q�当然会引�v效率的大大降低�?
我有一个问题，如果像前面提到的在hashset中判断元素是否重复的必要�Ҏ��是equals()�Ҏ��Q�根据网上找到的观点�Q�，但是�q�里�q�没有涉及到关于哈希表的问题�Q�可是这个集合却叫hashset�Q�这是�ؓ什么？�Q?
我想�Q�在hashmap,hashtable中的存储操作�Q�依焉��守上面的准则。所以这里不再多说。这些是今天看书�Q�网上查询资料，自己�ȝ��出来的，部分代码和语�a�是引�q�ͼ�但是千真万确是自己�ȝ��出来的。有错误之处和不详细不清楚的地方�q�请大家指出�Q�我也是初学者，所以难免会有错误的地方�Q�希望大家共同讨论�?

redcoatjk 2011-05-27 18:15 发表评论

java各种数据�c�d��转换

redcoatjk — Mon, 21 Feb 2011 05:34:00 GMT

各种数字�c�d��转换成字�W�串型：

String s = String.valueOf( value); // 其中 value ��Z�Q意一�U�数字类型�?

字符串型转换成各�U�数字类型：

String s = "169";
byte b = Byte.parseByte( s );
short t = Short.parseShort( s );
int i = Integer.parseInt( s );
long l = Long.parseLong( s );
Float f = Float.parseFloat( s );
Double d = Double.parseDouble( s );

数字�c�d��与数字类对象之间的�{换：

byte b = 169;
Byte bo = new Byte( b );
b = bo.byteValue();

short t = 169;
Short to = new Short( t );
t = to.shortValue();

int i = 169;
b = bo.byteValue();

short t = 169;
Short to = new Short( t );
t = to.shortValue();

int i = 169;
Integer io = new Integer( i );
i = io.intValue();

long l = 169;
Long lo = new Long( l );
l = lo.longValue();

float f = 169f;
Float fo = new Float( f );
f = fo.floatValue();

double d = 169f;
Double dObj = new Double( d );
d = dObj.doubleValue();

redcoatjk 2011-02-21 13:34 发表评论

redcoatjk — Sun, 16 May 2010 07:35:00 GMT

概述
J2SE(TM) 5.0引入了很多激�q�的语言元素变化�Q�这些变化或多或��减��M��我们开发�h员的一些编码负担，其中的大部分也必然会被应用到卛_��发布�?a target="_blank">J2EE(TM) 5.0中。主要的新特性包括：

　　· 泛型

　　· 增强的for循环

　　· 自动装箱和自动拆��?/p>

　　· �c�d��安全的枚�?/p>

　　· 可变长度参数

　　· 静态引�?/p>

　　· 元数�?注解)

　　· C风格的格式化输出

　　�q�当中，泛型、枚丑֒�注解可能会占用较大的��幅�Q�而其余的因�ؓ用法直截了当�Q�抑或相对简单，我就�E�作介绍�Q�剩下的留给读者去思考、去探烦了�?/p>

　　1.4. 泛型

　　泛型�q�个题目相当大，大到完全可以��p��个话题写一本书。有关Java是否需要泛型和如何实现泛型的讨��Z��早就在Java�C��q��ؓ��传。终于，我们在J2SE(TM) 5.0中看��C��它。也许目前Java�Ҏ��型的支持�q�算不上��_��理想�Q�但�q�一�Ҏ��的��d��也经��以让我们欣喜一阵了�?/p>

　　在接下来的介�l�中�Q�我们会了解刎ͼ�Java的泛型虽然跟C++的泛型看上去十分�怼��Q�但其实有着相当大的区别�Q�有些细节的东西也相当复�?臛_��很多地方会跟我们的直觉背道而驰)。可以这栯��Q�泛型的引入在很大程度上增加了Java语言的复杂度�Q�对初学者尤其是个挑战。下面我们将一点一点往里挖�?/p>

　　首先我们来看一个简单的使用泛型�cȝ��例子�Q?/p>

    ArrayList aList = new ArrayList();
    aList.add(new Integer(1));
    // ...
    Integer myInteger = aList.get(0);

　　我们可以看到�Q�在�q�个��单的例子中，我们在定义aList的时候指明了它是一个直接受Integer�c�d��的ArrayList�Q�当我们调用aList.get(0)�Ӟ��我们已经不再需要先昑ּ�的将�l�果转换成Integer�Q�然后再赋值给myInteger了。而这一步在早先的Java版本中是必须的。也�怽�在想�Q�在使用Collection时节�U�一些类型�{换就是Java泛型的全部吗?�q�不止。单��p��个例子而言�Q�泛型至��还有一个更大的好处�Q�那��是使用了泛型的容器�c�d��得更加健壮：早先�Q�Collection接口的get()和Iterator接口的next()�Ҏ��都只能返回Object�c�d��的结果，我们可以把这个结果强制�{换成��M��Object的子�c�，而不会有��M��~�译期的错误�Q�但�q�显然很可能带来严重的运行期错误�Q�因为在代码中确定从某个Collection中取出的是什么类型的对象完全是调用者自��p��了算�Q�而调用者也许�ƈ不清楚放�q�Collection的对象具体是什么类�?��q��知道放进�ȝ��对象“应该”是什么类�Q�也不能保证攑ֈ�Collection的对象就一定是那个�cȝ��实例。现在有了泛型，只要我们定义的时候指明该Collection接受哪种�c�d��的对象，�~�译器可以帮我们避免�c�M��的问题溜��C�品中。我们在实际工作中其实已�l�看��C��太多的ClassCastException�Q�不是吗?

　　泛型的��用从�q�个例子看也是相当易懂。我们在定义ArrayList�Ӟ��通过�c�d��后面�?lt;>括号中的值指定这个ArrayList接受的对象类型。在�~�译的时候，�q�个ArrayList会被处理成只接受该类或其子类的对象，于是��M��试图��其他类型的对象��d��q�来的语句都会被�~�译器拒�l��?/p>

　　那么泛型是怎样定义的呢?看看下面�q�一�D늤�例代码：(其中用E代替在实际中��会使用的类名，当然你也可以使用别的名称�Q�习惯上在这里��用大写的E�Q�表�C�Collection的元素�?

    public class TestGenerics {
    Collection col;
    public void doSth(E elem) {
    col.add(elem);
    // ...
    }
    }
      在泛型的使用中，有一个很�Ҏ��有的误解�Q�那��是既然Integer是从Object�z��出来的，那么ArrayList当然��是ArrayList的子�c�R��真的是�q�样吗？我们仔细想一惛_��会发现这样做可能会带来的问题�Q�如果我们可以把ArrayList向上转型为ArrayList�Q�那么在往�q�个转了型以后的ArrayList中添加对象的时候，我们岂不是可以添加�Q何类型的对象�Q�因为Object是所有对象的公共父类�Q�？�q�显然让我们的ArrayList失去了原本的目的。于是Java�~�译器禁止我们这样做。那既然是这��P��ArrayList以及ArrayList、ArrayList�{�等有没有公��q��父类呢？有，那就是ArrayList�?在这里叫做通配�W�。我们�ؓ了羃��通配�W�所指代的范��_��通常也需要这样写�Q�ArrayList�Q�这样写的含义是定义�q�样一个类ArrayList�Q�比方说SomeClass有SomeExtendedClass1和SomeExtendedClass2�q�两个子�c�，那么ArrayList��是如下几个�cȝ��父类�Q�ArrayList、ArrayList和ArrayList�?nbsp;

       接下来我们更�q�一步：既然ArrayList是一个通配的公用父�c�，那么我们可不可以往声明为ArrayList的ArrayList实例中添加一个SomeExtendedClass1的对象呢�Q�答案是不能。甚至你不能��d��M��对象。�ؓ什么？因�ؓArrayList实际上代表了所有ArrayList、ArrayList和ArrayList三种ArrayList�Q�甚臛_��括未知的接受SomeClass其他子类对象的ArrayList。我们拿��C��个定义�ؓArrayList的ArrayList的时候，我们�q�不能确定这个ArrayList具体是��用哪个类作�ؓ参数定义的，因此�~�译器也无法让这�D�代码编译通过。�D例来�Ԍ��如果我们惛_��q�个ArrayList中放一个SomeExtendedClass2的对象，我们如何保证它实际上不是其他的如ArrayList�Q�而就是这个ArrayList呢？�Q�还记得吗？ArrayList�q��ArrayList的子�c�R��）怎么办？我们需要��用泛型方法。泛型方法的定义�c�M��下面的例子：
    public static void add (Collection c, T elem) {
    c.add(elem);
    }

　　其中T代表了我们这个方法期待的那个最�l�的具体的类�Q�相关的声明必须攑֜��Ҏ��{�֐�中紧靠返回类型的位置之前。在本例中，它可以是SomeClass或者SomeClass的�Q何子�c�，其说�?t entends SomeClass>攑֜�void关键字之�?只能攑֜��q�里)。这��h��们就可以让编译器��信当我们试图添加一个元素到泛型的ArrayList实例中时�Q�可以保证类型安全�?/p>

　　Java泛型的最大特点在于它是在语言�U�别实现的，区别�?a target="_blank">C# 2.0中的CLR�U�别。这��L��做法使得JRE可以不必做大的调��_��~�点是无法支持一些运行时的类型甄别。一旦编译，它就被写��M��Q�能提供的动态能力相当弱�?/p>

　　个�h认�ؓ泛型是这�ơJ2SE(TM) 5.0中引入的最重要的语�a�元素�Q�给Java语言带来的媄响也是最大。�D个例子来�Ԍ��我们可以看到�Q�几乎所有的Collections API都被更新成支持泛型的版本。这样做带来的好处是显而易见的�Q�那��是减少代码重复(不需要提供多个版本的某一个类或者接口以支持不同�cȝ��对象)以及增强代码的健壮�?�~�译期的�c�d��安全��?。不�q�如何才能真正利用好�q�个�Ҏ��，��其是如何实现自��q��泛型接口或类供他��Z��用，��ƈ非那么显而易见了。让我们一起在使用中慢慢积累�?/p>

　　1.5. 增强的for循环

　　你是否已�l�厌倦了每次写for循环旉��要写上那些机械的代码�Q�尤其当你需要遍历数�l�或者Collection�Q�如�Q?假设在Collection中储存的对象是String�c�d��?

    public void showAll (Collection c) {
    for (Iterator iter = c.iterator(); iter.hasNext(); ) {
    System.out.println((String) iter.next());
    }
    }

    public void showAll (String[] sa) {
    for (int i = 0; i < sa.length; i++) {
    System.out.println(sa[i]);
    }
    }

　　�q�样的代码不仅显得臃肿，而且�Ҏ��出错�Q�我��x��们大家在刚开始接触编�E�时�Q�尤其是C/C++和Java�Q�可能多��都犯过以下�c�M��错误的一�U�或几种�Q�把for语句的三个表辑ּ��序弄错;�W�二个表辑ּ�逻辑判断不正��?漏掉一些、多��Z��些、甚��x��循环);忘记�U�d��游标;在��@环体内不��心改变了游标的位置�{�等。�ؓ什么不能让�~�译器帮我们处理�q�些�l�节�?�?.0中，我们可以�q�样写：

    public void showAll (Collection c) {
    for (Object obj : c) {
    System.out.println((String) obj);
    }
    }

    public void showAll (String[] sa) {
    for (String str : sa) {
    System.out.println(str);
    }
    }

　　�q�样的代码显得更加清晰和��z�，不是�?具体的语法很��单：使用":"分隔开�Q�前面的部分写明从数�l�或Collection中将要取出的�c�d��Q�以及��用的临时变量的名字，后面的部分写上数�l�或者Collection的引用。加上泛型，我们甚至可以把第一个方法变得更加漂亮：

    public void showAll (Collection cs) {
    for (String str : cs) {
    System.out.println(str);
    }
    }

　　有没有发玎ͼ�当你需要将Collection替换成String[]�Q�你所需要做的仅仅是��单的把参数类�?Collection"替换�?String[]"�Q�反�q�来也是一��P��你不完全需要改其他的东�ѝ��这在J2SE(TM) 5.0之前是无法想象的�?/p>

　　对于�q�个看上�ȝ��当方便的新语�a�元素�Q�当你需要在循环体中讉K��游标的时候，会显得很别扭�Q�比方说�Q�当我们处理一个链表，需要更新其中某一个元素，或者删除某个元素等�{�。这个时候，你无法在循环体内获得你需要的游标信息�Q�于是需要回退到原先的做法。不�q�，有了泛型和增强的for循环�Q�我们在大多数情况下已经不用��L��心那些烦人的for循环的表辑ּ�和嵌套了。毕竟，我们大部分时间都不会需要去了解游标的具体位�|�，我们只需要遍历数�l�或Collection�Q�对�?

　　1.6. 自动装箱/自动拆箱

　　所谓装��，��是把值类型用它们相对应的引用�c�d��包�v来，使它们可以具有对象的特质�Q�如我们可以把int型包装成Integer�cȝ��对象�Q�或者把double包装成Double�Q�等�{�。所谓拆��，��是跟装��q��方向相反�Q�将Integer及Double�q�样的引用类型的对象重新��化�ؓ值类型的数据�?/p>

　　在J2SE(TM) 5.0发布之前�Q�我们只能手工的处理装箱和拆��。也�怽�会问�Q��ؓ什么需要装��和拆箱?比方说当我们试图��一个值类型的数据��d��C��个Collection中时�Q�就需要先把它装箱�Q�因为Collection的add()�Ҏ��只接受对�?而当我们需要在�E�后��这条数据取出来�Q�而又希望使用它对应的值类型进行操作时�Q�我们又需要将它拆��成值类型的版本。现在，�~�译器可以帮我们自动地完成这些必要的步骤。下面的代码我提供两个版本的装箱和拆��，一个版本��用手工的方式�Q�另一个版本则把这些显而易见的代码交给�~�译器去完成�Q?/p>

    public static void manualBoxingUnboxing(int i) {
    ArrayList aList = new ArrayList();
    aList.add(0, new Integer(i));
    int a = aList.get(0).intValue();
    System.out.println("The value of i is " + a);
    }

    public static void autoBoxingUnboxing(int i) {
    ArrayList aList = new ArrayList();
    aList.add(0, i);
    int a = aList.get(0);
    System.out.println("The value of i is " + a);
    }

　　看到了吧�Q�在J2SE(TM) 5.0中，我们不再需要显式的��d��一个值类型的数据转换成相应的对象�Q�从而把它作为对象传�l�其他方法，也不必手工的��那个代表一个数值的对象拆箱为相应的值类型数据，只要你提供的信息��_��让编译器��信�q�些装箱/拆箱后的�c�d��在��用时是合法的�Q�比方讲�Q�如果在上面的代码中�Q�如果我们��用的不是ArrayList而是ArrayList或者其他不兼容的版本如ArrayList�Q�会有编译错误�?/p>

　　当然�Q�你需要��够重视的是：一斚w��Q�对于值类型和引用�c�d��Q�在资源的占用上有相当大的区�?另一斚w��Q�装��和拆箱会带来额外的开销。在使用�q�一方便�Ҏ��的同时�Q�请不要忘记了背后隐藏的�q�些也许会媄响性能的因素�?/p>

　　1.7. �c�d��安全的枚�?/p>

　　在介�l�J2SE(TM) 5.0中引入的�c�d��安全枚�D的用法之前，我想先简单介�l�一下这一话题的背景�?/p>

　　我们知道�Q�在C中，我们可以定义枚�D�c�d��来��用别名代替一个集合中的不同元素，通常是用于描�q�那些可以归��Z��c�，而又具备有限数量的类别或者概念，如月份、颜艌Ӏ�扑克牌、太阳系的行星、五大洲、四大洋、季节、学�U�、四则运��符�Q�等�{�。它们通常看上��L��q�个样子�Q?/p>

　　typedef enum {SPRING, SUMMER, AUTUMN, WINTER} season;

　　实质上，�q�些别名被处理成int帔R��Q�比�?代表SPRING�Q?代表SUMMER�Q�以此类推。因��些别名最�l�就是int�Q�于是你可以对它们进行四则运��，�q�就造成了语意上的不明确�?/p>

　　Java一开始�ƈ没有考虑引入枚�D的概念，也许是出于保持Java语言��z�的考虑�Q�但是��用Java的广大开发者对于枚丄��需求�ƈ没有因�ؓJava本��n没有提供而消失，于是出现了一些常见的适用于Java的枚举设计模式，如int enum和typesafe enum�Q�还有不��开源的枚�DAPI和不开源的内部实现�?/p>

　　我大致说一下int enum模式和typesafe enum模式。所谓int enum模式��是模仿C中对enum的实玎ͼ�如：

    public class Season {
    public static final int SPRING = 0;
    public static final int SUMMER = 1;
    public static final int AUTUMN = 2;
    public static final int WINTER = 3;
    }
    �q�种模式跟C中的枚�D没有太多本质上的区别�Q�C枚�D的局限它基本上也有。而typesafe enum模式则要昑־�健壮得多�Q?
    public class Season {
    private final String name;
    private Season(String name) {
    this.name = name;
    }
    public String toString() {
    return name;
    }
    public static final Season SPRING = new Season("spring");
    public static final Season SUMMER = new Season("summer");
    public static final Season AUTUMN = new Season("autumn");
    public static final Season WINTER = new Season("winter");
    }

　　后一�U�实现首先通过�U�有的构造方法阻止了对该�cȝ��l�承和显式实例化�Q�因而我们只可能取得定义好的四种Season�c�d��Q��ƈ且提供了方便的toString()�Ҏ��获取有意义的说明�Q�而且�׃��q�是一个完全意义上的类�Q�所以我们可以很方便的加入自��q��Ҏ��和逻辑来自定义我们的枚丄��?/p>

　　最�l�，Java军_��拥抱枚�D�Q�在J2SE(TM) 5.0中，我们看到了这一变化�Q�它所采用的设计思�\基本上就是上面提到的typesafe enum模式。它的语法很��单，用一个实际的例子来说�Q�要定义一个枚举，我们可以�q�样写：

　　public enum Language {CHINESE, ENGLISH, FRENCH, HUNGARIAN}

　　接下来我们就可以通过Language.ENGLISH来��用了。呃…�q�个例子是不是有点太��儿�U�了�Q�我们来看一个复杂点的例子。��用Java的类型安全枚举，我们可以为所有枚丑օ�素定义公用的接口�Q�然后具体到每个元素本��n�Q�可以针对这些接口实��C��些特定的行�ؓ。这对于那些可以归�ؓ一�c�，又希望能通过�l�一的接口访问的不同操作�Q�将会相当方�ѝ��通常�Q��ؓ了实现类似的功能�Q�我们需要自己来�l�护一套��承关�p�L��者类似的枚�D模式。这里借用Java官方�|�站上的一个例子：

    public enum Operation {
    PLUS { double eval(double x, double y) { return x + y; } },
    MINUS { double eval(double x, double y) { return x - y; } },
    TIMES { double eval(double x, double y) { return x * y; } },
    DIVIDE { double eval(double x, double y) { return x / y; } };

    // Do arithmetic op represented by this constant
    abstract double eval(double x, double y);
    }
    在这个枚举中�Q�我们定义了四个元素�Q�分别对应加减乘除四则运��，对于每一�U�运��，我们都可以调用eval()�Ҏ��Q�而具体的�Ҏ��实现各异。我们可以通过下面的代码来试验上面�q�个枚�D�c�：
    public static void main(String args[]) {
    double x = Double.parseDouble(args[0]);
    double y = Double.parseDouble(args[1]);
    for (Operation op : Operation.values()) {
    System.out.println(x + " " + op + " " + y + " = " + op.eval(x, y));
    }
    }

　　怎么��P��使用枚�D�Q�我们是不是能够很方便的实现一些有��的功能?其实说穿了，Java的类型安全枚丑ְ�是包含了有限数量的已生成好的自��n实例的一�U�类�Q�这些现成的实例可以通过�cȝ��静态字�D�|��获取�?/p>

　　1.8. 可变长度参数

　　��֐�思义�Q�可变长度参数就是指在方法的参数体中�Q�只要定义恰当，我们可以使用��L��数量的参敎ͼ��c�M��于��用数�l�。在J2SE(TM) 5.0中，一个新的语法被引入�Q�就是在参数�c�d��名称后面加上"..."�Q�表�C��Ҏ��可以接受多个该类型的参数。需要说明的是可变长度参数必��L��在参数列表的最后，且一个方法只能包含一个这��L��参数。在�Ҏ��体内部，�q�样的参数被当作数组处理�Q�看上去代码应该�c�M��q�个样子�Q?/p>

    public String testVararg(String... args) {
    StringBuilder sb = new StringBuilder();
    for (String str : args) {
    sb.append(str);
    }
    return sb.toString();
    }

　　�q�样的方法签名跟你写成testVararg(String[] args)的区别在于：在调用时�Q�你不再需要传入一个包装好的String数组�Q�你只需要简单的写一�q�串String参数�Q�以逗号隔开卛_��Q�就如同�q�个�Ҏ��正好有一个重载的版本是接受那么多个String参数一栗��?/p>

　　1.9. 静态引�?/p>

　　所谓静态引入就是指除了引入�c�M��外，我们现在又多了一�U�选择�Q�引入某个类的静态字�D�c��如�Q?/p>

　　import static java.lang.Math.PI;

　　或�?/p>

　　import static java.lang.Math.*;

　　�q�样我们在接下来的代码中�Q�当我们需要��用某个被引入的静态字�D�|��Q�就不用再写上前面的�c�d��了。当�Ӟ��出现名字冲突�Ӟ��跟原来的�c�d��入一��P��q�是需要前�~�以示区分。我个�h认�ؓ�q�个新语�a�元素意义不大。当引入太多静态字�D�后�Q�代码会变得难以阅读和维护。由于静态字�D늚�名字通常不如�c�d��那么��h��描述性，我认为原先在静态字�D�前写上�c�d��才是更好的选择。不�q�，毕竟每个人的喜好和需求不同，如果你觉得它对你有用�Q�既然提供了�Q�那么就用咯�?/p>

　　1.10. 元数�?注解)

　　注解是J2SE(TM) 5.0引入的重要语�a�元素�Q�它所对应的JSR是JSR 175�Q�我们先来看看JSR 175的文��对注解的说明：

　　注解不会直接影响�E�序的语义，而开发和部��v工具则可以读取这些注解信息，�q�作相应处理�Q�如生成额外的Java源代码、XML文档、或者其他将与包含注解的�E�序一起��用的物�g�?/p>

　　在之前的J2SE版本中，我们已经使用��C��一部分早期的注解元素，如@deprecated�{�。这些元素通常被用于��?a target="_blank">HTML的Javadoc。在J2SE(TM) 5.0中，注解被正式引入，且推��C��Java历史上前所未有的高度�?/p>

　　现在�Q�注解不仅仅被用来��生Javadoc�Q�更重要的，注解使得代码的编译期��查更加有效和方便�Q�同时也增强了代码的描述能力。有一些注解是随着J2SE(TM) 5.0一起发布的�Q�我们可以直接��用。除此之外，我们也可以很方便的实现自定义的注解。在此基��上，很多以前我们只能靠反��机制来完成的功能也变得更加�Ҏ��实现�?/p>

　　我们来看现成的有哪些有用的注解：

　　首先是@Override�Q�这个注解被使用在方法上�Q�表明这个方法是从其父类�l�承下来的，�q�样的写法可以很方便的避免我们在重写�l�承下来的方法时�Q�不至于不小心写错了�Ҏ��{�֐��Q�且悄悄的溜�q�了�~�译器，造成隐蔽性相当高的bug�?/p>

　　其次是@Deprecated�Q�表明该��?�c�R��字�D�c��方�?不再被推荐��用�?/p>

　　�q�有一个@SuppressWarnings�Q�表明该��?�c�R��字�D�c��方�?所�늛�的范围不需要显�C�所有的警告信息。这个注解需要提供参敎ͼ�如unchecked�{�等�?/p>

　　下面我通过一个例子向大家说明�q�些现成的注解的用法�Q?/p>

    public class Main {
    @Deprecated
    public String str;
    public static void main(String[] args) {
    new SubMain().doSomething();
    }
    public void doSomething() {
    System.out.println("Done.");
    }
    }

    class SubMain extends Main {
    @Override
    @SuppressWarnings("unchecked", "warning")
    public void doSomething() {
    java.util.ArrayList aList = new java.util.ArrayList();
    aList.add(new Integer(0));
    System.out.println("Done by SubMain.");
    }
    }

　　当然�Q�我们也完全可以写自��q��注解。注解定义的语法是@interface关键字。J2SE(TM) 5.0支持三种形式的注解：不带参数的标记注解、带一个参数的注解和带多个参数的完整注解。下面分别�D例说明：

    标记注解�Q�类似@Deprecated�Q�如�Q?
    @interface SomeEmptyAnnotation {}
    单个参数的注解，如：
    @interface MySingleElementAnnotation {
    String value();
    }
    以及多个参数的注解，如：
    @interface MyAnnotationForMethods {
    int index();
    String info();
    String developer() default "Sean GAO";
    }

　　我们可以看到�Q�注解的定义跟interface的定义相当类��|��我们�q�可以指定默认倹{��对于这些注解，我们也可以�ؓ其添加注解，所�?#8220;注解的注�?#8221;。比方讲�Q�我们通常会��用@Target指定注解的作用对象，以及用@Retention指定注解信息写入的��别，如源代码、类文�g�{�等。�D个例子：

    @Target(ElementType.METHOD)
    @Retention(RetentionPolicy.SOURCE)
    public @interface SignedMethod {
    }
    在��用时�Q�我们需要在注解名称前面写上@�Q�然�?)中指定参数��|��如：
    @MyAnnotationForMethods (
    index = 1,
    info = "This is a method to test MyAnnotation.",
    developer = "Somebody else"
    )
    public void testMethod1() {
    // ...
    }

　　注解的最大作用在于它在源代码的基��上增加了有用的信息，使得源代码的描述性更强。这些信息可以被代码之外的工兯��别，从而可以很方便的增加外部功能，以及减少不必要的相关代码/文�g的维护。这里我想简单提一个超出J2SE(TM) 5.0范畴的话题：在未来的EJB 3.0规范中会有相当多的对注解的应用，让我们预览一下将来的无状态会话bean用注解来定义会是什么样子：

    @Stateless public class BookShelfManagerBean {
    public void addBook(Book aBook) {
    // business logic goes here...
    }
    public Collection getAllBooks() {
    // business logic goes here...
    }
    // ...
    }

　　我们甚至不用写�Q何接口和部��v描述�W�，�q�些工作��完全由外部工具通过��d��注解加上反射来完成，�q�不是很好吗?

　　1.11. C风格格式化输�?/p>

　　Java�ȝ��也有�c�M��C的printf()风格的方法了�Q�方法名同样叫作printf()�Q�这一�Ҏ��依赖于前边提到的可变长度参数。�D个例子来��_��我们现在可以写：

　　System.out.printf("%s has a value of %d.%n", someString, a);

　　怎么��P��看上去还不错�?需要注意的是Java��Z��支持多��^収ͼ�新增�?n标示�W�，作�ؓ对\n的补充。有关Java格式化输出的具体语法�Q�请参考java.util.Formatter的API文��?/p>

　　1.12. �l�语

　　在这一��介�l�性的文章中，我们一起领略了J2SE 5.0带来的新的语�a�元素�Q�不知道大家是否也跟�W�者一��P��感受��C��q�些新特性在提高我们的开发效率上所作的巨大努力。其实不只是语言元素�Q�J2SE(TM) 5.0的发布在其他很多斚w��都作了不��的改进�Q�包括虚拟机、新的API�c�d��{�等�Q�性能和功能上都有大幅提升�?/p>

　　对于主要靠J2EE吃饭的朋友来�Ԍ��也许真正意义上要在工作中充分利用�q�些新的元素�Q�恐怕要�{�主��的J2EE服务�?/a>都支持J2EE(TM) 5.0的那一天了�Q�对此我充满期待�?br />

redcoatjk 2010-05-16 15:35 发表评论

java中的double相加的怪事

redcoatjk — Sun, 07 Mar 2010 09:23:00 GMT

摘自:http://www.tkk7.com/ghyghost/archive/2008/06/16/208309.html
标题在Java中实现��Q�Ҏ��的精��计��? AYellow�Q�原作）修改
关键�? Java ��点�? �_��计算

问题的提出：
�~�译�q�行下面�q�个�E�序会看��C��么？
public class Test{
public static void main(String args[]){
System.out.println(0.05+0.01);
System.out.println(1.0-0.42);
System.out.println(4.015*100);
System.out.println(123.3/100);
}
};

你没有看错！�l�果��实�?
0.060000000000000005
0.5800000000000001
401.49999999999994
1.2329999999999999

Java中的��单��Q�Ҏ��c�d��float和double不能够进行运��。不光是Java�Q�在其它很多�~�程语言中也有这��L��问题。在大多数情况下�Q�计��的�l�果是准��的�Q�但是多试几�ơ（可以做一个��@环）��可以试出类��g��面的错误。现在终于理解�ؓ什么要有BCD码了�?
�q�个问题相当严重�Q�如果你�?.999999999999元，你的计算机是不会认�ؓ你可以购�?0元的商品的�?
在有的编�E�语�a�中提供了专门的货币类型来处理�q�种情况�Q�但是Java没有。现在让我们看看如何解决�q�个问题�?

四舍五入
我们的第一个反应是做四舍五入。Math�c�M��的round�Ҏ��不能讄��保留几位��数�Q�我们只能象�q�样�Q�保留两位）�Q?
public double round(double value){
return Math.round(value*100)/100.0;
}

非常不幸�Q�上面的代码�q�不能正常工作，�l�这个方法传�?.015它将�q�回4.01而不�?.02�Q�如我们在上面看到的
4.015*100=401.49999999999994
因此如果我们要做到精��的四舍五入�Q�不能利用简单类型做��M��q�算
java.text.DecimalFormat也不能解册��个问题：
System.out.println(new java.text.DecimalFormat("0.00").format(4.025));
输出�?.02

BigDecimal
在《Effective Java》这本书中也提到�q�个原则�Q�float和double只能用来做科学计��或者是工程计算�Q�在商业计算中我们要�? java.math.BigDecimal。BigDecimal一共有4个够造方法，我们不关心用BigInteger来够造的那两个，那么�q�有两个�Q? 它们是：
BigDecimal(double val)
Translates a double into a BigDecimal.
BigDecimal(String val)
Translates the String repre sentation of a BigDecimal into a BigDecimal.

上面的API��要描�q�相当的明确�Q�而且通常情况下，上面的那一个��用�v来要方便一些。我们可能想都不惛_��用上了，会有什么问题呢�Q�等到出了问题的时候，才发��C��面哪个够造方法的详细说明中有�q�么一�D�：
Note: the results of this constructor can be somewhat unpredictable. One might assume that new BigDecimal(.1) is exactly equal to .1, but it is actually equal to .1000000000000000055511151231257827021181583404541015625. This is so because .1 cannot be represented exactly as a double (or, for that matter, as a binary fraction of any finite length). Thus, the long value that is being passed in to the constructor is not exactly equal to .1, appearances nonwithstanding.
The (String) constructor, on the other hand, is perfectly predictable: new BigDecimal(".1") is exactly equal to .1, as one would expect. Therefore, it is generally recommended that the (String) constructor be used in preference to this one.

原来我们如果需要精��计��，非要用String来够造BigDecimal不可�Q�在《Effective Java》一书中的例子是用String来够造BigDecimal的，但是书上却没有强调这一点，�q�也许是一个小��的��p��吧�?

解决�Ҏ��
现在我们已经可以解决�q�个问题了，原则是��用BigDecimal�q�且一定要用String来够造�?
但是惛_��一下吧�Q�如果我们要做一个加法运��，需要先��两个��Q�Ҏ��转�ؓString�Q�然后够造成BigDecimal�Q�在其中一个上调用add�Ҏ��Q�传入另一个作为参敎ͼ�然后把运��的�l�果�Q�BigDecimal�Q�再转换为��Q�Ҏ��。你能够忍受�q�么烦琐的过�E�吗�Q�下面我们提供一个工��L��Arith来简化操作。它提供以下静态方法，包括加减乘除和四舍五入：
public static double add(double v1,double v2)
public static double sub(double v1,double v2)
public static double mul(double v1,double v2)
public static double div(double v1,double v2)
public static double div(double v1,double v2,int scale)
public static double round(double v,int scale)

附录

源文件Arith.java�Q?

import java.math.BigDecimal;
/**
* �׃��Java的简单类型不能够�_��的对��点数进行运��，�q�个工具�c�L��供精
* ��的��点数运��，包括加减乘除和四舍五入�?
*/

public class Arith{

//默认除法�q�算�_�ֺ�
private static final int DEF_DIV_SCALE = 10;

//�q�个�c�M��能实例化
private Arith(){
}

/**
* 提供�_��的加法运��?
* @param v1 被加�?
* @param v2 加数
* @return 两个参数的和
*/

public static double add(double v1,double v2){
BigDecimal b1 = new BigDecimal(Double.toString(v1));
BigDecimal b2 = new BigDecimal(Double.toString(v2));
return b1.add(b2).doubleValue();
}

/**
* 提供�_��的减法运��?
* @param v1 被减�?
* @param v2 减数
* @return 两个参数的差
*/

public static double sub(double v1,double v2){
BigDecimal b1 = new BigDecimal(Double.toString(v1));
BigDecimal b2 = new BigDecimal(Double.toString(v2));
return b1.subtract(b2).doubleValue();
}

/**
* 提供�_��的乘法运��?
* @param v1 被乘�?
* @param v2 乘数
* @return 两个参数的积
*/

public static double mul(double v1,double v2){
BigDecimal b1 = new BigDecimal(Double.toString(v1));
BigDecimal b2 = new BigDecimal(Double.toString(v2));
return b1.multiply(b2).doubleValue();
}

/**
* 提供�Q�相对）�_��的除法运��，当发生除不尽的情冉|��Q�精��到
* ��数点以�?0位，以后的数字四舍五入�?
* @param v1 被除�?
* @param v2 除数
* @return 两个参数的商
*/

public static double div(double v1,double v2){
return div(v1,v2,DEF_DIV_SCALE);
}

/**
* 提供�Q�相对）�_��的除法运��。当发生除不��的情况�Ӟ��由scale参数�?
* 定精度，以后的数字四舍五入�?
* @param v1 被除�?
* @param v2 除数
* @param scale 表示表示需要精��到��数点以后几位�?
* @return 两个参数的商
*/

public static double div(double v1,double v2,int scale){
if(scale<0){
throw new IllegalArgumentException(
"The scale must be a positive integer or zero");
}
BigDecimal b1 = new BigDecimal(Double.toString(v1));
BigDecimal b2 = new BigDecimal(Double.toString(v2));
return b1.divide(b2,scale,BigDecimal.ROUND_HALF_UP).doubleValue();
}

/**
* 提供�_��的小��C��四舍五入处理�?
* @param v 需要四舍五入的数字
* @param scale ��数点后保留几位
* @return 四舍五入后的�l�果
*/

public static double round(double v,int scale){
if(scale<0){
throw new IllegalArgumentException(
"The scale must be a positive integer or zero");
}
BigDecimal b = new BigDecimal(Double.toString(v));
BigDecimal one = new BigDecimal("1");
return b.divide(one,scale,BigDecimal.ROUND_HALF_UP).doubleValue();
}
};

redcoatjk 2010-03-07 17:23 发表评论

redcoatjk — Wed, 20 May 2009 02:41:00 GMT

摘要: Java接口和Java抽象�c? 在没有好好地研习面向对象设计的设计模式之前，我对Java接口和Java抽象�cȝ��认识�q�是很模�p�，很不可理解�? 刚学Java语言�Ӟ��很隄��解�ؓ什么要有接口这个概念，虽说是可以实现所谓的多��承，可一个只有方法名�Q�没有方法体的东西，... 阅读全文

redcoatjk 2009-05-20 10:41 发表评论