亚洲区日韩精品中文字幕,在线精品自拍亚洲第一区,亚洲中文字幕无码mv

优化你的java代码性能

矛_��@ — Mon, 24 Aug 2009 13:40:00 GMT

一、避免在循环条�g中��用复杂表辑ּ�

在不做编译优化的情况下，在��@环中�Q��@环条件会被反复计��，如果不��用复杂表辑ּ��Q�而��循环条�g��g��变的话，�E�序��会�q�行的更快�?br />
例子�Q?br /> import java.util.Vector;
class CEL {
    void method (Vector vector) {
        for (int i = 0; i < vector.size (); i++)  // Violation
            ; // ...
    }
}

更正�Q?br /> class CEL_fixed {
    void method (Vector vector) {
        int size = vector.size ()
        for (int i = 0; i < size; i++)
            ; // ...
    }
}

二、�ؓ'Vectors' �?'Hashtables'定义初始大小

JVM为Vector扩充大小的时候需要重新创��Z��个更大的数组�Q�将原原先数�l�中的内容复制过来，最后，原先的数�l�再被回收。可见Vector定w��的扩大是一个颇�Ҏ��间的事�?br /> 通常�Q�默认的10个元素大��是不够的。你最好能准确的估计你所需要的最佛_��?br />
例子�Q?br /> import java.util.Vector;
public class DIC {
    public void addObjects (Object[] o) {
        // if length > 10, Vector needs to expand
        for (int i = 0; i< o.length;i++) {
            v.add(o);   // capacity before it can add more elements.
        }
    }
    public Vector v = new Vector();  // no initialCapacity.
}

更正�Q?br /> 自己讑֮�初始大小�?br />     public Vector v = new Vector(20);
    public Hashtable hash = new Hashtable(10);

参考资料：
Dov Bulka, "Java Performance and Scalability Volume 1: Server-Side Programming
Techniques" Addison Wesley, ISBN: 0-201-70429-3 pp.55 – 57

三、在finally块中关闭Stream

�E�序中��用到的资源应当被释放�Q�以避免资源泄漏。这最好在finally块中��d��。不��程序执行的�l�果如何�Q�finally块��L��会执行的�Q�以��保资源的正��关闭�?br />
例子�Q?br /> import java.io.*;
public class CS {
    public static void main (String args[]) {
        CS cs = new CS ();
        cs.method ();
    }
    public void method () {
        try {
            FileInputStream fis = new FileInputStream ("CS.java");
            int count = 0;
            while (fis.read () != -1)
                count++;
            System.out.println (count);
            fis.close ();
        } catch (FileNotFoundException e1) {
        } catch (IOException e2) {
        }
    }
}

更正�Q?br /> 在最后一个catch后添加一个finally�?br />
参考资料：
Peter Haggar: "Practical Java - Programming Language Guide".
Addison Wesley, 2000, pp.77-79

四、��?System.arraycopy ()'代替通过来��@环复制数�l?/font>

'System.arraycopy ()' 要比通过循环来复制数�l�快的多�?br />
例子�Q?br /> public class IRB
{
    void method () {
        int[] array1 = new int [100];
        for (int i = 0; i < array1.length; i++) {
            array1 [i] = i;
        }
        int[] array2 = new int [100];
        for (int i = 0; i < array2.length; i++) {
            array2 [i] = array1 [i];                 // Violation
        }
    }
}

更正�Q?br /> public class IRB
{
    void method () {
        int[] array1 = new int [100];
        for (int i = 0; i < array1.length; i++) {
            array1 [i] = i;
        }
        int[] array2 = new int [100];
        System.arraycopy(array1, 0, array2, 0, 100);
    }
}

参考资料：
http://www.cs.cmu.edu/~jch/java/speed.html

五、让讉K��实例内变量的getter/setter�Ҏ��变成”final”

��单的getter/setter�Ҏ��应该被置成final�Q�这会告诉编译器�Q�这个方法不会被重蝲�Q�所以，可以变成”inlined”

例子�Q?br /> class MAF {
    public void setSize (int size) {
         _size = size;
    }
    private int _size;
}

更正�Q?br /> class DAF_fixed {
    final public void setSize (int size) {
         _size = size;
    }
    private int _size;
}

参考资料：
Warren N. and Bishop P. (1999), "Java in Practice", p. 4-5
Addison-Wesley, ISBN 0-201-36065-9

六、避免不需要的instanceof操作

如果左边的对象的静态类型等于右边的�Q�instanceof表达式返回永�q��ؓtrue�?br />
例子�Q?nbsp;
public class UISO {
    public UISO () {}
}
class Dog extends UISO {
    void method (Dog dog, UISO u) {
        Dog d = dog;
        if (d instanceof UISO) // always true.
            System.out.println("Dog is a UISO");
        UISO uiso = u;
        if (uiso instanceof Object) // always true.
            System.out.println("uiso is an Object");
    }
}

更正�Q?nbsp;
删掉不需要的instanceof操作�?br />
class Dog extends UISO {
    void method () {
        Dog d;
        System.out.println ("Dog is an UISO");
        System.out.println ("UISO is an UISO");
    }
}

七、避免不需要的造型操作

所有的�c�都是直接或者间接��承自Object。同��P��所有的子类也都隐含�?#8220;�{�于”其父�c�R��那么，由子�c�造型至父�cȝ��操作��是不必要的了�?br /> 例子�Q?br /> class UNC {
    String _id = "UNC";
}
class Dog extends UNC {
    void method () {
        Dog dog = new Dog ();
        UNC animal = (UNC)dog;  // not necessary.
        Object o = (Object)dog;         // not necessary.
    }
}

更正�Q?nbsp;
class Dog extends UNC {
    void method () {
        Dog dog = new Dog();
        UNC animal = dog;
        Object o = dog;
    }
}

参考资料：
Nigel Warren, Philip Bishop: "Java in Practice - Design Styles and Idioms
for Effective Java".  Addison-Wesley, 1999. pp.22-23

八、如果只是查扑֍�个字�W�的话，用charAt()代替startsWith()

用一个字�W�作为参数调用startsWith()也会工作的很好，但从性能角度上来看，调用用String API无疑是错误的!

例子�Q?br /> public class PCTS {
    private void method(String s) {
        if (s.startsWith("a")) { // violation
            // ...
        }
    }
}

更正
��?startsWith()' 替换�?charAt()'.
public class PCTS {
    private void method(String s) {
        if ('a' == s.charAt(0)) {
            // ...
        }
    }
}

参考资料：
Dov Bulka, "Java Performance and Scalability Volume 1: Server-Side Programming
Techniques"  Addison Wesley, ISBN: 0-201-70429-3

九、��用移位操作来代替'a / b'操作

"/"是一个很“昂贵”的操作，使用�U�M��操作��会更快更有效�?br />
例子�Q?br /> public class SDIV {
    public static final int NUM = 16;
    public void calculate(int a) {
        int div = a / 4;            // should be replaced with "a >> 2".
        int div2 = a / 8;         // should be replaced with "a >> 3".
        int temp = a / 3;
    }
}

更正�Q?br /> public class SDIV {
    public static final int NUM = 16;
    public void calculate(int a) {
        int div = a >> 2;
        int div2 = a >> 3;
        int temp = a / 3;       // 不能转换成位�U�L��?br />     }
}

十、��用移位操作代�?a * b'

同上�?br /> [i]但我个�h认�ؓ�Q�除非是在一个非常大的��@环内�Q�性能非常重要�Q�而且你很清楚你自己在做什么，方可使用�q�种�Ҏ��。否则提高性能所带来的程序晚��L��的降低��是不合��的�?br />
例子�Q?br /> public class SMUL {
    public void calculate(int a) {
        int mul = a * 4;            // should be replaced with "a << 2".
        int mul2 = 8 * a;         // should be replaced with "a << 3".
        int temp = a * 3;
    }
}

更正�Q?br /> package OPT;
public class SMUL {
    public void calculate(int a) {
        int mul = a << 2;
        int mul2 = a << 3;
        int temp = a * 3;       // 不能转换
    }
}

十一、在字符串相加的时候，使用 ' ' 代替 " "�Q�如果该字符串只有一个字�W�的�?

例子�Q?br /> public class STR {
    public void method(String s) {
        String string = s + "d"  // violation.
        string = "abc" + "d"      // violation.
    }
}

更正�Q?br /> ��一个字�W�的字符串替换成' '
public class STR {
    public void method(String s) {
        String string = s + 'd'
        string = "abc" + 'd'
    }
}

十二、不要在循环中调用synchronized(同步)�Ҏ��

�Ҏ��的同步需要消耗相当大的资料，在一个��@环中调用它绝对不是一个好��L��?br />
例子�Q?br /> import java.util.Vector;
public class SYN {
    public synchronized void method (Object o) {
    }
    private void test () {
        for (int i = 0; i < vector.size(); i++) {
            method (vector.elementAt(i));    // violation
        }
    }
    private Vector vector = new Vector (5, 5);
}

更正�Q?br /> 不要在��@环体中调用同步方法，如果必须同步的话�Q�推荐以下方式：
import java.util.Vector;
public class SYN {
    public void method (Object o) {
    }
private void test () {
    synchronized{//在一个同步块中执行非同步�Ҏ��
            for (int i = 0; i < vector.size(); i++) {
                method (vector.elementAt(i));
            }
        }
    }
    private Vector vector = new Vector (5, 5);
}

十三、将try/catch块移出��@�?/font>

把try/catch块放入��@环体内，会极大的影响性能�Q�如果编译JIT被关闭或者你所使用的是一个不带JIT的JVM�Q�性能会将下降21%之多!

例子�Q?nbsp;
import java.io.FileInputStream;
public class TRY {
    void method (FileInputStream fis) {
        for (int i = 0; i < size; i++) {
            try {                                      // violation
                _sum += fis.read();
            } catch (Exception e) {}
        }
    }
    private int _sum;
}

更正�Q?nbsp;
��try/catch块移出��@�?nbsp;
    void method (FileInputStream fis) {
        try {
            for (int i = 0; i < size; i++) {
                _sum += fis.read();
            }
        } catch (Exception e) {}
    }

参考资料：
Peter Haggar: "Practical Java - Programming Language Guide".
Addison Wesley, 2000, pp.81 – 83

十四、对于boolean��|��避免不必要的�{�式判断

��一个boolean��g��一个true比较是一个恒�{�操�?直接�q�回该boolean变量的�?. �U�走对于boolean的不必要操作臛_��会带�?个好处：
1)代码执行的更�?(生成的字节码��了5个字�?�Q?br /> 2)代码也会更加�q�净 �?br />
例子�Q?br /> public class UEQ
{
    boolean method (String string) {
        return string.endsWith ("a") == true;   // Violation
    }
}

更正�Q?br /> class UEQ_fixed
{
    boolean method (String string) {
        return string.endsWith ("a");
    }
}

十五、对于常量字�W�串�Q�用'String' 代替 'StringBuffer'

帔R��字符串�ƈ不需要动态改变长度�?br /> 例子�Q?br /> public class USC {
    String method () {
        StringBuffer s = new StringBuffer ("Hello");
        String t = s + "World!";
        return t;
    }
}

更正�Q?br /> 把StringBuffer换成String�Q�如果确定这个String不会再变的话�Q�这��会减少�q�行开销提高性能�?br />

十六、用'StringTokenizer' 代替 'indexOf()' �?substring()'

字符串的分析在很多应用中都是常见的。��用indexOf()和substring()来分析字�W�串�Ҏ��D��StringIndexOutOfBoundsException。而��用StringTokenizer�c�L��分析字符串则会容易一些，效率也会高一些�?br />
例子�Q?br /> public class UST {
    void parseString(String string) {
        int index = 0;
        while ((index = string.indexOf(".", index)) != -1) {
            System.out.println (string.substring(index, string.length()));
        }
    }
}

参考资料：
Graig Larman, Rhett Guthrie: "Java 2 Performance and Idiom Guide"
Prentice Hall PTR, ISBN: 0-13-014260-3 pp. 282 – 283

十七、��用条件操作符替代"if (cond) return; else return;" �l�构

条�g操作�W�更加的��?br /> 例子�Q?br /> public class IF {
    public int method(boolean isDone) {
        if (isDone) {
            return 0;
        } else {
            return 10;
        }
    }
}

更正�Q?br /> public class IF {
    public int method(boolean isDone) {
        return (isDone ? 0 : 10);
    }
}

十八、��用条件操作符代替"if (cond) a = b; else a = c;" �l�构

例子�Q?br /> public class IFAS {
    void method(boolean isTrue) {
        if (isTrue) {
            _value = 0;
        } else {
            _value = 1;
        }
    }
    private int _value = 0;
}

更正�Q?br /> public class IFAS {
    void method(boolean isTrue) {
        _value = (isTrue ? 0 : 1);       // compact expression.
    }
    private int _value = 0;
}

十九、不要在循环体中实例化变�?/font>

在��@环体中实例化临时变量��会增加内存消�?br />
例子�Q?nbsp;
import java.util.Vector;
public class LOOP {
    void method (Vector v) {
        for (int i=0;i < v.size();i++) {
            Object o = new Object();
            o = v.elementAt(i);
        }
    }
}

更正�Q?nbsp;
在��@环体外定义变量，�q�反复��?nbsp;
import java.util.Vector;
public class LOOP {
    void method (Vector v) {
        Object o;
        for (int i=0;i             o = v.elementAt(i);
        }
    }
}

二十、确�?StringBuffer的容�?/font>

StringBuffer 的构造器会创��Z��个默认大��?通常�?6)的字�W�数�l�。在使用中，如果��出�q�个大小�Q�就会重新分配内存，创徏一个更大的数组�Q��ƈ��原先的数组复制�q�来�Q�再丢弃旧的数组。在大多数情况下�Q�你可以在创�?StringBuffer的时候指定大��，�q�样��避免了在容量不够的时候自动增长，以提高性能�?br />
例子�Q?nbsp;
public class RSBC {
    void method () {
        StringBuffer buffer = new StringBuffer(); // violation
        buffer.append ("hello");
    }
}

更正�Q?nbsp;
为StringBuffer提供寝大��?nbsp;
public class RSBC {
    void method () {
        StringBuffer buffer = new StringBuffer(MAX);
        buffer.append ("hello");
    }
    private final int MAX = 100;
}

参考资料：
Dov Bulka, "Java Performance and Scalability Volume 1: Server-Side Programming
Techniques" Addison Wesley, ISBN: 0-201-70429-3 p.30 – 31

二十一、尽可能的��用栈变量

如果一个变量需要经常访问，那么你就需要考虑�q�个变量的作用域了。static? local?�q�是实例变量�Q�访问静态变量和实例变量��会比访问局部变量多耗费2-3个时钟周期�?br />
例子�Q?br /> public class USV {
    void getSum (int[] values) {
        for (int i=0; i < value.length; i++) {
            _sum += value[i];           // violation.
        }
    }
    void getSum2 (int[] values) {
        for (int i=0; i < value.length; i++) {
            _staticSum += value[i];
        }
    }
    private int _sum;
    private static int _staticSum;
}

更正�Q?nbsp;
如果可能�Q�请使用局部变量作��Z��l�常讉K��的变量�?br /> 你可以按下面的方法来修改getSum()�Ҏ��Q?nbsp;
void getSum (int[] values) {
    int sum = _sum;  // temporary local variable.
    for (int i=0; i < value.length; i++) {
        sum += value[i];
    }
    _sum = sum;
}

参考资料：
Peter Haggar: "Practical Java - Programming Language Guide".
Addison Wesley, 2000, pp.122 – 125

二十二、不要��L��使用取反操作�W?!)

取反操作�W?!)降低�E�序的可��L��，所以不要��L��使用�?br />
例子�Q?br /> public class DUN {
    boolean method (boolean a, boolean b) {
        if (!a)
            return !a;
        else
            return !b;
    }
}

更正�Q?br /> 如果可能不要使用取反操作�W?!)

二十三、与一个接�?�q�行instanceof操作

��Z��接口的设计通常是�g好事�Q�因为它允许有不同的实现�Q�而又保持灉|��。只要可能，对一个对象进行instanceof操作�Q�以判断它是否某一接口要比是否某一个类要快�?br />
例子�Q?br /> public class INSOF {
    private void method (Object o) {
        if (o instanceof InterfaceBase) { }  // better
        if (o instanceof ClassBase) { }   // worse.
    }
}

class ClassBase {}
interface InterfaceBase {}

摘自�Q�http://www.51testing.com/?88979/spacelist-blog-page-2.html

矛_��@ 2009-08-24 21:40 发表评论

java内存泄漏

矛_��@ — Mon, 24 Aug 2009 13:39:00 GMT

解决Java内存泄漏

Java内存泄漏是每个Java�E�序员都会遇到的问题,�E�序在本地运行一切正�?可是布��v到远端就会出现内存无限制的增�?最后系�l�瘫�?那么如何最快最好的��程序的�E�_��?防止�pȝ��崩盘,作者用自已的亲�w�经历与各位分��n解决�q�些问题的办�?

�? 为Internet最��行的编�E�语�a�之一,Java现正非常��行.我们的网�l�应用程序就主要采用Java语言开�?大体上分为客��L��、服务器和数据库三个层次.在进入测试过�E�中,我们发现有一个程序模块系�l�内存和CPU资源消耗急剧增加,持箋增长到出�? java.lang.OutOfMemoryError为止.�l�过分析Java内存泄漏是破坏系�l�的主要因素.�q�里与大家分享我们在开发过�E�中遇到�? Java内存泄漏的检��和处理解决�q�程.

一. Java是如何管理内�?

��Z��判断Java中是否有内存泄露,我们首先必须了解Java是如何管理内存的.Java的内存管�? ��是对象的分配和释放问题.在Java�?内存的分配是��q��序完成的,而内存的释放是由垃圾攉��?Garbage Collection,GC)完成�?�E�序员不需要通过调用函数来释攑ֆ��?但它只能回收无用�q�且不再被其它对象引用的那些对象所占用的空�?

Java的内存垃圑֛�收机制是从程序的主要�q�行对象开始检查引用链,当遍历一遍后发现没有被引用的�? 立对象就作�ؓ垃圾回收.GC��Z��能够正确释放对象,必须监控每一个对象的�q�行状�?包括对象的申诗��引用、被引用、赋值等,GC都需要进行监�?监视对象状态是��Z��更加准确地、及时地释放对象,而释攑֯�象的�Ҏ��原则��是该对象不再被引用.

在Java�?�q�些无用的对象都由GC负责回收,因此�E�序员不需要考虑�q�部分的内存泄露.虽然,我们有几个函数可以访问GC,例如�q�行GC的函数System.gc(),但是�Ҏ��Java语言规范定义,该函��C��保证JVM的垃圾收集器一定会执行.因�ؓ�? 同的JVM实现者可能��用不同的��法��理GC.通常GC的线�E�的优先�U�别较低.JVM调用GC的策略也有很多种,有的是内存��用到达一定程度时,GC才开始工�?也有定时执行�?有的是��^�~�执行GC,有的是中断式执行GC.但通常来说,我们不需要关心这�?

�? 什么是Java中的内存泄露

��D��内存泄漏主要的原因是,先前甌��了内存空间而忘��C��释放.如果�E�序中存在对无用对象的引�?那么 �q�些对象��׃��ȝ��内存,消耗内�?因�ؓ无法让垃圑֛�收器GC验证�q�些对象是否不再需�?如果存在对象的引�?�q�个对象��p��定义�?有效的活�?,同时不会被释�?要确定对象所占内存将被回�?我们��p��务必��认该对象不再会被��?典型的做法就是把对象数据成员设�ؓnull或者从集合中移除该对象.但当局�? 变量不需要时,不需明显的设为null,因�ؓ一个方法执行完毕时,�q�些引用会自动被清理.

在Java�?内存泄漏��是存在一些被分配的对�?�q�些对象有下面两个特�?首先,�q�些对象是有被引用的,卛_��有向树�Ş图中,存在树枝通�\可以与其相连�Q�其��?�q�些对象是无用的,即程序以后不会再使用�q�些对象.如果对象满��q�两个条�?�q�些对象��可以判定�ؓJava中的内存泄漏,�q�些对象不会被GC所回收,然而它却占用内�?

�q�里引用一个常看到的例�?在下面的代码�?循环甌��Object对象,�q�将所甌��的对象放入一�? Vector�?如果仅仅释放对象本��n,但因为Vector仍然引用该对�?所以这个对象对GC来说是不可回收的.因此,如果对象加入到Vector�? �q�必��M��Vector中删�?最��单的�Ҏ��是��Vector对象讄��为null.实际上这些对象已�l�是无用�?但还被引�?GC��无能�ؓ力了(事实�? GC认�ؓ它还有用),�q�一�Ҏ��D��内存泄漏最重要的原�? 再引用另一个例子来说明Java的内存泄�?假设有一个日志类Logger,其提供一个静态的log(String msg),��M��其它�c�都可以调用Logger.Log(message)来将message的内容记录到�pȝ��的日志文件中.

Logger�c�L��一个类型�ؓHashMap的静态变量temp,每次在执行log(message) 的时�?都首先将message的值写入temp�?以当前线�E?当前旉��为键),在退��Z��前再从temp中将以当前线�E�和当前旉��为键的条目删�?�? �?�q�里当前旉��是不断变化的,所以log在退��Z��前执行删除条目的操作�q�不能删除执行之初写入的条目.�q�样,��M��一个作为参��C��l�log的字�W�串最�l�由于被Logger的静态变量temp引用,而无法得到回�?�q�种对象保持��是我们所说的Java内存泄漏. �ȝ��来说,内存��理中的内存泄漏产生的主要原因：保留下来却永�q�不再��用的对象引用.

�? 几种典型的内存泄�?

我们知道了在Java中确实会存在内存泄漏,那么��p��我们看一看几�U�典型的泄漏,�q�找��Z��们发生的原因和解��x��?

3.1 全局集合

在大型应用程序中存在各种各样的全局数据仓库是很普遍�?比如一个JNDI-tree或者一个session table.在这些情况下,必须注意��理储存库的大小.必须有某�U�机制从储存库中�U�除不再需要的数据.

通常有很多不同的解决形式,其中最常用的是一�U�周期运行的清除作业.�q�个作业会验证仓库中的数据然�? 清除一切不需要的数据.另一�U�管理储存库的方法是使用反向链接(referrer)计数.然后集合负责�l�计集合中每个入口的反向链接的数�?�q�要求反向链接告诉集合何时会退出入�?当反向链接数目�ؓ零时,该元素就可以从集合中�U�除�?

3.2 �~�存
�~�存一�U�用来快速查扑ַ��l�执行过的操作结果的数据�l�构.因此,如果一个操作执行需要比较多的资源�ƈ会多�ơ被使用,通常做法是把常用的输入数据的操作�l�果�q�行�~�存,以便在下�ơ调用该操作时��用缓存的数据.�~�存通常都是以动态方式实�? �?如果�~�存讄��不正��而大量��用缓存的话则会出现内存溢出的后果,因此需要将所使用的内存容量与��索数据的速度加以�q��.

常用的解决途径是��用java.lang.ref.SoftReference�c�d��持将对象攑օ��~�存.�q�个�Ҏ��可以保证当虚拟机用完内存或者需要更多堆的时�?可以释放�q�些对象的引�?

3.3 �c�装载器
Java�c�装载器的��用�ؓ内存泄漏提供了许多可乘之�?一般来说类装蝲�? 都具有复杂结�?因�ؓ�c�装载器不仅仅是只与"常规"对象引用有关,同时也和对象内部的引用有�?比如数据变量,�Ҏ��和各�U�类.�q�意味着只要存在�Ҏ��据变 �?�Ҏ��,各种�c�d��对象的类装蝲�?那么�c�装载器��驻留在JVM�?既然�c�装载器可以同很多的�c�d��?同时也可以和静态数据变量关�?那么相当多的内存��? 可能发生泄漏.

�? 如何��和处理内存泄漏

如何查找引�v内存泄漏的原因一般有两个步骤:�W�一是安排有�l�验的编�E��h员对代码�q�行走查和分�?扑և�内存泄漏发生的位�|?�W�二是��用专门的内存泄漏��试工具�q�行��试.

�W�一个步�?在代码走查的工作�?可以安排对系�l�业务和开发语�a�工具比较熟悉的开发�h员对应用的代码进行了交叉走查,��量扑և�代码中存在的数据库连接声明和�l�果集未关闭、代码冗余等故障代码.

�W�二个步�?��是��Java的内存泄�?在这里我们通常使用一些工��h��查Java�E�序的内存泄�? 问题.市场上已有几�U�专业检查Java内存泄漏的工�?它们的基本工作原理大同小�?都是通过监测Java�E�序�q�行�?所有对象的甌��、释攄��动作,��内存管理的所有信息进行统计、分析、可视化.开发�h员将�Ҏ��q�些信息判断�E�序是否有内存泄漏问�?�q�些工具包括Optimizeit Profiler,JProbe Profiler,JinSight , Rational 公司的Purify�{?

4.1��内存泄漏的存在
�q�里我们��简单介�l�我们在使用Optimizeit��查的�q�程.通常在知道发生内存泄漏之�?�W�一步是要弄清楚泄漏了什么数据和哪个�cȝ��对象引�v了泄�?

一般说�?一个正常的�pȝ��在其�q�行�E�_��后其内存的占用量是基本稳定的,不应该是无限制的增长�?�? �?对�Q何一个类的对象的使用个数也有一个相对稳定的上限,不应该是持箋增长�?�Ҏ��q�样的基本假�?我们持箋地观察系�l�运行时使用的内存的大小和各实例的个�?如果内存的大��持�l�地增长,则说明系�l�存在内存泄�?如果特定�cȝ��实例对象个数随时间而增�?��是所谓的“增长�?#8221;),则说明这个类的实例可能存在泄漏情�?

另一斚w��通常发生内存泄漏的第一个迹象是�Q�在应用�E�序中出��C��OutOfMemoryError.�? �q�种情况�?需要��用一些开销较低的工��h��监控和查扑ֆ�存泄�?虽然OutOfMemoryError也有可能应用�E�序��实正在使用�q�么多的内存�Q�对于这 �U�情况则可以增加JVM可用的堆的数�?或者对应用�E�序�q�行某种更改,使它使用较少的内�?

但是,在许多情况下,OutOfMemoryError都是内存泄漏的信�?一�U�查明方法是不间断地监控GC的活�?��定内存使用量是否随着旉��增加.如果��实如此,��可能发生了内存泄漏.

4.2处理内存泄漏的方�?
一旦知道确实发生了内存泄漏,��需要更专业的工��h��查明��Z��么会发生泄漏.JVM自己是不会告诉您�?�q�些专业工具从JVM获得内存�pȝ��信息的方法基本上有两�U�：JVMTI和字节码技�?byte code instrumentation).Java虚拟机工��h��?Java Virtual Machine Tools Interface,JVMTI)及其前��nJava虚拟机监视程序接�?Java Virtual Machine Profiling Interface,JVMPI)是外部工具与JVM通信�q�从JVM攉��信息的标准化接口.字节码技术是指��用探��器处理字节码以获得工具所需的信息的技 �?

Optimizeit是Borland公司的��?主要用于协助对��Y件系�l�进行代码优化和故障诊断,其中的Optimizeit Profiler主要用于内存泄漏的分�?Profiler的堆视图��是用来观察�pȝ��q�行使用的内存大��和各个�cȝ��实例分配的个数的.

首先,Profiler会进行趋势分�?扑և�是哪个类的对象在泄漏.�pȝ��q�行长时间后可以得到四个�? 存快�?对这四个内存快照�q�行�l�合分析,如果每一�ơ快照的内存使用都比上一�ơ有增长,可以认定�pȝ��存在内存泄漏,扑և�在四个快照中实例个数都保持增长的 �c?�q�些�c�d��以初步被认定为存在泄�?通过数据攉��和初步分�?可以得出初步�l�论:�pȝ��是否存在内存泄漏和哪些对象存在泄�?被泄�?.

接下�?看看有哪些其他的�c�M��泄漏的类的对象相兌��.前面已经谈到Java中的内存泄漏��是无用的对象保�?��单地说就是因为编码的错误��D��了一条本来不应该存在的引用链的存�?从而导致了被引用的对象无法释放),因此内存泄漏分析的�Q务就是找��条多余的引用�?�q�找到其形成的原�?查看对象分配到哪里是很有用的.同时只知道它们如何与其他对象相关�?卛_��些对象引用了它们)是不够的,关于它们在何�? 创徏的信息也很有�?

最�?�q�一步研�I�单个对�?看看它们是如何互相关联的.借助于Profiler工具,应用�E�序中的代码可以在分配时�q�行动态添�?以创建堆栈跟�t?也有可以对系�l�中所有对象分配进行动态的堆栈跟踪.�q�些堆栈跟踪可以在工具中�q�行累积和分�?�Ҏ��个被泄漏的实例对 �?必然存在一条从某个牵引对象出发到达该对象的引用�?处于堆栈�I�间的牵引对象在被从栈中弹出后就失去其牵引的能力,变�ؓ非牵引对�?因此,在长旉��? �q�行�?被泄露的对象基本上都是被作�ؓ�cȝ��静态变量的牵引对象牵引.

总而言�? Java虽然有自动回收管理内存的功能,但内存泄漏也是不容忽�?它往往是破坏系�l�稳定性的重要因素.

摘自�Q�http://www.51testing.com/?88979/spacelist-blog-page-2.html

矛_��@ 2009-08-24 21:39 发表评论

矛_��@ — Sat, 22 Aug 2009 08:53:00 GMT

　
安装jdk��会生成如下3个项目：
HKEY_LOCAL_MACHINE\SOFTWARE\JavaSoft\Java Development Kit
HKEY_LOCAL_MACHINE\SOFTWARE\JavaSoft\Java Plug-in
HKEY_LOCAL_MACHINE\SOFTWARE\JavaSoft\Java Runtime Environment
同时�Q�Java2 SDK安装�E�序��会把java.exe�Q�javaw.exe�Q�javareg.exe�q?�?zmkey class="zoomino-searchword">可执行文�?/zmkey>拯��到winnt\system32目录下，�׃��winnt\system32被操作系�l�缺省的讄��为最高优先权的PATH搜烦路径�Q�因此可保证用户在命令行��M��目录下可�q�行java.exe来启动JVM�?
那么java.exe在启动时如何��定其JRE所在的目录以及需要动�?zmkey class="zoomino-searchword">加蝲的链接库呢？java.exe是通过下面方式来确定的�Q?
假如存在../jre/bin/java.dll文�g�Q�则查找../jre/lib/ jvm.cfg文�g�Q�在该文件中�Q�第1个被列出的jvm.dll�c�d��作�ؓ�~�省��|��假如在java.exe命��o行指定了jvm.dll的类型，则��用指定类型）。jvm.dll�c�d��分�ؓhotspot�Q�classic�Q�server三种。假如不存在../jre/lib/jvm.cfg文�g�Q�则打印下面的错误信息：
Error: could not open 'c:\jdk1.3\jre\lib\jvm.cfg'
如不�? �?./jre/bin/java.dll�Q�当�q�行的是winnt\system32\java.exe�Q�，则注册表��在此时发挥�? 用，HKEY_LOCAL_MACHINE\SOFTWARE\JavaSoft\Java Runtime Environment\ CurrentVersion键值所记录的实际上是winnt\system32\java.exe的版本��|��该版本值只保存丅R��次两个版本��P��? 1.2�Q?.3�{��?
同时java.exe�E�序内部本��n也有一个标识自�w�的版本��|��?.2�?.3�{�。java.exe�Ҏ��自己内部的版本值和CurrentVersion值相比较�Q�假如发��C��个值相�{�，则将在HKEY_LOCAL_MACHINE\SOFTWARE\JavaSoft \Java Runtime Environment\MainVersion.MicroVersion��下获取JRE所在目录及动态链接库�Q�这两个键的名称分别是JavaHome和RuntimeLib�Q�MainVersion表示�ȝ��本号�Q�MicroVersion表示�ơ版本号�?
假如java.exe内部版本值和CurrentVersion不一��_��则报�c�M��以下的错误：
Registry key 'Software\JavaSoft\Java Runtime Environment\CurrentVersion'
has value '1.2', but '1.3' is required.
意思是��_��注册表当前所记蝲的winnt\system32\java.exe版本�?.2�Q�但是此时运行的java.exe版本�?.3�? java.exe抱怨除非注册表�?.3版的记蝲�Q�否则自己无法正��定位JRE目录和jvm.dll�Q�因此提�C?.3是需要的�?
�q�里�Q�我们不能简单的修改注册表的CurrentVersion值来辑ֈ��q�个目的。一般地�Q�当在系�l�中装了两套版本的Java2 SDK�Q�如先装1.2而后又装�?.3�Q�，后面安装的Java2 SDK会将自己带的java.exe和javaw.exe拯��到winnt\system32目录下，从而覆盖先前版本的java.exe�? javaw.exe�Q��ƈ且在注册表中改写CurrentVersion�?.3。所以徏议在安装Java2 SDK前，先卸载以前安装的版本。假如�h为的修改CurrentVersion�Q�会使得不同版本的java.exe加蝲与己版本不符的java.dll�? jvm.dll�Q�将引�v难以预料的后果！
非凡情况�Q?
JBuilder自己带一套JDK�Q�在JBuilder安装完成后，JBuilder安装�E�序会修改CurrentVersion��己所带JDK的版本，但不会覆盖winnt\system32下的java.exe和javaw.exe�?
WebLogic自己带一套JDK�Q�在WebLogic安装完成后，WebLogic安装�E�序不会修改注册表，也不会覆盖winnt\system32下的java.exe和javaw.exe�?
Oracle自己带一套JDK�Q�一般是比较低版本的�Q�例�?.1.7仅仅带JDK 1.1.7�Q�，在Oracle安装完成后，Oracle安装�E�序不会修改注册表，也不会覆盖winnt\system32下的java.exe�? javaw.exe。但是，Oralce安装�E�序会修改系�l�PATH变量�Q�将自带的JRE的bin路径加入其中�Q�且�|�于最前面。随着Oracle安装版本的不同，其自带JRE的JVM启动�E�序也不同。在�W�者机器上安装的Oracle 8.1.7�Q�其JRE��p��在C:\Program Files\Oracle下，�q�将C:\Program Files\Oracle\jre\1.1.7\bin攑֜�PATH变量最前，其JVM启动�E�序是jre.exe而非java.exe�?
以上��是Java2 SDK在Windows下安装时所做的动作�Q�这样会带来兼容性问题：
问题背景�Q�安装Java2 SDK后，安装了JBuilder6�Q�未修改��M��PATH变量
问题1
当在操作�pȝ��中安装了JDK 1.2�Q�其后安装了JBuilder6�Q�自带JDK 1.3.1�Q�，�q�时CurrentVersion�?.3�Q�在命��o行执行java -version�Ӟ��提示�Q?
Registry key 'Software\JavaSoft\Java Runtime Environment\CurrentVersion'
has value '1.3', but '1.2' is required.
解决�Ҏ��Q�将JDK 1.2中java.exe所在�\径加入到操作�pȝ��PATH的首位，从而保证在命��o行调用java时��L��执行JDK 1.2中的java.exe�Q�以使得java.exe可正��定位JRE和jvm.dll�?
问题2
当在操作�pȝ��中安装了JDK 1.3.0�Q�而后安装了JBuilder6�Q�自带JDK 1.3.1�Q�，�q�时CurrentVersion�?.3�Q�但是此1.3是指向的是JBuilder6自带的JDK 1.3.1的JRE�Q�而非指向先前JDK 1.3.0的JRE�Q�当在命令行执行java -version�Ӟ��此时执行的是JDK 1.3.0拯��到winnt\system32的一个java.exe副本�Q�但打印的版本信息却是：
java version "1.3.1"
Java(TM) 2 Runtime Environment, Standard Edition (build 1.3.1-b24)
Java HotSpot(TM) Client VM (build 1.3.1-b24, mixed mode)
��D��该问题的原因是java.exe只维护小数点�?位的版本��P��而非2位�?
解决�Ҏ��Q�同问题1
问题3�Q?
假如在操作系�l�中先安装了JDK 1.3.0�Q�而后安装了带有与安装JDK��L��版本相同的JBuilder6�Q�带JDK 1.3.1�Q�前两位相同�Q�，则问�?实际上被隐蔽了，没有发生的机会；而问�?的隐蔽性也很强�Q�不��L��发觉�Q�因��Z�h们往往会忽略JDK的第3个版本号�?
如问�?所叙，在命令行执行java�Q�虽然是使用JDK 1.3.0的一个java.exe副本�Q�winnt\system32目录下）�Q�而实际上却是使用JBuilder6下JDK 1.3.1的JRE及其目录�l�构�Q�其�l�果是当我们使用Java2的extension mechanism��jar文�g攑ֈ�JDK 1.3.0的jre\lib\ext目录下时�Q�发现达不到希望的效�?– 在命令行用java启动�E�序�Ӟ��不会自动去JDK 1.3.0的jre\lib\ext目录下去搜烦jar文�g�Q�它只会去JBuilder6下JDK 1.3.1的jre\lib\ext��L��索jar文�g�Q�而JBuilder6下的JDK 1.3.1�q�不存在jre\lib\ext�q�么一个目录！
问题3极�ؓ隐蔽�Q�除非完全对Java2 SDK的安装及class定位机制了解�Q�一般的开发者是难以发现问题所在的。有关Java2中class定位机制�Q�见�?zmkey class="zoomino-searchword">Java2中的class定位机制》一文�?
事实上，即��仅仅在系�l�中存在一份JDK 1.3.0�Q�假如在命��o行运行java的话�Q��用的JRE目录是C:\Program Files\JavaSoft\JRE\1.3�Q�也��是��_��即��我们在c:\jdk1.3\jre\lib\ext下放�|�我们的extension jar�Q�也得不到预期的�l�果。正��的做法是放在C:\Program Files\JavaSoft\JRE\1.3\lib\ext目录下�?
解决�Ҏ��Q�同问题1
�l�g��所叙，强烈��?JDK_HOME%\bin目录攑֜�Windows操作�pȝ��的PATH变量的首位，以避免潜在的问题�?
而在UNIX下，则完全不存在�c�M��Windows操作�pȝ��上的问题�?
我们在命令下执行的java�?bin/java
$which java
$/bin/java
�?bin是到/usr/bin的链接，也就是说/bin/java实际上是/usr/bin/java
�?usr/bin/java实际上链接到/usr/java/bin/java�Q?usr/java是到/usr/java1.2的链接（Solaris 7或更高系�l�内�|�JDK 1.2�Q�，所以我们实际上执行的java�?
/usr/java1.2/bin/java
�Ҏ��UNIX上的情况�Q�java在运行时实际上��L��可以�?./jre/lib/sparc/libjava.so�?./jre/lib/sparc /libjvm.so来找到这2个文�Ӟ��前者类��g��Windows下的java.dll�Q�而后者类��g��Windows下的jvm.dll。所以java�? ��L��可以��定自己JRE的目录�?
Windows和UNIX上用到的动态链接库�Q�实际上在Sun的文档中�U�Cؓoptional package's native code binaries�Q�optional pakage实际上即为extension mechanism classes�Q�详见《Java2中的class定位机制》�?
要更改UNIX上java的版本，更改/usr/java的链接是其中一个方法，具体可参见JDK在UNIX上的安装介绍�?
补充�Q�（2002-12-23�Q?
Windows如何定位Plug-in
�Ҏ��在PATH环境变量�? 扑ֈ�的java.exe的版本号�Q�到HKEY_LOCAL_MACHINE\SOFTWARE\JavaSoft\Java Plug-in下寻扑֯�应版本的Java Plug-in�Q�在HKEY_LOCAL_MACHINE\SOFTWARE\JavaSoft\Java Plug-in下可以有多个版本的Plug-in存在�?
不依靠HKEY_LOCAL_MACHINE\SOFTWARE \JavaSoft\Java Development Kit的CurrentVersion值和HKEY_LOCAL_MACHINE\SOFTWARE\JavaSoft\Java Runtime Environment的CurrentVersion值来定位应该使用哪个版本的Java Plug-in�?br />

矛_��@ 2009-08-22 16:53 发表评论

矛_��@ — Sat, 22 Aug 2009 01:52:00 GMT

(一) Java应用�E�序的开发周期包括编译、下载、解释和执行几个部分。Java�~�译�E�序��? Java源程序翻译�ؓJVM可执行代�?-字节码。这一�~�译�q�程同C/C++的编译有些不同。当C�~�译器编译生成一个对象的代码�Ӟ��该代码是为在某一特定 ��g�q�_��q�行而��生的。因此，在编译过�E�中�Q�编译程序通过查表��所有对�W�号的引用�{换�ؓ特定的内存偏�U�量�Q�以保证�E�序�q�行。Java�~�译器却不将对变量和 �Ҏ��的引用编译�ؓ数值引用，也不��定�E�序执行�q�程中的内存布局�Q�而是��这些符号引用信息保留在字节码中�Q�由解释器在�q�行�q�程中创立内存布局�Q�然后再通过�? 表来��定一个方法所在的地址。这样就有效的保证了Java的可�U�L��性和安全性�?/p>

�q�行JVM字节码的工作是由解释�? java命��o )来完成的。解释执行过�E�分三部�q�行�Q�代码的装入、代码的校验和代码的执行。装入代码的工作�?�c�装载器"�Q�class loader�Q�完成。类装蝲器负责装入运行一个程序需要的所有代码，�q�也包括�E�序代码中的�c�L��l�承的类和被其调用的�c�R��当�c�装载器装入一个类�Ӟ��该类被放在自��q��名字�I�间中。除了通过�W�号引用自己名字�I�间以外的类�Q�类之间没有其他办法可以影响其他�c�R��在本台计算��Z��的所有类都在同一地址�I�间内，而所有从�? 部引�q�的�c�，都有一个自��q��立的名字�I�间。这使得本地�c�通过�׃�n相同的名字空间获得较高的�q�行效率�Q�同时又保证它们与从外部引进的类不会�怺�影响。当装入了运行程序需要的所有类后，解释器便可确定整个可执行�E�序的内存布局。解释器为符号引用同特定的地址�I�间建立对应关系及查询表。通过在这一阶段��定代码�? 内存布局�Q�Java很好地解决了��p��c�L��变而��子类崩溃的问题，同时也防止了代码对地址的非法访问�?/p>

随后�Q�被装入的代码由字节码校验器�q�行��查。校验器可发现操作数栈溢出，非法数据�c�d��转化�{�多�U�错误。通过校验后，代码便开始执行了�?/p>

Java字节码的执行有两�U�方式：

1.��x��~�译方式�Q�解释器先将字节码编译成机器码，然后再执行该机器码�?/p>

2.解释执行方式�Q�解释器通过每次解释�q�执行一��段代码来完成Java字节码程序的所有操作�?/p>

通常采用的是�W�二�U�方法。由于JVM规格描述��h��_��的灵�z�L��，�q��得将字节码翻译�ؓ机器代码的工�?/p>

��h��较高的效率。对于那些对�q�行速度要求较高的应用程序，解释器可��Java字节码即时编译�ؓ机器码，从而很好地保证了Java代码的可�U�L��性和高性能�?/p>

�Q�二�Q�JVM规格描述
JVM的设计目标是提供一个基于抽象规格描�q�的计算机模型，��释程序开发�h员提很好的灵�z�L��，同时也确保Java代码可在�W�合该规范的��M��pȝ��上运行。JVM对其实现的某些方面给��Z��具体的定义，特别是对Java可执行代�?/zmkey>�Q�即字节�?Bytecode)的格式给��Z��明确的规根{��这一规格包括操作�?/zmkey>和操作数的语法和数倹{��标识符的数��D��C�方式、以及Java�c�L��件中的Java对象、常量缓冲池在JVM的存储映象。这些定义�ؓJVM解释器开发�h员提供了所需的信息和开发环境。Java的设计者希望给开发�h员以随心所�Ʋ��用Java的自由�?br /> JVM定义了控制Java代码解释执行和具体实现的五种规格�Q�它们是�Q?br /> JVM指��o�pȝ��
JVM寄存�?br /> JVM栈结�?br /> JVM��片回收�?br /> JVM存储�?br /> 2.1JVM指��o�pȝ��
JVM指��o�pȝ��同其他计��机的指令系�l�极其相伹{��Java指��o也是�? 操作码和操作��C��部分�l�成。操作码�?位二�q�制敎ͼ�操作数进紧随在操作码的后面，光��度根据需要而不同。操作码用于指定一条指令操作的性质�Q�在�q�里我们�? 用汇�~�符��L��形式�q�行说明�Q�，如iload表示从存储器中装入一个整敎ͼ�anewarray表示��Z��个新数组分配�I�间�Q�iand表示两个整数�? �?�Q�ret用于��程控制�Q�表�C�Z��Ҏ��一�Ҏ��的调用中�q�回。当长度大于8位时�Q�操作数被分��Z��个以上字节存放。JVM采用�?big endian"的编码方式来处理�q�种情况�Q�即高位bits存放在低字节中。这�?Motorola及其他的RISC CPU采用的编码方式是一致的�Q�而与Intel采用�?little endian "的编码方式即低位bits存放在低位字节的�Ҏ��不同�?br /> Java指��o�pȝ��是以Java语言的实��Cؓ目的设计的，其中包含了用于调用方法和监视多先�E�系�l�的指��o。Java�?位操作码的长度��得JVM最多有256�U�指令，目前已��用了160多种操作码�?br /> 2.2JVM指��o�pȝ��
所有的CPU均包含用于保存系�l�状态和处理器所需信息的寄存器�l�。如果虚拟机定义较多的寄存器�Q�便可以从中得到更多的信息而不必对栈或内存�q�行讉K��Q�这有利于提高运行速度。然而，如果虚拟��Z��的寄存器比实际CPU的寄存器多，在实现虚拟机时就会占用处理器大量的时间来用常规存储器模拟寄存器，�q�反而会�? 低虚拟机的效率。针对这�U�情况，JVM只设�|�了4个最为常用的寄存器。它们是�Q?br /> pc�E�序计数�?br /> optop操作数栈��指�?br /> frame当前执行环境指针
vars指向当前执行环境中第一�?zmkey class="zoomino-searchword">局部变�?/zmkey>的指�?br /> 所有寄存器均�ؓ32位。pc用于记录�E�序的执行。optop,frame和vars用于记录指向Java栈区的指针�?br /> 2.3JVM栈结�?br /> 作�ؓ��Z��栈结构的计算机，Java栈是JVM存储信息的主要方法。当JVM得到一个Java字节码应用程序后�Q�便��代码中一个类的每一个方法创��Z��个栈框架�Q�以保存该方法的状态信息。每个栈框架包括以下三类信息�Q?br /> 局部变�?br /> 执行环境
操作数栈
局部变量用于存储一个类的方法中所用到的局部变量。vars寄存器指向该变量表中的第一个局部变量�?br /> 执行环境用于保存解释器对Java字节码进行解释过�E�中所需的信息。它们是�Q�上�ơ调用的�Ҏ��、局部变量指针和操作数栈的栈��和栈底指针。执行环境是一�? 执行一个方法的控制中心。例如：如果解释器要执行iadd(整数加法)�Q�首先要从frame寄存器中扑ֈ�当前执行环境�Q�而后便从执行环境中找到操作数栈，从栈��弹��Z��个整数进行加法运��，最后将�l�果压入栈顶�?br /> 操作数栈用于存储�q�算所需操作数及�q�算的结果�?br /> 2.4JVM��片回收�?br /> Java�cȝ��实例所需的存储空间是在堆上分配的。解释器具体承担为类实例分配�I�间的工作。解释器在�ؓ一个实例分配完存储�I�间后，便开始记录对该实例所占用的内存区域的使用。一旦对象��用完毕，便将其回收到堆中�?br /> 在Java语言中，除了new语句外没有其他方法�ؓ一对象甌��和释攑ֆ�存。对内存�q�行释放和回收的工作是由Java�q�行�pȝ��承担的。这允许Java�q�行 �pȝ��的设计者自己决定碎片回收的�Ҏ��。在SUN公司开发的Java解释器和Hot Java环境中，��片回收用后台线�E�的方式来执行。这不但��行系�l�提供了良好的性能�Q�而且使程序设计�h员摆�׃��自己控制内存使用的风险�?br /> 2.5JVM存储�?br /> JVM有两�c�d��储区�Q�常量缓冲池和方法区。常量缓冲池用于存储�c�d��U�、方法和字段名称以及串常量。方法区则用于存储Java�Ҏ��的字节码。对于这两种�? 储区域具体实现方式在JVM规格中没有明��规定。这使得Java应用�E�序的存储布局必须在运行过�E�中��定�Q�依赖于具体�q�_��的实现方式�?br /> JVM是�ؓJava字节码定义的一�U�独立于具体�q�_��的规格描�q�ͼ�是Java�q�_��独立性的基础。目前的JVM�q�存在一些限制和不��Q�有待于�q�一步的完善�Q�但无论如何�Q�JVM的思想是成功的�?br /> �Ҏ��分析�Q�如果把Java原程序想象成我们的C++原程序，Java�?zmkey class="zoomino-searchword">�E�序�~�译后生成的字节码就相当于C++原程序编译后�?0x86的机器码�Q�二�q�制�E�序文�g�Q�，JVM虚拟机相当于80x86计算机系�l?Java解释器相当于80x86CPU。在80x86CPU上运行的是机器码�Q�在Java解释器上�q�行的是Java字节码�?br /> Java解释器相当于�q�行Java字节码的“CPU”,但该“CPU”不是通过��g实现的，而是用��Y件实现的。Java解释器实际上��是特定的��^��C��? 一个应用程序。只要实��C��特定�q�_��下的解释器程序，Java字节码就能通过解释器程序在该��^��C��q�行�Q�这是Java跨��^台的�Ҏ��。当前，�q�不是在所有的�q? ��C��都有相应Java解释器程序，�q�也是Java�q�不能在所有的�q�_��下都能运行的原因�Q�它只能在已实现了Java解释器程序的�q�_��下运行�?/p>

Java宣称的一处编写随处运行就是由JVM来完�? 在sun的网站上你可以下载到��Z��各种cpu和各�U�操作系�l�的Jdk和jre的下载版�?只要��L��到合适你使用的版�?以前你所�~�写的class文�gcopy到其他的机器上可以直接运�?不需要再�~�译.

其实j2se是一�U�规�?�q�种规范�U�定了其跨��^台执行的所需要关注很多实�?��Z��该规范开发�h员可以�Q意编写自��q��Java代码而不需要关心这个程序可能在其他的机器和cpu上无法很好运行问�?

其实你也可以看到Ibm和Weblogic都有��Z��j2se规范的自己实现的Java 虚拟�?. 而且Sun所宣称的不需要编译而可以直接用class文�g在各个JVM上直接运行�ƈ不精��?博格曄��遇到�q�用sun jre开发的class文�g在ibm jre上有一个自动�{换的�q�程,然后�q�个�c�d��以很好的工作�?�q�好�q�种情况是自动完�?否则我们又要陷入�c�M��于各�U�c c++的版本编译器兼容性问题中.

以下下摘录了几个主要的概�?

JVM Java Virtual Machine�Q�Java虚拟机）�Q�它是一个虚构出来的计算�?是通过在实际的计算��Z��仿真模拟各种计算机功能来实现的�? Java虚拟机有自己完善的硬件架�?如处理器、堆栈、寄存器�{?�q�具有相应的指��o�pȝ��。JVM屏蔽了与具体操作�pȝ��q�_��相关的信�?使得Java�E�序�? 需生成在Java虚拟��Z��q�行的目标代�?字节�?,��可以在多种�q�_��上不加修改地�q�行。Java虚拟机在执行字节码时,实际上最�l�还是把字节码解释成�? 体��^��C��的机器指令执行�?/p>

JRE Java Runtime Environment�Q�Java�q�行环境�Q�，�q�行JAVA�E�序所必须的环境的集合�Q�包含JVM标准实现及Java核心�c�d��?/p>

JSDK Java Software Development Kit�Q�和JDK以及J2SE�{�同�?/p>

JDK Java Development Kit(Java开发工具包):包括�q�行环境、编译工具及其它工具、源代码�{�，基本上和J2SE�{�同�?/p>

J2ME Java 2 Micro Edition�Q�JAVA2�_��版）API规格��Z��J2SE �Q�但是被修改为可以适合某种产品的单一要求。J2ME使JAVA �E�序可以很方便的应用于电话卡、寻呼机�{�小型设备，它包括两�U�类型的�l��g�Q�即配置�Q�configuration�Q�和描述�Q�profile�Q��?/p>

J2EE Java 2 Enterprise Edition�Q�JAVA2企业版）�Q��用Java�q�行企业开发的一套扩展标准，必须��Z��J2SE�Q�提供一个基于组件设计、开发、集合、展开企业应用的�? 径。J2EE �q�_��提供了多层、分布式的应用模型，重新利用�l��g的能力，�l�一安全的模式以及灵�zȝ��处理控制能力�?J2EE包括EJB, JTA, JDBC, JCA, JMX, JNDI, JMS, JavaMail, Servlet, JSP�{�规范�?/p>

J2SE Java 2 Standard Edition�Q�JAVA2标准版）�Q�用来开发Java�E�序的基��Q�包括编译器、小工具、运行环境，SUN发布的标准版本中�q�包括核心类库的所有源代码�?/p>

摘自�Q�http://www.diybl.com/course/3_program/java/javajs/20090304/157613.html

矛_��@ 2009-08-22 09:52 发表评论

如何“快速”掌握一门语�a�

矛_��@ — Fri, 21 Aug 2009 13:45:00 GMT

现在的开发工作要求我们能够快速掌握一门语�a�。一般来说应对这�U�挑战有两种态度�Q�其一�Q�粗�_�看看语法，��撸赯��子开�qԌ��Ҏ��Google边学习；�? 二是花很多时间完整地把整个语�a�学习一遍，做到胸有成竹�Q�然后再开始做实际工作。然而这两种�Ҏ��都有弊病。第二种�Ҏ��的问题当然很明显�Q�不仅浪费了旉��Q? 偏离了目标，而且学习效率不高。因为没有实际问题驱动的语言学习通常是不牢固不深入的。有的�h学着学着成了语言专家�Q�反而忘了自己原本是要解决问题来的�? �W�一�U��\子也有问题，在对于这�U�语�a�的脾气秉性还没有了解的情况下大刀阔斧地拼凑代码，写出来的东西肯定不入��。说�I�新鞋走老�\�Q�新瓶装旧酒�Q�那都是��问题，真正严重的是�q�样的程序员可以在短旉��内堆�U�大量充满缺��L��垃圾代码。由于通常开发阶�D늚��试完备�E�度有限�Q�这些垃圾代码往往能通过�q�个阶段�Q�从而潜伏下来，在后期成为整个项目的毒瘤�Q�反反复复让后来的维护者陷入西西弗斯困境�?/p>

实际上语�a�学习有一定规律可循，对于已经掌握一门语�a��? 开发者来��_��对于一般的语言�Q�完全可以以最快的速度�Q�在几天至一周之内掌握其最常用�?0%�Q�而且保证路子基本正宗�Q�没有出偏的弊病。其实真正写�E�序不�? 完全不会�Q�最怕一知半解的��L��解决�Ҏ��。因��Z��完全不会�Q�就自然会去认真查书学习�Q�如果学习能力好的话�Q�写出来的代码质量不会差。而一知半解，自己动手�? 法炼钢，那搞出来的基本上都是废铜烂铁。比如错误处理和序列化，很多��Z��M��?#8220;正�\�?#8221;�Q�而是凭借自��q��一知半解去攒野路子�Q�这是最危险的。因此，即�� 旉��再紧张，�q�些内容也是必须首先完整了解一遍的。掌握这些内容之后进入实际开发，即��有问题，也基本不会伤及项目大体。而开发者本人则可以安步当�R�Q�慢慢在实践中提高自己�?/p>

以下列出一个学习提�UԌ��主要针对的是有经验的人，初学者不合适。这个提�U�只能用于一般的�怿��~�程语言学习�Q�目前在 ��行�~�程语言排行榜上排前20的基本上都是�怿�语言。如果你要学的是LISP之类非庸俗语�a��Q�或是某个��Y件中的二�ơ开发语�a��Q�这里的��未必合适。还是那句话�Q�仅供参考�?/p>

1. 首先了解该语�a�的基本数据类型，基本语法和主要语�a�构�?/font>�Q�主要数学运��符和print函数的��用，辑ֈ�能够写�K��强�E�序设计书课后数学习题的�E�度�Q?/p>

2. 其次掌握数组和其他集合类的��?/font>�Q�有基础的话可以理解一下泛型，如果理解不了也问题不大，后面可以补；

3. ��单字�W�串处理。所谓简单，��是Regex和Parser以下的内容，什么查找替换，截断��d��串之�cȝ��。不�q�这个阶�D�|��一个难点，��是字符�~�码问题。如果理解不了，可以先蟩�q�，否则的话最好在�q�时候把�q�个问题搞定�Q�免留后患；

4. 基本面向对象或者函数式�~�程的特�?/font>�Q�无非是什么��ѝ��多态、Lambda函数之类的，如果有经验的话很快就明白了；

5. 异常、错误处理、断�a�、日志和调试支持�Q�对单元��试的支�?/font>。你不一定要用TDD�Q�但是在�q�个时候应该掌握在�q�个语言里做TDD的基本技能；

6. �E�序代码和可执行代码的组�l�机�Ӟ��q�行时模块加载、符��h��找机�?/font>�Q�这是初学时的一个难点，因�ؓ大部分书都不太注意介�l�这个极为重要的内容�Q?/p>

7. 基本输入输出和文件处理，输入输出��类的组�l?/font>�Q�这通常是比较繁琐的一部分�Q�可以提�U�挈领学一下，搞清楚概念，用到的时候查��是了。到�q�个阶段可以写大部分控制台应用了�Q?/p>

8. 该语�a�如何�q�行callback�Ҏ��调用�Q�如何支持事仉��动编�E�模型�?/font>�? ��C��~�程环境下，�q�个问题是涉及开发思想的一个核心问题，几乎每种语言在这里都会用��_��夫，.NET的delegate�Q�Java的anonymous inner class�Q�Java 7的closure�Q�C++OX�? tr1::function/bind�Q�五花八门。如果能��d��理解�q�个问题�Q�不但程序就不至于写得太走样�Q�而且对该语言的设计思�\也能有比较好的认识；

9. 如果有必要，可在�q�时研究regex和XML处理问题�Q�如无必要可跌��Q?/p>

10. 序列化和反序列化�Q�掌握一下缺省的机制��可以了�Q?/p>

11. 如果必要�Q�可了解一下线�E�、�ƈ发和异步调用机制�Q�主要是��Z��L��别�h的代码，如果自己要写�q�类代码�Q�必��M��门花旉��严肃认真�pȝ��地学习，严禁半桶水上阵；

12. 动态编�E�，反射和元数据�~�程�Q�数据和�E�序之间的相互�{化机�Ӟ��q�行时编译和执行的机�Ӟ��有抱负的开发者在�q�块可以多下些功夫，能够使你对语�a�的认识高��Z��个层面；

13. 如果有必要，可研�I�一下该语言对于泛型的支持，不必花太多时��_��只要能��用现成的泛型集合和泛型函数就可以了，可在以后闲暇时抽旉��pȝ��学习。需要注意的是，泛型技术跟多线�E�技术一��P��用不好就成�ؓ万恶之源�Q�必��ȝ��l�学习，谨慎使用�Q�否则不如不学不用；

14. 如果�q�有旉��Q�最好咨询一下有�l�验的�h�Q�看看这个语�a�较常用的特色features是什么，如果之前没学�q�，应当补一下。比如Ruby的block interator, Java的dynamic proxy�Q�C# 3的LINQ和extension method。没旉��的话�Q�我认�ؓ也可以边做边学，没有大问题�?/p>

15. 有必要的话，在工作的闲暇旉��Q�可以着重考察两个问题�Q�第一�Q�这个语�a�有哪些惯用法和模式，�W�二�Q�这个语�a�的编�?解释执行机制�?/p>

�? 此语�a�的基本部分就可以说掌握了�Q�之后是做数据库、网�l�还是做囑�Ş�Q�可以根据具体需求去搞，扄��应的成熟框架或库�Q�边做边学，加深理解。对于一个庸俗语 �a��Q�我自己把上面的内容��C��遍大概要�?-3周时��_��不能��很快，但也耽误不了太多事情�Q�毕竟不是每个月都学新语�a�。掌握了以上的内容，��q��l�武术打好了基本功，虽然不见得有多优�U��Q�但是肯定是�Ҏ��苗红�Q�将来不必绕大弯子。就��是临时使用的语�a��Q�把上面�q�个提纲�_��一下，只看蓝色重体字的部分�Q�大致能在几天到一周内搞定�Q�不��是太耗时�Q�而且写出来的代码不会太不靠谱�?/p>

以上提纲未设及内存模型。对于C/C++�Q�这个问题很重要�Q�要攑֜�显著位置来考虑�Q�但对于其他语言�Q�这个问题被透明化了�Q�除非你要做hardcore��目�Q�否则不必太��x��?/p>

摘自�Q�http://blog.csdn.net/myan/archive/2008/10/25/3144661.aspx

矛_��@ 2009-08-21 21:45 发表评论

java中进行callback�Ҏ��调用

矛_��@ — Fri, 21 Aug 2009 13:43:00 GMT

回调函数(callback function)�q�个概念, 所谓回调函�?��是指这个函数先在某处注册，而它��在�E�后某个需要的时候被调用。比如在利用SDK �q�行Windows�~�程的时�?我们需要注册一个WNDCLASS�c?�q�个�c�M��有这样一个参�?lpfnWndProc, 要进行消息处�?我们��p��用处理消息的函数的指针给它赋倹{��消息处理函��C��么时候被调用的？我们没有昑ּ�地在�E�序中看到啊。是OS调用的�?nbsp; �q�是SDK的试验方式，当然用的是过�E�式的语�a�C�Q�可以通过传递函数的指针实现�?/p>

C++中怎么来实现呢�Q�当�Ӟ��C++兼容C�Q�用函数指针��可以�?nbsp; 同时C++又提供了面向对象的机�Ӟ��可不可以有不同的实现机制呢？当然�Q? STL 中的functor(Function object)��可以用到回调上�?nbsp; 比如对一个存放int数据的vector�q�行递减排序的话�Q�我们可以这栯��行�?/p>

sort(vec.begin(),vec.end(),greater());

greater()��是我们传递的一个匿名对象，它重载了函数调用�q�算�W?#8220;()”。我们没有显式地调用�q�个对象里面提供的函敎ͼ�sort函数对对象里面的函数�q�行call back�?/p>

Java中要实现�c�M��functor的功能，应该怎么办呢�Q�Command模式可以帮上忙。Command模式看�v来很��单，只要把command��装��C��个接口中��可以。Command模式是回调机制的一个面向对象的替代品�?/p>

比如 java.io 中已�l�定义好的一个接�?/p>

    public interface FilenameFilter {
        boolean accept(File dir, String name);
    }

�q�个FilenameFilter��是Command�Q�实现Command的类��是ConcreteCommand。这个接口所声明的操�? “accept” ��是看看目录dir中的文�gname是否满��某种要求�Q�如果满��_��q�回true�Q�否则就�q�回false。这个要求是什么呢�Q�你要对�q�个接口�q�行实现。比�? 我想看看�q�个文�g的名�U�包含不包含指定
的字�W�串�Q�那么就可以定义下面的类�Q?/p>

    class DirFilter implements FilenameFilter {
        private String afn;
        public DirFilter(String afn){

   this.afn = afn;
        }
        public boolean accept(File dir, String name){
            String f = new File(name).getName();
            return f.indexOf(afn) != -1;
        }
    }

怎么样��用它呢？File�c�M��有这样一个方�?br /> public String[] list(FilenameFilter filter)

因此�Q�我们就可以�q�样做了�Q?br /> File file = new File(”.”);
String[] list = file.list(new DirFilter(”wf”));

得到的list��是一个当然目录中所有包含字�W�串”wf”的文件名�U�的字符串数�l��?/p>

怎么��P��看�v来是不是和C++中的functor差不多呢�Q?/p>

anonymous inner class �?nbsp; closure �Q?.0�Q�都是体现回调的思想

矛_��@ 2009-08-21 21:43 发表评论

java reference

矛_��@ — Wed, 19 Aug 2009 04:49:00 GMT

Reference
Java世界泰山北斗�U�大作《Thinking In Java》切入Java��提�?#8220;Everything is Object”。在Java�q�个充满Object的世界中�Q�reference是一切谜题的�Ҏ��Q�所有的故事都是从这里开始的�?/p>

Reference是什么？
如果你和我一样在�q�入 Java世界之前曄��迹于C/C++世界�Q�就一定不会对指针陌生。谈到指针，往日种�U�不堪回首的�l�历一下子涌上心头�Q�这里不是抱怨的地方�Q�让我们暂时�? 记指针的痛苦�Q�回忆一下最初接触指针的甜蜜吧！�q�记得你看过的教�U�书中，如何讲解指针吗？留在我印象中的一�U�说法是�Q�指针就是地址�Q�如同门牌号码一��P��? 了地址�Q�你可以轻而易举找��C��个�h�Ӟ��而不必费��心力的大�v捞针�?br /> C++��M��历史舞台�Q�reference也随之而来�Q�容我问个小问题�Q�指针和reference区别何在�Q�我的答案来自于在C++世界享誉盛名的《More Effective C++》�?/p>

没有null reference�?
reference必须有初倹{�?
使用reference要比使用指针效率高。因为reference不需要测试其有效性�?
指针可以重新赋��|��而reference��L��指向它最初获得的对象

设计选择�Q?/strong>
当你指向你需要指向的某个东西�Q�而且�l�不会改指向其它东西�Q�或是当你实作一个运��符而其语法需要无法有指针达成�Q�你��应该选择reference。其它�Q何时候，请采用指针�?/p>

�q�和Java有什么关�p�？
初学Java�Q�鉴于reference的名�U�ͼ�我毫不犹豫的��它和C++中的reference�{�同��h��。不�q�，我错了。在Java中，reference可以随心所�Ʋ的赋值置�I�，�Ҏ��一下上面列出的差异�Q�就不难发现�Q�Java的reference如果要与 C/C++对应�Q�它不过是一个穿着reference外衣的指针而已�?br /> 于是�Q�所有关于C中关于指针的理解方式�Q�可以照搬到Java中，��而言之，reference��是一个地址。我们可以把它想象成一个把手，抓住它，��抓住了我们惌��操纵的数据。如同掌握C的关键在于掌握指针，探烦Java的钥匙就是reference�?/p>

一�D�小�E�序
我知道，太多的文字��L��令�h犯困�Q�那��来�D�代码吧�Q?br /> public class ReferenceTricks {
  public static void main(String[] args) {
    ReferenceTricks r = new ReferenceTricks();
    // reset integer
  r.i = 0;
    System.out.println("Before changeInteger:" + r.i);
    changeInteger(r);
  System.out.println("After changeInteger:" + r.i);

    // just for format
  System.out.println();

    // reset integer
  r.i = 0;
    System.out.println("Before changeReference:" + r.i);
  changeReference(r);
    System.out.println("After changeReference:" + r.i);
}

  private static void changeReference(ReferenceTricks r) {
r = new ReferenceTricks();
   r.i = 5;
   System.out.println("In changeReference: " + r.i);
}

private static void changeInteger(ReferenceTricks r) {
   r.i = 5;
   System.out.println("In changeInteger:" + r.i);
}

public int i;
}

对不��P��我知道，把一个字�D�设成public是一�U�不好的�~�码习惯�Q�这里只是�ؓ了说明问题�?br /> 如果你有兴趣自己�q�行一下这个程序，我等你！

OK�Q�你已经�q�行�q�了吗？�l�果如何�Q�是否如你预期？下面是我在自��q��机器上运行的�l�果�Q?br /> Before changeInteger:0
In changeInteger:5
After changeInteger:5

Before changeReference:0
In changeReference: 5
After changeReference:0
�q�里�Q�我们关注的是两个change——changeReference和changeInteger。从输出的内容中�Q�我们可以看出，两个�Ҏ��在调用前和调用中完全一��P��差异出现在调用后的结果�?/p>
�p�涂的讲�?/span>
先让我们来分析一下changeInteger的行为�?br /> 前面说过了，Java中的reference��是一个地址�Q�它指向了一个内存空��_��q�个�I�间存放着一个对象的相关信息。这里我们暂时不��d��心这个内存具体如何排布，只要知道�Q�通过地址�Q�我们可以找到r�q�个对象的i字段�Q�然后我们给它赋�?。既然这个字�D늚�内容得到了修改，从函��C��q�回之后�Q�它自然��是改动后的�l? 果了�Q�所以调用之后，r对象的i字段依然�?。下囑ֱ��C�Z��changeInteger调用前后内存变化�?/p>
     Reference +--------+                Reference +--------+
    ---------->| i = 0 |               ---------->| i = 5 |
               |--------|                          |--------|
               | Memory |                          | Memory |
               |        |                          |        |
               |        |                          |        |
               +--------+                          +--------+

    调用changeInteger之前               调用changeInteger之后

让我们把目光转向changeReference�?br /> 从代码上�Q�我们可以看出，同changeInteger之间的差别仅仅在于多了这么一句�?br /> r = new ReferenceTricks();
�q�条语句的作用是分配一块新的内存，然后��r指向它�?br /> 执行完这条语句，r��׃��再是原来的r�Q�但它依然是一个ReferenceTricks的对象，所以我们依然可以对�q�个r的i字段赋倹{��到此�ؓ止，一切都是那么自然�?/p>
     Reference +--------+                          +--------+
    ---------->| i = 0 |                          | i = 0 |
               |--------|                          |--------|
               | Memory |                          | Memory |
               |        |                Reference |--------|
               |        |               ---------->| i = 5 |
               +--------+                          +--------+

    调用changeReference之前              调用changeReference之后

��着�q�个思�\�l�箋下去的话�Q�执行完changeReference�Q�输出的r的i字段�Q�那么应该是应该是新内存中的i�Q�所以应该是5。至于那块被我们抛弃的内存，Java的GC功能自然会替我们善后的�?br /> 事与愿违�?br /> 实际的结果我们已�l�看��C��Q�输出的�?�?br /> 肯定哪个地方错了�Q�究竟是哪个地方呢？

参数传递的�U�密
知道�Ҏ��参数如何传递吗�Q?br /> 记得刚开始学�~�程那会儿，老师教导�Q�所谓参敎ͼ�有�Ş式参数和实际参数之分�Q�参数列表中写的那些东西都叫形式参数�Q�在实际调用的时候，它们会被实际参数所替代�?br /> �~? 译程序不可能知道每次调用的实际参数都是什么，于是写编译器的高手就��Z��办法�Q�让实际参数按照一定顺序放��C��个大安��可以扑־�到的地方�Q�以此作为方法调�? 的一�U�约定。所�?#8220;没有规矩�Q�不成方�?#8221;�Q�有了这个规矩，大家协作��h��容易多了。这个公共数据区�Q�现在编译器的选择通常�?#8220;�?#8221;�Q�而所谓的��序��是形式参数声明的顺序�?br /> 昄��Q�程序运行的�q�程中，作�ؓ实际参数的变量可能遍布于内存的各个位�|�，而�ƈ不一定要老老实实的呆在栈里。�ؓ了守“规矩”�Q�程序只好将变量复制一份到栈中�Q�也��是通常所说的��参数压入栈中�?br /> 打�v�_��Q�谜底就要揭晓了�?br /> 我刚才说什么来着�Q�将变量复制一份到栈中�Q�没错，“复制”�Q?br /> �q�就是所谓的��g��递�?br /> C语言的旷世经典《The C Programming Language》开��的�W�一章中�Q�谈到实际参数时��_��“在C中，所有函数的实际参数都是�?#8216;�?#8217;�?#8221;�?br /> 马上会有人站出来�Q?#8220;错了�Q�还有传地址�Q�比如以指针传递就是传地址”�?br /> 不错�Q�传指针��是传地址。在把指针视为地址的时候，是否考虑�q�这样一个问题，它也是一个变量。前面的讨论中说�q�了�Q�参��C��递必��要把参数压入栈中，作�ؓ地址的指针也不例外。所以，必须把这个指针也复制一份。函��C��对于指针操作实际上是对于�q�个指针副本的操作�?br /> Java的reference�{�于C的指针。所以，在Java的方法调用中�Q�reference也要复制一份压入堆栈。在�Ҏ��中对reference的操作就是对�q�个reference副本的操作�?br /> 谜底揭晓
好，让我们回到最初的问题上�?br /> 在changeReference中对于reference的赋值实际上是对�q�个reference的副本进行赋��|��而对于reference的本��没有��生丝毫的影响�?br /> 回到调用点，本尊醒来�Q�它�q�不知道自己睡去的这�D�|��间内发生�q�什么，所以只好当作什么都没发生过一般。就�q�样�Q�副本消�׃��Q�在�Ҏ��中对它的修改也就烟消云散了�?br />
也许你会问出�q�样的问题，“听了你的解释�Q�我反而对changeInteger感到�q�h��了，既然是对于副本的操作�Q��ؓ什么changeInteger可以�q�作正常�Q?#8221;
呵呵�Q�很有趣的大脑短路现象�?br /> 好，那我��q��前面的说法解释一下changeInteger的运作�?br /> 所谓复�Ӟ��其结果必然是副本完全�{�同于本��。reference复制的结果必然是两个reference指向同一块内存空间�?br /> 虽然在方法中对于副本的操作�ƈ不会影响到本��，但对内存�I�间的修改确实实实在在的�?br /> 回到调用点，虽然本尊依然不知道曾�l�发生过的一切，但它按照原来的方式访问内存的时候，取到的确是经�q�方法修改之后的内容�?br /> 于是�Ҏ��可以把自��q��影响扩展到方法之外�?br />
多说几句
�q? 个问题�v源于我对C/C++中同样问题的思考。同C/C++相比�Q�在changeReference中对reference赋值可能�ƈ不会造成什么很严重的后果，而在C/C++中，�q�么做却会造成臭名昭著�?#8220;内存泄漏”�Q�根本的原因在于Java拥有了可��q��GC功能。即便这��P��我仍不推荐��用这�U�的手法�Q? 毕竟GC已经很忙了，我们怎么好意思再�ȝ��人家�?br /> 在C/C++中，�q�个问题�q�可以��l�引生뀂既然在函数中对于指针直接赋��D��不通，那么如何在函��C��修改指针呢？�{�案很简单，指针的指针，也就是把原来的指针看作一个普通的数据�Q�把一个指向它的指针传到函��C��可以了�?br /> 同样的问题到了Java中就没有那么��妙的解��x��案了�Q�因为Java中可没有reference的reference�q�样的语法。可能的变通就是将reference�q�行��装成类。至于��g��|��公道自在人心�?/p>

摘自�Q�http://azi.javaeye.com/blog/182792

矛_��@ 2009-08-19 12:49 发表评论

数据�c�d��转换

矛_��@ — Wed, 19 Aug 2009 04:43:00 GMT
     摘要: Code highlighting produced by Actipro CodeHighlighter (freeware) http://www.CodeHighlighter.com/ --> public class BinConverter {     /**     &...  阅读全文

矛_��@ 2009-08-19 12:43 发表评论

矛_��@ — Fri, 14 Aug 2009 10:26:00 GMT
0　引言
从控制台中读取数据是一个比较常用的功能�Q�在 JDK 5.0 以前的版本中的实现是比较复杂的，需要手工处理系�l�的输入��。有意思的是，�? JDK 5.0 版本开始，能从控制��C��输入数据的方法每增加一个版本号�Q�就有一�U�新增的�Ҏ��Q�这也增加了选择的种�c�，可以依据不同的要求来�q�行选择。下面来看一下，各个版本中如何从控制��C��d��数据以及各自的优�~�点�?

1　JDK 1.4 及以下版本读取的�Ҏ��
JDK 1.4 及以下的版本中要想从控制��C��输入数据只有一�U�办法，即��用System.in获得�pȝ��的输入流�Q�再桥接臛_��W�流从字�W�流中读入数据。示例代码如下：

import java.io.IOException;
import java.io.InputStreamReader;

public class Test1 {

    public static void main(String[] args) {
        String str = readString("误��入字�W�串�Q?);
        System.out.println("readString �Ҏ��的输入：" + str);
    }

    /**
     * 使用�pȝ��的输入流�Q�从控制��C��d��数据

     * 用于所用的JDK版本
     * @param prompt 提示信息
     * @return 输入的字�W�串
     */
    private static String readString(String prompt) {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String str = null;
        try {
            System.out.print(prompt);
            str = br.readLine();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return str;
    }
}

从上面的代码�D�|��看，�q�种控制台输入的�Ҏ��非常地麻烦，��Z��能读取整行的数据�Q�采用了BufferedReader�c�L��q�行处理�Q�而且在读取的�q? �E�中�q�需要捕获IOException。不�q�这�?JDK 1.4 及以下版本中从控制台��d��数据唯一的办法。还有一�U�非控制台读入数据的办法�Q�就是采�?Swing 中的JOptionPane�Q�会弹出一个非常漂亮的输入对话框让使用者输入数据，但这是一�U�比较另�cȝ��做法�Q�不推荐使用�?

import javax.swing.JOptionPane;

public class Test2 {

    public static void main(String[] args) {
        String str = readStringFromDialog("误��入字�W�串�Q?);
        System.out.println("readStringFromDialog �Ҏ��的输入：" + str);
    }

    /**
     * 使用JOptionPane的输入对话框�Q�输入字�W�串

     * 用于所用的JDK版本
     * @param prompt 提示信息
     * @return 输入的字�W�串
     */
    private static String readStringFromDialog(String prompt) {
        return JOptionPane.showInputDialog(prompt);
    }
}
上面的两�U�方法都有个共同的缺点——只能读取字�W�串�Q�若需要读取其他类型的数据需要手工进行�{换�?

2　JDK 5.0 ��d��的方�?
�?JDK 5.0 开始，基本�c�d��中增加了java.util.Scanner�c�，�Ҏ��它的 API 文档说明�Q�这个类是采用正则表辑ּ��q�行基本�c�d��和字�W�串分析的文本扫描器。��用它的Scanner(InputStream source)构造方法，可以传入�pȝ��的输入流System.in而从控制��C��d��数据。示例代码如下：

import java.util.Scanner;

public class Test3 {

    public static void main(String[] args) {
        String str = readString5("误��入字�W�串�Q?);
        System.out.println("readString5 �Ҏ��的输入：" + str);
    }

    /**
     * 使用扫描器类�Q�Scanner�Q�从控制��C��d��字符�?lt;br/>
     * 适用于JDK 5.0及以后的版本
     * @param prompt 提示信息
     * @return 输入的字�W�串
     */
    private static String readString5(String prompt) {
        Scanner scanner = new Scanner(System.in);
        System.out.print(prompt);
        return scanner.nextLine();
    }
}
从代码量上来看，Test3比Test1��了很多的代码，核心代码只有两行。其实�ƈ不是Scanner��控制台输入�l�简单化了，只是在其内部的实 ��C��已经��IOException处理了，而且采用InputStreamReader来一个字�W�一个字�W�进行扫描读取的�Q�嘿嘿，它本�w�就是个扫描器）�Q? 只是Scanner做了更高层次的封装�?

Scanner不仅可以从控制台中读取字�W�串�Q�还可以��d��除char之外的其他七�U�基本类型和两个大数字类型，�q�不需要显式地�q�行手工转换�? Scanner不单单只能扫描控制台中输入的字符�Q�它�q�可以让��d��的字�W�串匚w��一定的正则表达式模式，如果不匹配时��抛�? InputMismatchException异常�?

使用System.in作�ؓ它的构造参数时�Q�它只扫描了�pȝ��输入��中的字�W�。它�q�有其他的构造，分别可以从文件或者是字符串中扫描分析字符串的�Q�具体的使用�Ҏ��可以参�?API 文档说明�?

3　JDK 6.0 ��d��的方�?
�?JDK 6.0 开始，基本�c�d��中增加了java.io.Console�c�，用于获得与当�?Java 虚拟机关联的��Z��字符的控制台讑֤�。在�U�字�W�的控制台界面下�Q�可以更加方便地��d��数据。示例代码如下：

import java.io.Console;
import java.util.Scanner;

public class Test4 {

    public static void main(String[] args) {
        String str = readString6("误��入字�W�串�Q?);
        System.out.println("readString6 �Ҏ��的输入：" + str);
    }

    /**
     * 使用控制台类�Q�Console�Q�从控制��C��d��字符�?lt;br/>
     * 适用于JDK 1.6或以后的版本
     * @param prompt 提示信息
     * @return 输入的字�W�串
     */
    private static String readString6(String prompt) {
        Console console = System.console();
        if (console == null) {
            throw new IllegalStateException("不能使用控制�?);
        }
        return console.readLine(prompt);
    }
}
在Test1和Test3中，输入数据前的提示信息需要��用System.out.print();来输出，但是使用��Z��Console的Test4�c�，可以在方法参��C��直接攑օ�提示信息�?

如果需要在控制��C��输入密码�{�敏感信息的话，像在��览器或者是应用�E�序中那��h��C�替代字�W�，�?JDK 6.0 以前的做法是相当�ȝ��的（具体的做法可以参考《Java �~�程语言中的口��o屏蔽》一文）�Q�而��用Console�cȝ��readPassword()�Ҏ��可以在控制台上不回显地输入密码，�q�将密码�l�果保存在char 数组中，�Ҏ�� API 文档的徏议，在��用后应立卛_��数组清空�Q�以减少其在内存中占用的旉��Q�以便增强安全性�?

但是�Q�Console也有一些缺点，�Ҏ��ConsoleAPI 文档的说明：

虚拟机是否具有控制台取决于底层��^収ͼ��q�取决于调用虚拟机的方式。如果虚拟机从一个交互式命��o行开始启动，且没有重定向标准输入和输出流�Q�那么其控制台将存在�Q��ƈ且通常�q�接到键盘�ƈ从虚拟机启动的地�Ҏ��C�。如果虚拟机是自动启动的�Q�例如，由后��C��业调度程序启动）�Q�那么它通常没有控制台�?

通过上面的文档说明可以看出，在��?IDE 的情况下�Q�是无法获取到Console实例的，原因在于�?IDE 的环境下�Q�重新定向了标准输入和输出流�Q�也是就是将�pȝ��控制��C��的输入输出重定向��C�� IDE 的控制台中。因此，�?IDE 中不能��用这个程序，而Test1和Test3��没有这�U�限制�?

4　�ȝ��
以上囊括�?Java 中各�U�版本从控制��C��d��数据的方法，��对它们的优�~�点�q�行了分析。下面给��Z��一些��用徏议，可供参考：

JRE 1.4 或以下版本的情况下，没得选择只能采用Test1或者是非控制台��d��的Test2的方法�?
JRE 5.0 的情况下�Q�徏议��用基于Scanner的Test3的方法，更方便地�q�行数据��d��?
JRE 6.0 的情况，�q�且只在字符界面的控制台下运行时�Q�采用Test4的方法，如果需要读入像密码之类的敏感数据，��Z��安全性考虑也必��M��用Test4或者是自行实现。如果需要读入除字符串类型之外的其他数据�c�d��Q�徏议��用基于Scanner的控制台输入�?br /> 摘自�Q�http://yutaozxy.javaeye.com/blog/372981

矛_��@ 2009-08-14 18:26 发表评论

StringIndexOutOfBoundException 引出的对String�cȝ��看法

矛_��@ — Wed, 12 Aug 2009 08:15:00 GMT

邂逅StringIndexOutOfBoundsException

今天在WCS的测试中邂逅了�q�个从未接触的exception

�q��我对它做了一些分�?/p>
首先�Q?br /> “不断的将被选中的字�W�串加到某一字符串末��，当长度超�q�一定量时提�C�：
java.lang.StringIndexOutOfBoundsException: String index out of range: 10
”�q�不能说明String有长度限�?/p>
Java API指出StringIndexOutOfBoundsException异常
Thrown by String methods to indicate that an index is either negative or greater than the size of the string. For some methods such as the charAt method�?br /> 上面的错误是因�ؓ
String.length()<10;
而你又要取index>=10的字�W�从而抛��Z��面异�?br /> String其实是没有限制的�Q�而是当String太大了，��过JVM的自�w�的内存后会抛出
java.lang.OutOfMemoryError错误

String是没有长度限制的�Q�而是有JVM的内存限制了String的长�?/p>
在dayworker的blog中还提到

[quote]

public class testString{
public static void main(String args[])
{
String s="abbbbb";
System.out.println("JVM MAX MEMORY: "+Runtime.getRuntime().maxMemory()/1024/1024+"M");
System.out.println("JVM IS USING MEMORY:"+Runtime.getRuntime().totalMemory()/1024/1024+"M");
Runtime.getRuntime().traceMethodCalls(true);
while(true)
{
try{
s=s+s;

}catch(Exception e)
{
System.out.println(e);
}
catch(Error o)
{ String unit = null;
int sizeb = s.length();
int size = sizeb;
int time = 0;
while(size>1024)
{
size = size/1024;
time++;
}
switch(time)
{
case 0: unit = "byte";break;
case 1: unit = "k"; break;
case 2: unit = "M"; break;
default : unit = "byte";
}

System.out.println("String has used memory:"+size+unit);
System.out.println("JVM IS USING MEMORY:"+(float)Runtime.getRuntime().totalMemory()/1024/1024+"M");
System.out.println("MemoryError:"+o);
break;
}

}
}
}
然后我们用JVM的默认参数执行（我的机器内存�?28M�Q?br /> java testString
�l�果�Q?br /> JVM MAX MEMORY: 128M
JVM IS USING MEMORY:1M
String has used memory:12M
JVM IS USING MEMORY:63.5625M
MemoryError:java.lang.OutOfMemoryError
开始JVM使用的内存是1M�Q�当String�?2M�Q�JVM使用�?3M多时
JVM溢出�?br />
然后�Q�我们用限制JVM内存大小的参数来执行,限制最大内�?M
java -mx5m testString
�l�果�Q?br /> JVM MAX MEMORY: 70M
JVM IS USING MEMORY:1M
String has used memory:768.0k
JVM IS USING MEMORY:5.9375M
MemoryError:java.lang.OutOfMemoryError
开始JVM使用的内存是1M�Q�当String�?68k�Q�JVM使用�?M多时
JVM溢出�?br />
大家�q�可以改�?-mx参数�Q�来�q�一步做实验�?br /> 以上两个实验证明,String是没有长度限制的�Q�而是有JVM的内存限制了String的长度。同时说明，�q�不会抛��Z�Q何Exception而只会抛出Error.

OutMemoryError表明�E�序的设计很差，或者遇��C��出�~�程人员所预想的大扚w��的数据。不��哪�U�情况，都只有下面这几种解决办法。它们是�Q?br />
设计人员重新设计�E�序�Q�不致�ɽE�序一�ơ蝲入所有的数据�?br />
数据可以分割成更��的块�?br />
可以为程序分配更多的内存�?br />
为Java虚拟机提供更多的内存�?br />
而上面的例子是�ؓ虚拟机提供更多的内存

=======================================
其实应该��用String�q�东西，特别�?String�?+=操作
不仅原来的String对象不能�l�箋使用�Q�主要是又要new出N多的新对象出来，再多的memory也要out~~
String用char array实现�Q�就肯定由长度限制的�Q�不能用memory来衡�?br />
==================================
例如上面的程序改用StringBuffer实现�Q�就可以得到极大的改善�?br /> 下面是我改用StringBuffer做的��试�Q?br /> 注意�Q�程序��@环了2097150�ơ！
是��用String的程序的99864倍！

public class TestStringBuffer{
public static void main(String args[])
{
String s="abbbbb";
StringBuffer sb = new StringBuffer(s);
System.out.println("JVM IS USING MEMORY:"+
(Runtime.getRuntime().totalMemory()/1024/1024)+
"M");
Runtime.getRuntime().traceMethodCalls(true);

int count = 0;
while(true)
{
try{
sb.append(s);
count++;

}catch(Exception e)
{
System.out.println(e);
}
catch(Error o)
{
String unit = null;
int size = sb.length();
size *= 2;

int time = 0;
while(size>1024)
{
size = size/1024;
time++;
}
switch(time)
{
case 0: unit = "byte";break;
case 1: unit = "k"; break;
case 2: unit = "M"; break;
default : unit = "byte";
}

System.out.println("Loop times:"+count);
System.out.println("String has used memory:"+size+unit);
System.out.println("JVM IS USING MEMORY:"+
(float)Runtime.getRuntime().totalMemory()/1024/1024+
"M");
System.out.println("MemoryError:"+o);
break;
}

}
}
}

输出�l�果�Q?br /> JVM IS USING MEMORY:1M
Loop times:2097150
String has used memory:23M
JVM IS USING MEMORY:63.75M
MemoryError:java.lang.OutOfMemoryError

=====================
�? 另一斚w��_��如果你要处理的字�W�串辑ֈ�癑օ�甚至上GB�Q��用String对象�Q�根本没法工作，所以这个问题不需要太多讨论。看一下jdk的源�? �Ӟ��String的长度是String对象的一个成员count�Q�类型是int�Q�不是long�Q�也不是char。知道这些，我认为够�?/p>
摘自�Q�http://blog.chinaunix.net/u/18/showart_18583.html

矛_��@ 2009-08-12 16:15 发表评论

有点变态的问题

矛_��@ — Sun, 09 Aug 2009 10:09:00 GMT

�W�一�Q�谈谈final, finally, finalize的区别�?

�W�二�Q�Anonymous Inner Class (匿名内部�c? 是否可以extends(�l�承)其它�c�，是否
可以implements(实现)interface(接口)?

�W�三�Q�Static Nested Class �?Inner Class的不同，说得��多��好(面试题有的很�W?br /> �l?�?br />
�W�四�Q?amp;�?amp;&的区别�?br />
�W�五�Q�HashMap和Hashtable的区别�?br />
�W�六�Q�Collection �?Collections的区别�?br />
�W�七�Q�什么时候用assert�?br />
�W�八�Q�GC是什�? ��Z��么要有GC?

�W�九�Q�String s = new String("xyz");创徏了几个String Object?

�W�十�Q�Math.round(11.5)�{�於多少? Math.round(-11.5)�{�於多少?

�W�十一�Q�short s1 = 1; s1 = s1 + 1;有什么错? short s1 = 1; s1 += 1;有什么错
?

�W�十二，sleep() �?wait() 有什么区�?

�W�十三，Java有没有goto?

�W�十四，数组有没有length()�q�个�Ҏ��? String有没有length()�q�个�Ҏ��?

�W�十五，Overload和Override的区别。Overloaded的方法是否可以改变返回值的�c�d��
?

�W�十六，Set里的元素是不能重复的�Q�那么用什么方法来区分重复与否�? 是用==�q�是
equals()? 它们有何区别?

�W�十七，�l�我一个你最常见到的runtime exception�?br />
�W�十八，error和exception有什么区�?

�W�十九，List, Set, Map是否�l�承自Collection接口?

�W�二十，abstract class和interface有什么区�?

�W�二十一�Q�abstract�?a target="_blank" >method是否可同时是static,是否可同时是native�Q�是否可同时
是synchronized?

�W�二十二�Q�接口是否可�l�承接口? 抽象�c�L��否可实现(implements)接口? 抽象�c�L��?br /> 可��承实体类(concrete class)?

�W�二十三�Q�启动一�?a target="_blank" >�U�程是用run()�q�是start()?

�W�二十四�Q�构造器Constructor是否可被override?

�W�二十五�Q�是否可以��承String�c?

�W�二十六�Q�当一个线�E�进入一个对象的一个synchronized�Ҏ��后，其它�U�程是否可进
入此对象的其它方�?

�W�二十七�Q�try {}里有一个return语句�Q�那么紧跟在�q�个try后的finally {}里的cod
e会不会被执行�Q�什么时候被执行�Q�在return前还是后?

�W�二十八�Q�编�E�题: 用最有效率的�Ҏ��出2乘以8�{�於�?

�W�二十九�Q�两个对象值相�?x.equals(y) == true)�Q�但却可有不同的hash code�Q�这
句话对不�?

�W�三十，当一个对象被当作参数传递到一个方法后�Q�此�Ҏ��可改变这个对象的属性，
�q�可�q�回变化后的�l�果�Q�那么这里到底是��g��递还是引用传�?

�W�三十一�Q�swtich是否能作用在byte上，是否能作用在long上，是否能作用在String
�?

�W�三十二�Q�编�E�题: 写一个Singleton出来�?/p>

�Q�＝�Q�＝�Q�＝�Q�＝�Q�＝�Q�＝�Q�＝�Q�＝�Q�＝�Q�＝�Q�＝�Q�＝�Q�＝�Q?/p>
以下是答案：

�Q�＝�Q�＝�Q�＝�Q�＝�Q�＝�Q�＝�Q�＝�Q�＝�Q�＝�Q�＝�Q�＝�Q�＝�Q�＝�Q?/p>
�W�一�Q�谈谈final, finally, finalize的区别�?br /> final—修饰符�Q�关键字�Q�如果一个类被声明�ؓfinal�Q�意味着它不能再�z��出新的子
�c�，不能作�ؓ父类被��ѝ��因此一个类不能既被声明�?abstract的，又被声明为final�?br /> 。将变量或方法声明�ؓfinal�Q�可以保证它们在使用中不被改变。被声明为final的变量必
��d��声明时给定初��|��而在以后的引用中只能��d��Q�不可修攏V��被声明为final的方法也�?br /> 样只能��用，不能重蝲
finally—再异常处理时提�?finally 块来执行��M��清除操作。如果抛��Z��个异常，
那么相匹配的 catch 子句��׃��执行�Q�然后控制就会进�?finally 块（如果有的话）�?/p>
　　finalize—方法名。Java 技术允�怋��?finalize() �Ҏ��在垃圾收集器��对象从内存
中清除出��M��前做必要的清理工作。这个方法是由垃圾收集器在确定这个对象没有被引用
时对�q�个对象调用的。它是在 Object �c�M��定义的，因此所有的�c�都�l�承了它。子�c�覆�?br /> finalize() �Ҏ��以整�?span class="t_tag" onclick="tagshow(event)" class="t_tag">�pȝ��资源或者执行其他清理工作。finalize() �Ҏ��是在垃圾攉��
器删除对象之前对�q�个对象调用的�?br />
�W�二�Q�Anonymous Inner Class (匿名内部�c? 是否可以extends(�l�承)其它�c�，是否
可以implements(实现)interface(接口)?
匿名的内部类是没有名字的内部�c�R��不能extends(�l�承) 其它�c�，但一个内部类可以
作�ؓ一个接口，由另一个内部类实现�?br />
�W�三�Q�Static Nested Class �?Inner Class的不同，说得��多��好(面试题有的很�W?br /> �l?�?br /> Nested Class �Q�一般是C++的说法）�Q�Inner Class (一般是JAVA的说�?。Java内部
�c�M��C++嵌套�c�L��大的不同��在于是否有指向外部的引用上。具体可见http: //www.front
free.net/articles/services/view.asp?id=704&page=1
注：静态内部类�Q�Inner Class�Q�意味着1创徏一个static内部�cȝ��对象�Q�不需要一�?br /> 外部�c�d��象，2不能从一个static内部�cȝ��一个对象访问一个外部类对象
Hashtable�l�承自Dictionary�c�，而HashMap是Java1.2引进的Map interface的一个实
�?/p>
　　HashMap允许��null作�ؓ一个entry�?a target="_blank" >key或者value�Q�而Hashtable不允�?/p>
　　�q�有��是�Q�HashMap把Hashtable的contains�Ҏ��L��了，�Ҏ��containsvalue和conta
insKey。因为contains�Ҏ��Ҏ��让�h引�v误解�?/p>
　　最大的不同是，Hashtable的方法是Synchronize的，而HashMap不是�Q�在
多个�U�程讉K��Hashtable�Ӟ��不需要自�׃ؓ它的�Ҏ��实现同步�Q�而HashMap
��必��Mؓ之提供外同步�?br /> �W�四�Q?amp;�?amp;&的区别�?br /> &是位�q�算�W��?amp;&是布��逻辑�q�算�W��?br />
�W�五�Q�HashMap和Hashtable的区别�?br /> 都属于Map接口的类�Q�实��C��惟一键映��到特定的��g��?br /> HashMap �c�L��有分�c�L��者排序。它允许一�?null 键和多个 null 倹{�?
Hashtable �c�M��?HashMap�Q�但是不允许 null 键和 null 倹{��它也比 HashMap 慢，
因�ؓ它是同步的�?br /> Hashtable�l�承自Dictionary�c�，而HashMap是Java1.2引进的Map interface的一个实
�?/p>
　　�q�有��是�Q�HashMap把Hashtable的contains�Ҏ��L��了，�Ҏ��containsvalue和conta
insKey。因为contains�Ҏ��Ҏ��让�h引�v误解�?/p>
　　最大的不同是，Hashtable的方法是Synchronize的，而HashMap不是�Q�在
多个�U�程讉K��Hashtable�Ӟ��不需要自�׃ؓ它的�Ҏ��实现同步�Q�而HashMap
��必��Mؓ之提供外同步�?/p>
　　�W�六�Q�Collection �?Collections的区别�?br /> Collections是个java.util下的�c�，它包含有各种有关集合操作的静态方法�?br /> Collection是个java.util下的接口�Q�它是各�U�集合结构的父接�?
�W�七�Q�什么时候用assert�?br /> 断言是一个包含布��表辑ּ�的语句，在执行这个语句时假定该表辑ּ��?true。如果表
辑ּ�计算�?false�Q�那么系�l�会报告一�?AssertionError。它用于调试目的�Q?
assert(a > 0); // throws an AssertionError if a <= 0
断言可以有两�U��Ş式：
assert Expression1 ;
assert Expression1 : Expression2 ;
Expression1 应该��L��产生一个布��倹{�?
Expression2 可以是得��Z��个值的��L��表达式。这个值用于生成显�C�更多调试信息的
String 消息�?br /> 断言在默认情况下是禁用的。要在编译时启用断言�Q�需要��?source 1.4 标记�Q?/p>
　　javac -source 1.4 Test.java
要在�q�行时启用断�a��Q�可使用 -enableassertions 或�?-ea 标记�?
要在�q�行旉��择��用断言�Q�可使用 -da 或�?-disableassertions 标记�?
要系�l�类中启用断�a��Q�可使用 -esa 或�?-dsa 标记。还可以在包的基��上启用或�?br /> ��用断言�?
可以在预计正常情况下不会到达的�Q何位�|�上攄��断言。断�a�可以用于验证传递给�U?br /> 有方法的参数。不�q�，断言不应该用于验证传递给公有�Ҏ��的参敎ͼ�因�ؓ不管是否启用�?br /> 断言�Q�公有方法都必须��查其参数。不�q�，既可以在公有�Ҏ��中，也可以在非公有方法中
利用断言��试后置条�g。另外，断言不应该以��M��方式改变�E�序的状态�?

�W�八�Q�GC是什�? ��Z��么要有GC? (基础)�?br /> GC是垃圾收集器。Java �E�序员不用担心内�?span class="t_tag" >��理�Q�因为垃圾收集器会自动进�?span class="t_tag" >��理�?br /> 要请求垃圾收集，可以调用下面的方法之一�Q?
System.gc()
Runtime.getRuntime().gc()

�W�九�Q�String s = new String("xyz");创徏了几个String Object?
两个对象�Q�一个是“xyx”,一个是指向“xyx”的引用对象s�?br />
�W�十�Q�Math.round(11.5)�{�於多少? Math.round(-11.5)�{�於多少?
Math.round(11.5)�q�回�Q�long�Q?2�Q�Math.round(-11.5)�q�回�Q�long�Q?11;

�W�十一�Q�short s1 = 1; s1 = s1 + 1;有什么错? short s1 = 1; s1 += 1;有什么错
?
short s1 = 1; s1 = s1 + 1;有错�Q�s1是short型，s1+1�?a target="_blank" >int�?不能昑ּ�转化为sho
rt型。可修改为s1 =(short)(s1 + 1) 。short s1 = 1; s1 += 1正确�?br />
�W�十二，sleep() �?wait() 有什么区�? 搞线�E�的最�?br /> sleep()�Ҏ��是�ɾU�程停止一�D�|��间的�Ҏ��。在sleep 旉��间隔期满后，�U�程不一定立
��x��复执行。这是因为在那个时刻�Q�其它线�E�可能正在运行而且没有被调度�ؓ攑ּ�执行�Q?br /> 除非(a)“醒来”的线�E�具有更高的优先�U?br /> (b)正在�q�行的线�E�因为其它原因而阻塞�?br /> wait()是线�E�交互时�Q�如果线�E�对一个同步对象x 发出一个wait()调用�Q�该�U�程会暂
停执行，被调对象�q�入�{�待状态，直到被唤醒或�{�待旉��到�?br /> �W�十三，Java有没有goto?
Goto—java中的保留字，现在没有在java中��用�?br />
�W�十四，数组有没有length()�q�个�Ҏ��? String有没有length()�q�个�Ҏ��Q?br /> 数组没有length()�q�个�Ҏ��Q�有length的属性�?br /> String有有length()�q�个�Ҏ��?br />
�W�十五，Overload和Override的区别。Overloaded的方法是否可以改变返回值的�c�d��
?
�Ҏ��的重写Overriding和重载Overloading是Java多态性的不同表现。重写Overridin
g是父�c�M��子类之间多态性的一�U�表玎ͼ�重蝲Overloading是一个类中多态性的一�U�表现�?br /> 如果在子�c�M��定义某方法与其父�c�L��相同的名�U�和参数�Q�我们说该方法被重写 (Overridi
ng)。子�cȝ��对象使用�q�个�Ҏ��Ӟ��调用子�c�M��的定义，对它而言�Q�父�c�M��的定义如同被
“屏蔽”了。如果在一个类中定义了多个同名的方法，它们或有不同的参��C��数或有不�?br /> 的参数类型，则称为方法的重蝲(Overloading)。Overloaded的方法是可以改变�q�回值的�c?br /> 型�?br />
�W�十六，Set里的元素是不能重复的�Q�那么用什么方法来区分重复与否�? 是用==�q�是
equals()? 它们有何区别?
Set里的元素是不能重复的�Q�那么用iterator()�Ҏ��来区分重复与否。equals()是判�?br /> 两个Set是否相等�?br /> equals()�?=�Ҏ��军_��引用值是否指向同一对象equals()在类中被覆盖�Q��ؓ的是当两
个分��ȝ��对象的内容和�c�d��盔R��的话�Q�返回真倹{�?br />
�W�十七，�l�我一个你最常见到的runtime exception�?br /> ArithmeticException, ArrayStoreException, BufferOverflowException, BufferU
nderflowException, CannotRedoException, CannotUndoException, ClassCastExceptio
n, CMMException, ConcurrentModificationException, DOMException, EmptyStackExce
ption, IllegalArgumentException, IllegalMonitorStateException, IllegalPathStat
eException, IllegalStateException,
ImagingOpException, IndexOutOfBoundsException, MissingResourceException, N
egativeArraySizeException, NoSuchElementException, NullPointerException, Profi
leDataException, ProviderException, RasterFormatException, SecurityException,
SystemException, UndeclaredThrowableException, UnmodifiableSetException, Unsup
portedOperationException

�W�十八，error和exception有什么区�?
error 表示恢复不是不可能但很困隄��情况下的一�U�严重问题。比如说内存溢出。不
可能指望�E�序能处理这��L��情况�?br /> exception 表示一�U�设计或实现问题。也��是��_��它表�C�如果程序运行正常，从不�?br /> 发生的情��c�?br /> �W�十九，List, Set, Map是否�l�承自Collection接口?
List�Q�Set�?br />
Map不是

�W�二十，abstract class和interface有什么区�?
声明�Ҏ��的存在而不��d��现它的类被叫做抽象类�Q�abstract class�Q�，它用于要创徏
一个体现某些基本行为的�c�，�q��ؓ该类声明�Ҏ��Q�但不能在该�c�M��实现该类的情��c��不�?br /> 创徏abstract �cȝ��实例。然而可以创��Z��个变量，其类型是一个抽象类�Q��ƈ让它指向具体
子类的一个实例。不能有抽象构造函数或抽象静态方法。Abstract �cȝ��子类为它们父�c�M��
的所有抽象方法提供实玎ͼ�否则它们也是抽象�c�Mؓ。取而代之，在子�c�M��实现该方法。知
道其行�ؓ的其它类可以在类中实现这些方法�?br /> 接口�Q�interface�Q�是抽象�cȝ��变体。在接口中，所有方法都是抽象的。多�l�承性可�?br /> �q�实现这��L��接口而获得。接口中的所有方法都是抽象的�Q�没有一个有�E�序体。接口只�?br /> 以定义static final成员变量。接口的实现与子�cȝ��|��除了该实现类不能从接口定义中
�l�承行�ؓ。当�c�d��现特�D�接口时�Q�它定义�Q�即��程序体�l�予�Q�所有这�U�接口的�Ҏ��。然�?br /> �Q�它可以在实��C��该接口的�cȝ��M��对象上调用接口的�Ҏ��。由于有抽象�c�，它允�怋��?br /> 接口名作为引用变量的�c�d��。通常的动态联�~�将生效。引用可以�{换到接口�c�d��或从接口
�c�d��转换�Q�instanceof �q�算�W�可以用来决定某对象的类是否实现了接口�?br />
�W�二十一�Q�abstract的method是否可同时是static,是否可同时是native�Q�是否可同时
是synchronized?
都不�?br />
�W�二十二�Q�接口是否可�l�承接口? 抽象�c�L��否可实现(implements)接口? 抽象�c�L��?br /> 可��承实体类(concrete class)?
接口可以�l�承接口。抽象类可以实现(implements)接口�Q�抽象类是否可��承实体类�Q?br /> 但前提是实体�c�d��L��明确的构造函数�?br />
�W�二十三�Q�启动一个线�E�是用run()�q�是start()?
启动一个线�E�是调用start()�Ҏ��Q��ɾU�程所代表的虚拟处理机处于可运行状态，�q�意
味着它可以由JVM调度�q�执行。这�q�不意味着�U�程��׃��立即�q�行。run()�Ҏ��可以产生必须
退出的标志来停止一个线�E��?br /> �W�二十四�Q�构造器Constructor是否可被override?
构造器Constructor不能被��承，因此不能重写Overriding�Q�但可以被重载Overloadi
ng�?br />
�W�二十五�Q�是否可以��承String�c?
String�c�L��final�c�L��不可以��ѝ�?br />
�W�二十六�Q�当一个线�E�进入一个对象的一个synchronized�Ҏ��后，其它�U�程是否可进
入此对象的其它方�?
不能�Q�一个对象的一个synchronized�Ҏ��只能�׃��个线�E�访问�?br />
�W�二十七�Q�try {}里有一个return语句�Q�那么紧跟在�q�个try后的finally {}里的cod
e会不会被执行�Q�什么时候被执行�Q�在return前还是后?
会执行，在return前执行�?br />

�W�二十八�Q�编�E�题: 用最有效率的�Ҏ��出2乘以8�{�於�?
有C背景的程序员特别喜欢问这�U�问题�?br />
2 << 3

�W�二十九�Q�两个对象值相�?x.equals(y) == true)�Q�但却可有不同的hash code�Q�这
句话对不�?
不对�Q�有相同的hash code�?br />
�W�三十，当一个对象被当作参数传递到一个方法后�Q�此�Ҏ��可改变这个对象的属性，
�q�可�q�回变化后的�l�果�Q�那么这里到底是��g��递还是引用传�?
是��g��递。Java �~�程语言只由��g��递参数。当一个对象实例作��Z��个参数被传递到�?br /> 法中�Ӟ��参数的值就是对该对象的引用。对象的内容可以在被调用的方法中改变�Q�但对象
的引用是永远不会改变的�?br />

�W�三十一�Q�swtich是否能作用在byte上，是否能作用在long上，是否能作用在String
�?
switch�Q�expr1�Q�中�Q�expr1是一个整数表辑ּ�。因此传递给 switch �?case 语句�?br /> 参数应该�?int�?short�?char 或�?byte。long,string 都不能作用于swtich�?br /> �W�三十二�Q�编�E�题: 写一个Singleton出来�?br /> Singleton模式主要作用是保证在Java应用�E�序中，一个类Class只有一个实例存在�?/p>
　　一般Singleton模式通常有几�U�种形式:
�W�一�U��Ş�? 定义一个类�Q�它的构造函��Cؓprivate的，它有一个static的private�?br /> 该类变量�Q�在�c�d��始化时实例话�Q�通过一个public的getInstance�Ҏ��获取对它的引�?�l?br /> 而调用其中的�Ҏ��?br /> public class Singleton {
private Singleton(){}
//在自己内部定义自�׃��个实例，是不是很奇怪？
//注意�q�是private 只供内部调用
private static Singleton instance = new Singleton();
//�q�里提供了一个供外部讉K��本class的静态方法，可以直接讉K��
public static Singleton getInstance() {
return instance;
}
}
�W�二�U��Ş�?
public class Singleton {
private static Singleton instance = null;
public static synchronized Singleton getInstance() {
//�q�个�Ҏ��比上面有所改进�Q�不用每�ơ都�q�行生成对象�Q�只是第一��?
//使用时生成实例，提高了效率！
if (instance==null)
instance�Q�new Singleton();
return instance; }
}
其他形式:
定义一个类�Q�它的构造函��Cؓprivate的，所有方法�ؓstatic的�?br /> 一般认为第一�U��Ş式要更加安全

矛_��@ 2009-08-09 18:09 发表评论

java中容易出现的十大异常分析

矛_��@ — Sat, 08 Aug 2009 01:04:00 GMT

【�{】JAVA常见十大异常
关键�? java异常
java 10大常见异常，出现的原因和解决�Ҏ��
作�ؓJAVA�E�序员，写代码难免出现bug�Q�我们来看看java 10大常见异�?

NO.1　java.lang.NullPointerException

�q�个异常大家肯定都经帔R��刎ͼ�异常的解释是 "�E�序遇上了空指针 "�Q�简单地说就是调用了未经初始化的对象或者是不存在的对象�Q�这个错误经常出现在创徏囄��Q�调用数�l�这些操作中�Q�比如图片未�l�初始化�Q�或者图片创建时的�\ 径错误等�{�。对数组操作中出现空指针�Q�很多情况下是一些刚开始学习编�E�的朋友常犯的错误，��x��数组的初始化和数�l�元素的初始化�؜淆�v来了。数�l�的初始化是 �Ҏ��l�分配需要的�I�间�Q�而初始化后的数组�Q�其中的元素�q�没有实例化�Q�依然是�I�的�Q�所以还需要对每个元素都进行初始化�Q�如果要调用的话�Q?

NO.2　java.lang.ClassNotFoundException

�q�个异常是很多原本在JB�{�开发环境中开发的�E�序员，把JB下的�E�序包放在WTk下编译经常出现的问题�Q�异常的解释�?"指定的类不存�? "�Q�这里主要考虑一下类的名�U�和路径是否正确卛_��Q�如果是在JB下做的程序包�Q�一般都是默认加上Package的，所以�{到WTK下后要注意把 Package的�\径加上�?

NO.3　java.lang.ArithmeticException

�q�个异常的解释是 "数学�q�算异常 "�Q�比如程序中出现了除以零�q�样的运��就会出�q�样的异常，对这�U�异常，大家��p��好好��查一下自��q��序中涉及到数学运��的地方�Q�公式是不是有不妥了�?

NO.4　java.lang.ArrayIndexOutOfBoundsException

�q�个异常�怿�很多朋友也经帔R��到过�Q�异常的解释�?"数组下标��界 "�Q�现在程序中大多都有�Ҏ��l�的操作�Q�因此在调用数组的时候一定要认真��查，看自��p��用的下标是不是超��Z��数组的范��_��一般来��_��昄��Q�即直接用常数当�? 标）调用不太�Ҏ��L��错，但隐式（即用变量表示下标�Q�调用就�l�常出错了，�q�有一�U�情况，是程序中定义的数�l�的长度是通过某些特定�Ҏ��军_��的，不是事先声明的，�q�个时候，最好先查看一下数�l�的length�Q�以免出现这个异常�?

NO.5　java.lang.IllegalArgumentException

�q�个异常的解释是 "�Ҏ��的参数错�? "�Q�很多J2ME的类库中的方法在一些情况下都会引发�q�样的错误，比如音量调节�Ҏ��中的音量参数如果写成负数��׃��出现�q�个异常�Q�再比如 g.setColor(int red,int green,int blue)�q�个�Ҏ��中的三个��|��如果有超�q�２�Q�５的也会出现这个异常，因此一旦发现这个异常，我们要做的，��是赶紧��L��查一下方法调用中的参��C��递是不是出现了错误�?

NO.6　java.lang.IllegalAccessException

�q�个异常的解释是 "没有讉K��权限 "�Q�当应用�E�序要调用一个类�Q�但当前的方法即没有对该�cȝ��讉K��权限便会出现�q�个异常。对�E�序中用了Package的情况下要注意这个异常�?

NO.7　java.lang.IncompatibleClassChangeError

不兼容的�c�d��化错误。当正在执行的方法所依赖的类定义发生了不兼容的改变时�Q�抛��异常。一般在修改了应用中的某些类的声明定义而没有对整个应用重新�~�译而直接运行的情况下，�Ҏ��引发该错误�?

NO.8　java.lang.InstantiationError

实例化错误。当一个应用试��N��过Java的new操作�W�构造一个抽象类或者接口时抛出该异�?

NO.9　java.lang.LinkageError

链接错误。该错误及其所有子�c�L��C�某个类依赖于另外一些类�Q�在该类�~�译之后�Q�被依赖的类改变了其�c�d��义而没有重新编译所有的�c�，�q�而引发错误的情况�?

NO.10　java.lang.StackOverflowError

堆栈溢出错误。当一个应用递归调用的层�ơ太��p��导致堆栈溢出时抛出该错误�?

矛_��@ 2009-08-08 09:04 发表评论

矛_��@ — Wed, 05 Aug 2009 02:32:00 GMT
�?009�q�的JavaOne大会上，Joshua Bloch和Neal Gafter又�ؓ我们带来�?道谜题，挺有意思的。大家不妨看看�?
摘自�Q?
Return of the Puzzlers: Schlock and Awe
Joshua Bloch, Google, Inc.; Neal Gafter, Microsoft
http://developers.sun.com/learning/javaoneonline/sessions/2009/pdf/TS-5186.pdf
1.Life's Persistent Questions

Java code

public class SimpleQuestion {

static boolean yesOrNo(String s) {
s = s.toLowerCase();
if (s.equals("yes") || s.equals("y") || s.equals("t")) {
s = "true";
}
return Boolean.getBoolean(s);
}

public static void main(String[] args) {
System.out.println(yesOrNo("true") + " " + yesOrNo("Yes"));
}
}

问题�Q�程序打��C��么？
如果熟悉Boolean.getBoolean�Q�）�q�个�Ҏ��的话�Q�应该不会出错。方法的功能参考文档�?

2.Instruments of Tortue

Java code

import java.util.Arrays;
import java.util.Collection;
import java.util.HashSet;

public class InstrumentedHashSet<E> extends HashSet<E> {
private int addCount = 0;
@Override
public boolean add(E e){
addCount++;
return super.add(e);
}

@Override
public boolean addAll(Collection extends E> c){
addCount += c.size();
return super.addAll(c);
}

public static void main(String[] args) {
InstrumentedHashSet<String> s = new InstrumentedHashSet<String>();
s.addAll(Arrays.asList("Accordion","Banjo","Kazoo"));
System.out.println(s.addCount);
}
}

问题�Q�打印结果是什么？

�q�个看第一遍可能会出错�Q�不�q�也��容易理解�?

3.Iterator Titillator

Java code

import java.util.Iterator;
import java.util.NoSuchElementException;

public abstract class AbstractIterator<T> implements Iterator<T> {

T next = nextElement();

public boolean hasNext() {
return next != null;
}

public T next() {
if (next == null) {
throw new NoSuchElementException();
}
T result = next;
next = nextElement();
return result;
}

public void remove() {
throw new UnsupportedOperationException();
}

protected abstract T nextElement();

private static Iterator<Character> test(final String s) {
return new AbstractIterator<Character>() {

private int cursor = 0;

protected Character nextElement() {
return cursor == s.length() ? null : s.charAt(cursor++);
}
};
}

public static void main(String[] args) {
for (Iterator<Character> i = test("OPS"); i.hasNext();) {
System.out.print(i.next());
}
}
}

问题�Q�输出结果是什么？

理解如何正确的设计Iterator�?

4.Search for the One

Java code

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class Searching {
public static void main(String[] args) {
String[] strings = { "0", "1", "2", "3", "4", "5"};

List<Integer> integers = new ArrayList<Integer>();
for(String s : strings){
integers.add(Integer.valueOf(s));
}

System.out.println(Collections.binarySearch(integers, 1,cmp));
}

static Comparator<Integer> cmp = new Comparator<Integer>(){
public int compare(Integer i,Integer j){
return i<j?-1:(i==j?0:1);
}
};
}

问题�Q�打印结果是什么？

如果看过《Java Puzzlers》这本书的话应该�Ҏ��发现问题�?

5.Cogito Ergo Sum

Java code

import java.util.LinkedHashMap;
import java.util.Map;

public enum RomanNumeral {

I(1), V(5), X(10), L(50), C(100), D(500), M(1000);
private static Map<Integer, RomanNumeral> map = new LinkedHashMap<Integer, RomanNumeral>();
public final int val;

RomanNumeral(int val) {
this.val = val;
storeInMap();
}

private void storeInMap() {
map.put(val, this);
}

public static RomanNumeral fromInt(int val) {
return map.get(val);
}

public static void main(String[] args) {
int sum = 0;
for (int i = 0; i < 1000; i++) {
if (fromInt(i) != null) {
sum += i;
}
}
System.out.println(sum);
}
}

问题�Q�打印结果是什么？

如果理解java加蝲�c�d��创徏对象的顺序的话这个问题容易理解�?

6.Thread Friendly

Java code

public class ThreadFriendly {
ThreadLocal<Value> threadLocalPart = new ThreadLocal<Value>();
class Value{
final int i;
Value(int i){
this.i = i;
}
}

ThreadFriendly setThreadVal(int i){
threadLocalPart.set(new Value(i));
return this;
}

int getThreadVal(){
return threadLocalPart.get().i;
}

public static void main(String[] args) {
int sum = 0;
for(int i = -500000;i<=500000;i++){
sum+= new ThreadFriendly().setThreadVal(i).getThreadVal();
}
System.out.println(sum);
}
}

问题�Q�打印结果是什么？

理解内部�c�d��ThreadLocal�?

7.When Words Collide

Java code

public class PrintWords {
public static void main(String[] args) {
System.out.println(
Words.FIRST + " " + Words.SECOND + " " + Words.THIRD
);
}
}

public class Words{
public static final String FIRST = "the";
public static final String SECOND = null;
public static final String THIRD = "set";
}

�~�译PrintWords.java文�g�?
修改Words.java文�g�?

Java code

public class Words{
public static final String FIRST = "physics";
public static final String SECOND = "chemistry";
public static final String THIRD = "biology";
}

问题�Q�再�ơ编译运行PrintWords.java�Q�打印结果是什么？

需要了解常量折叠现象，理解什么是帔R��?

矛_��@ 2009-08-05 10:32 发表评论

java io�pȝ��概述

矛_��@ — Thu, 30 Jul 2009 11:05:00 GMT
Java ��在处理上分为字�W�流和字节流。字�W�流处理的单元�ؓ 2 个字节的 Unicode 字符�Q�分别操作字�W�、字�W�数�l�或字符�Ԍ��而字节流处理单元�?1 个字节，操作字节和字节数�l��?
Java 内用 Unicode �~�码存储字符�Q�字�W�流处理�c�负责将外部的其他编码的字符��和 java �?Unicode 字符��之间的转换。而类 InputStreamReader �?OutputStreamWriter 处理字符��和字节��的转换。字�W�流�Q�一�ơ可以处理一个缓冲区�Q�一�ơ操作比字节��（一�ơ一个字节）效率高�?nbsp;

( 一 )以字节�ؓ导向�?stream------InputStream/OutputStream

InputStream �?OutputStream 是两�?abstact �c�，对于字节为导向的 stream 都扩展这两个鸡肋�Q�基�c?^_^ �Q?;

1�?InputStream

1.1

ByteArrayInputStream -- 把内存中的一个缓冲区作�ؓ InputStream 使用 .

construct---

(A)ByteArrayInputStream(byte[]) 创徏一个新字节数组输入��（ ByteArrayInputStream �Q�，它从指定字节数组中读取数据（使用 byte 作�ؓ其缓冲区数组�Q?

(B)---ByteArrayInputStream(byte[], int, int) 创徏一个新字节数组输入��，它从指定字节数组中读取数据�?

---mark:: 该字节数�l�未被复制�?

1.2

StringBufferInputStream -- 把一�?String 对象作�ؓ InputStream .

construct---

StringBufferInputStream(String) 据指定串创徏一个读取数据的输入��串�?

注释�Q�不推荐使用 StringBufferInputStream �Ҏ��?此类不能��字�W�正��的转换为字节�?

�?JDK 1.1 版中的类��|��从一个串创徏一个流的最��x��法是采用 StringReader �c�R�?

1.3

FileInputStream -- 把一个文件作�?InputStream �Q�实现对文�g的读取操�?

construct---

(A)FileInputStream(File name) 创徏一个输入文件流�Q�从指定�?File 对象��d��数据�?

(B)FileInputStream(FileDescriptor) 创徏一个输入文件流�Q�从指定的文件描�q�器��d��数据�?

(C)-FileInputStream(String name) 创徏一个输入文件流�Q�从指定名称的文件读取数据�?

method ---- read() 从当前输入流中读取一字节数据�?

read(byte[]) ��当前输入流�?b.length 个字节数据读��C��个字节数�l�中�?

read(byte[], int, int) ��输入流�?len 个字节数据读入一个字节数�l�中�?

1.4

PipedInputStream �Q�实��C�� pipe 的概念，主要在线�E�中使用 . ��道输入��是指一个通讯��道的接收端�?

一个线�E�通过��道输出��发送数据，而另一个线�E�通过��道输入��读取数据，�q�样可实��C��个线�E�间的通讯�?

construct---

PipedInputStream() 创徏一个管道输入流�Q�它�q�未与一个管道输出流�q�接�?

PipedInputStream(PipedOutputStream) 创徏一个管道输入流 , 它已�q�接��C��个管道输出流�?

1.5

SequenceInputStream �Q�把多个 InputStream 合�ƈ��Z��?InputStream . “序列输入��?#8221;�c�d��许应用程序把几个输入��连�l�地合�ƈ��h��Q?

�q�且使它们像单个输入��一样出现。每个输入流依次被读取，直到到达该流的末��?

然后“序列输入��?#8221;�c�d��闭这个流�q�自动地切换��C��一个输入流�?

construct---

SequenceInputStream(Enumeration) 创徏一个新的序列输入流�Q��ƈ用指定的输入��的枚�D值初始化它�?

SequenceInputStream(InputStream, InputStream) 创徏一个新的序列输入流�Q�初始化为首�?读输入流 s1, 然后读输入流 s2 �?

2�?OutputSteam

2.1

ByteArrayOutputStream �Q?把信息存入内存中的一个缓冲区�?. 该类实现一个以字节数组形式写入数据的输出流�?

当数据写入缓冲区�Ӟ��它自动扩大。用 toByteArray() �?toString() 能检索数据�?

constructor

(A)--- ByteArrayOutputStream() 创徏一个新的字节数�l�输出流�?

(B)--- ByteArrayOutputStream() 创徏一个新的字节数�l�输出流�?

(C)--- ByteArrayOutputStream(int) 创徏一个新的字节数�l�输出流�Q��ƈ带有指定大小字节的缓冲区定w��?

toString(String) �Ҏ��指定字符�~�码��缓冲区内容转换为字�W�串�Q��ƈ��字节�{换�ؓ字符�?

write(byte[], int, int) ��指定字节数�l�中从偏�U�量 off 开始的 len 个字节写入该字节数组输出��?

write(int) ��指定字节写入该字节数组输出��?

writeTo(OutputStream) �?out.write(buf, 0, count) 调用输出��的写方法将该字节数�l�输出流的全部内容写入指定的输出��参数�?

2.2

FileOutputStream: 文�g输出��是�?File �?FileDescriptor 输出数据的一个输出流�?

constructor

(A)FileOutputStream(File name) 创徏一个文件输出流�Q�向指定�?File 对象输出数据�?

(B)FileOutputStream(FileDescriptor) 创徏一个文件输出流�Q�向指定的文件描�q�器输出数据�?

(C)FileOutputStream(String name) 创徏一个文件输出流�Q�向指定名称的文件输出数据�?

(D)FileOutputStream(String, boolean) 用指定系�l�的文�g名，创徏一个输出文件�?

2.3

PipedOutputStream: ��道输出��是指一个通讯��道的发送端�?一个线�E�通过��道输出��发送数据，

而另一个线�E�通过��道输入��读取数据，�q�样可实��C��个线�E�间的通讯�?

constructor

(A)PipedOutputStream() 创徏一个管道输出流�Q�它�q�未与一个管道输入流�q�接�?

(B)PipedOutputStream(PipedInputStream) 创徏一个管道输出流�Q�它已连接到一个管道输入流�?

( �?)以字�W��ؓ导向�?stream Reader/Writer

�?Unicode 字符为导向的 stream �Q�表�C�Z�� Unicode 字符为单位从 stream 中读取或往 stream 中写入信息�?

Reader/Writer �?abstact �c?

�?Unicode 字符为导向的 stream 包括下面几种�c�d��Q?

1. Reader

1.1

CharArrayReader �Q�与 ByteArrayInputStream 对应此类实现一个可用作字符输入��的字符�~�冲�?

constructor

CharArrayReader(char[]) 用指定字�W�数�l�创��Z��?CharArrayReader �?

CharArrayReader(char[], int, int) 用指定字�W�数�l�创��Z��?CharArrayReader

1.2

StringReader �Q?�?StringBufferInputStream 对应其源��Z��个字�W�串的字�W�流�?

StringReader(String) 创徏一新的串读取者�?/p>
1.3

FileReader �Q?�?FileInputStream 对应

1.4

PipedReader �Q�与 PipedInputStream 对应

2. Writer

2.1 CharArrayWrite �Q?�?ByteArrayOutputStream 对应

2.2   StringWrite �Q�无与之对应的以字节为导向的 stream

2.3 FileWrite �Q?�?FileOutputStream 对应

2.4 PipedWrite �Q�与 PipedOutputStream 对应

3、两�U�不同导向的 stream 之间的�{�?nbsp;

3.1

InputStreamReader �?OutputStreamReader �Q?

把一个以字节为导向的 stream 转换成一个以字符为导向的 stream �?

InputStreamReader �c�L��从字节流到字�W�流的桥梁：它读入字节，�q�根据指定的�~�码方式�Q�将之�{换�ؓ字符��?

使用的编码方式可能由名称指定�Q�或�q�_��可接受的�~�省�~�码方式�?

InputStreamReader �?read() �Ҏ��之一的每�ơ调用，可能促��从基本字节输入流中读取一个或多个字节�?

��Z��辑ֈ�更高效率�Q�考虑�?BufferedReader ��装 InputStreamReader �Q?

BufferedReader in = new BufferedReader(new InputStreamReader(System.in));

例如�Q?// 实现从键盘输入一个整�?

view plain copy to clipboard print ?

String s = null;

InputStreamReader re = new InputStreamReader(System.in);

              BufferedReader br = new BufferedReader(re);

              try {

              s = br.readLine();

              System.out.println("s= " + Integer.parseInt(s));

              br.close();

              }

              catch (IOException e)

              {

              e.printStackTrace();

              }

              catch (NumberFormatException e)// 当应用程序试囑ְ�字符串�{换成一�U�数值类型，但该字符串不能�{换�ؓ适当格式�Ӟ��抛出该异常�?

              {

              System.out.println(" 输入的不是数�?nbsp;");

              }

String s = null; InputStreamReader re = new InputStreamReader(System.in); BufferedReader br = new BufferedReader(re); try { s = br.readLine(); System.out.println("s= " + Integer.parseInt(s)); br.close(); } catch (IOException e) { e.printStackTrace(); } catch (NumberFormatException e)// 当应用程序试囑ְ�字符串�{换成一�U�数值类型，但该字符串不能�{换�ؓ适当格式�Ӟ��抛出该异常�? { System.out.println(" 输入的不是数�?"); }

InputStreamReader(InputStream) 用缺省的字符�~�码方式�Q�创��Z��?InputStreamReader �?

InputStreamReader(InputStream, String) 用已命名的字�W�编码方式，创徏一�?InputStreamReader �?

OutputStreamWriter ��多个字�W�写入到一个输出流�Q�根据指定的字符�~�码��多个字�W��{换�ؓ字节�?

每个 OutputStreamWriter 合�ƈ它自��q�� CharToByteConverter, 因而是从字�W�流到字节流的桥梁�?/p>

�Q�三�Q�Java IO 的一般��用原�?�Q?nbsp;

一、按数据来源�Q�去向）分类�Q?

1 、是文�g�Q?FileInputStream, FileOutputStream, ( 字节��?)FileReader, FileWriter( 字符 )

2 、是 byte[] �Q?ByteArrayInputStream, ByteArrayOutputStream( 字节��?)

3 、是 Char[]: CharArrayReader, CharArrayWriter( 字符��?)

4 、是 String: StringBufferInputStream, StringBufferOuputStream ( 字节��?)StringReader, StringWriter( 字符��?)

5 、网�l�数据流�Q?InputStream, OutputStream,( 字节��?) Reader, Writer( 字符��?)

二、按是否格式化输出分�Q?

1 、要格式化输出： PrintStream, PrintWriter

三、按是否要缓冲分�Q?

1 、要�~�冲�Q?BufferedInputStream, BufferedOutputStream,( 字节��?) BufferedReader, BufferedWriter( 字符��?)

四、按数据格式分：

1 、二�q�制格式�Q�只要不能确定是�U�文本的�Q?: InputStream, OutputStream 及其所有带 Stream �l�束的子�c?

2 、纯文本格式�Q�含�U�英文与汉字或其他编码方式）�Q?Reader, Writer 及其所有带 Reader, Writer 的子�c?

五、按输入输出分：

1 、输入： Reader, InputStream �c�d��的子�c?

2 、输出： Writer, OutputStream �c�d��的子�c?

六、特�D�需要：

1 、从 Stream �?Reader,Writer 的�{换类�Q?InputStreamReader, OutputStreamWriter

2 、对象输入输出： ObjectInputStream, ObjectOutputStream

3 、进�E�间通信�Q?PipeInputStream, PipeOutputStream, PipeReader, PipeWriter

4 、合�q�输入： SequenceInputStream

5 、更�Ҏ��的需要： PushbackInputStream, PushbackReader, LineNumberInputStream, LineNumberReader

军_��使用哪个�c�M��及它的构造进�E�的一般准则如下（不考虑�Ҏ��需要）�Q?

首先�Q�考虑最原始的数据格式是什么：原则�?

�W�二�Q�是输入�q�是输出�Q�原则五

�W�三�Q�是否需要�{换流�Q�原则六�W?1 �?

�W�四�Q�数据来源（��d��Q�是什么：原则一

�W�五�Q�是否要�~�冲�Q�原则三 �Q�特别注明：一定要注意的是 readLine() 是否有定义，有什么比 read, write 更特�D�的输入或输出方法）

�W�六�Q�是否要格式化输出：原则�?

出处�Q�http://blog.csdn.net/sqw131/archive/2009/03/25/4025047.aspx

矛_��@ 2009-07-30 19:05 发表评论

java IO中的Decorator模式

矛_��@ — Tue, 28 Jul 2009 09:54:00 GMT

http://hi.baidu.com/xiaowei81/blog/item/28f9ff541ed7f51c3a2935d7.html

矛_��@ 2009-07-28 17:54 发表评论

java中的io操作�Q�三�Q�流的��用）

矛_��@ — Sat, 25 Jul 2009 12:24:00 GMT
1: 分割�W�输�?br />      可以��定自己的分割符�Q?#8220;|”�Q?#8220;�Q?#8221;�Q�等�{�，
     如果在要保留的字�W�串中存在一个分割符�Q?br /> 2�Q?/span>字符串记号处理器
    当读取一行输入时�Q�会得到很长的一个字�W�串�Q�有旉��要将它分割�ؓ独立的字�W�串�Q�这时就需要找出其中的分割�W�且��它分离成单独的片段�Q?java.util中的StringToKenizer�c�d��是�ؓ�q�个目的设计的，它提供了一个很��单的�Ҏ��来分隔带分隔�W�文本的字符�Ԍ��思�\是：��字�W�串记号处理器对象附在字�W�串上，当构造字�W�串记号处理器对象时�Q�要指定哪些字符是分割符�Q?eg:
                     StringTokenizer tokenizer = new StringTokenizer(line,"|");
也可在在字符串中指定多个分割�W�， eg:
                     StringTokenizer tokenizer = new StringTokenizer(line,"|,:");
�q�就意味着字符串中的�Q意字�W�都能做为分割符出现。如果不指定分割�W�，则默认�ؓ"\t\n\r"

一旦构造好了一个字�W�串记号处理器，��可以��用它的方法从字符串中快速找��P��nextToken�Ҏ��可以�q�回下一个未读记��P��如果从在多个可用的记��P��hasMoreTokens �Ҏ��会返回true�Q?可以用下面的循环处理所有的记号�Q?br />                    While(tokenizer.hasMoreTokens())
                   {
                      String token = tokenizer.nextToken();
                                //....process token
                    }

矛_��@ 2009-07-25 20:24 发表评论

java中的io 操作(—：�cȝ��框架)

矛_��@ — Sat, 25 Jul 2009 12:04:00 GMT
最�l�学习了java io包中的类�Q�对io 操作熟悉了点�Q�写点东西整理一下自��q��思�\�?br />
首先回顾一下这些类的框�Ӟ��

矛_��@ 2009-07-25 20:04 发表评论

矛_��@ — Thu, 23 Jul 2009 11:25:00 GMT
在对象传输的情况�?有些域是"瞬时�?,也就是说只与当前�q�程环境相关,��Z��q�个�q�程��没有意义了,�q�样的域�?本地化的",没有序列化的价�?标�ؓ瞬时态的.

Java 的serialization提供了一�U�持久化对象实例的机制。当持久化对象时�Q�可能有一个特�D�的对象数据成员�Q�我们不想用serialization�? 制来保存它。�ؓ了在一个特定对象的一个域上关闭serialization�Q�可以在�q�个域前加上关键字transient�?/p>

transient是Java语言的关键字�Q�用来表�C�Z��个域不是该对象串行化的一部分。当一个对象被串行化的时候，transient型变量的��g��包括在串行化的表�C�Z��Q�然而非transient型的变量是被包括�q�去的�?/p>
首先�Q�让我们看一些Java serialization的代码：
public class LoggingInfo implements java.io.Serializable
{
    private Date loggingDate = new Date();
    private String uid;
    private transient String pwd;

    LoggingInfo(String user, String password)
    {
        uid = user;
        pwd = password;
    }
    public String toString()
    {
        String password=null;
        if(pwd == null)
        {
        password = "NOT SET";
        }
        else
        {
            password = pwd;
        }
        return "logon info: \n   " + "user: " + uid +
            "\n   logging date : " + loggingDate.toString() +
            "\n   password: " + password;
    }
}

现在我们创徏一个这个类的实例，�q�且串行�?serialize)�?,然后��这个串行化对象写入��盘�?br />
LoggingInfo logInfo = new LoggingInfo("MIKE", "MECHANICS");
System.out.println(logInfo.toString());
try
{
    ObjectOutputStream o = new ObjectOutputStream(new FileOutputStream("logInfo.out"));
    o.writeObject(logInfo);
    o.close();
}
catch(Exception e) {//deal with exception}

To read the object back, we can write

try
{
    ObjectInputStream in =new ObjectInputStream(new FileInputStream("logInfo.out"));
    LoggingInfo logInfo = (LoggingInfo)in.readObject();
    System.out.println(logInfo.toString());
}
catch(Exception e) {//deal with exception}

如果我们�q�行�q�段代码�Q�我们会注意��C��盘中读�?read——back (de-serializing))的对象打印password�?NOT SET"。这是当我们定义pwd域�ؓtransient�Ӟ��所期望的正��结果�?br /> 现在�Q�让我们来看一下粗心对待transient域可能引��L��潜在问题。假设我们修改了�c�d��义，提供�l�transient域一个默认��|��
代码如下�Q?br />
public class GuestLoggingInfo implements java.io.Serializable
{
    private Date loggingDate = new Date();
    private String uid;
    private transient String pwd;

    GuestLoggingInfo()
    {
        uid = "guest";
        pwd = "guest";
    }
    public String toString()
    {
        //same as above
     }
}
�? 在，如果我们串行化GuestLoggingInfo的一个实例，��它写入��盘�Q��ƈ且再��它从磁盘中��d��Q�我们仍然看到读回的对象打印password �?"NOT SET"。当从磁盘中��d��某个�cȝ��实例�Ӟ��实际上�ƈ不会执行�q�个�cȝ��构造函敎ͼ�而是载入了一个该�c�d��象的持久化状态，�q�将�q�个状态赋值给该类的另一个对象�?/p>

摘自�Q?a >http://www.devx.com/tips/Tip/13726

矛_��@ 2009-07-23 19:25 发表评论

矛_��@ — Wed, 22 Jul 2009 14:11:00 GMT
JNI�?/font>Java Native Interface�?�~�写。从Java 1.1开始，Java Native Interface (JNI)标准成�ؓjava�q�_��的一部分�Q�它允许Java代码和其他语�a�写的代码�q�行交互。JNI一开始是��Z��本地已编译语�a��Q�尤其是C和C++而设�? 的，但是它�ƈ不妨��你使用其他语言�Q�只要调用约定受支持��可以了�?
      使用java与本地已�~�译的代码交互，通常会��失��^台可�U�L��性。但是，有些情况下这样做是可以接受的�Q�甚��x��必须的，比如�Q��用一些旧的库�Q�与��g、操作系�l�进行交互，或者�ؓ了提�?span style="text-decoration: underline;">�E�序的性能。JNI标准臛_��保证本地代码能工作在��M��Java 虚拟机实��C��?/font>

JNI�Q�Java Native Interface�Q�的书写步骤

      ·�~�写带有native声明的方法的java�c?br />       ·使用javac命��o�~�译所�~�写的java�c?br />       ·使用javah ?jni java�c�d��生成扩展名�ؓh的头文�g
      ·使用C/C++�Q�或者其他编�E�想语言�Q�实现本地方�?br />       ·��C/C++�~�写的文件生成动态连接库

1) �~�写java�E�序�Q?br /> �q�里以HelloWorld��Z��?br /> 代码1�Q?br /> class HelloWorld {
public native void displayHelloWorld();

static {
System.loadLibrary("hello");
}

public static void main(String[] args) {
new HelloWorld().displayHelloWorld();
}
}
声明native�Ҏ��Q�如果你惛_��一个方法做��Z��个本地方法的话，那么你就必须声明�Ҏ��法�ؓnative的，�q�且不能实现。其中方法的参数和返回值在后面讲述�?br /> Load 动态库�Q�System.loadLibrary("hello");加蝲动态库�Q�我们可以这��L��解：我们的方法displayHelloWorld()�? 有实玎ͼ�但是我们在下面就直接使用了，所以必��d��使用之前对它�q�行初始化）�q�里一般是以static块进行加载的。同旉��要注意的�? System.loadLibrary();的参�?#8220;hello”是动态库的名字�?br /> main()�Ҏ��
2) �~�译没有什么好说的�?br /> javac HelloWorld.java
3) 生成扩展名�ؓh的头文�g
javah ?jni HelloWorld
头文件的内容�Q?br /> /* DO NOT EDIT THIS FILE - it is machine generated */
#include
/* Header for class HelloWorld */

#ifndef _Included_HelloWorld
#define _Included_HelloWorld
#ifdef __cplusplus
extern "C" {
#endif
/*
* Class: HelloWorld
* Method: displayHelloWorld
* Signature: ()V
*/
JNIEXPORT void JNICALL Java_HelloWorld_displayHelloWorld
(JNIEnv *, jobject);

#ifdef __cplusplus
}
#endif
#endif
�Q�这里我们可以这��L��解：�q�个h文�g相当于我们在java里面的接口，�q�里声明了一个Java_HelloWorld_displayHelloWorld (JNIEnv *, jobject);�Ҏ��Q�然后在我们的本地方法里面实现这个方法，也就是说我们在编写C/C++�E�序的时候所使用的方法名必须和这里的一��_��?br /> 4) �~�写本地�Ҏ��
实现和由javah命��o生成的头文�g里面声明的方法名相同的方法�?br /> 代码2�Q?br /> 1 #include
2 #include "HelloWorld.h"
3 #include

4 JNIEXPORT void JNICALL Java_HelloWorld_displayHelloWorld(JNIEnv *env, jobject obj)
{
printf("Hello world!\n");
return;
}
�? 意代�?中的�W?行，需要将jni.h�Q�该文�g可以�?JAVA_HOME%/include文�g夹下面找刎ͼ�文�g引入�Q�因为在�E�序中的JNIEnv�? jobject�{�类型都是在该头文�g中定义的�Q�另外在�W?行需要将HelloWorld.h头文件引入（我是�q�么理解的：相当于我们在�~�写java�E�序�? 时候，实现一个接口的话需要声明才可以�Q�这里就是将HelloWorld.h头文仉��面声明的�Ҏ��加以实现。当然不一定是�q�样�Q�。然后保存�ؓ HelloWorldImpl.c��?ok了�?br /> 5) 生成动态库
�q�里以在Windows中�ؓ例，需要生成dll文�g。在保存HelloWorldImpl.c文�g夹下面，使用VC的编译器cl成�?br /> cl -I%java_home%\include -I%java_home%\include\win32 -LD HelloWorldImp.c -Fehello.dll
�? 意：生成的dll文�g名在选项-Fe后面配置�Q�这里是hello�Q�因为在HelloWorld.java文�g中我们loadLibary的时候��用的名字是hello。当然这里修改之后那里也需要修攏V��另外需要将-I%java_home%\include -I%java_home%\include\win32参数加上�Q�因为在�W�四步里面编写本地方法的时候引入了jni.h文�g�?br /> 6) �q�行�E�序
java HelloWorld��ok�?/font>

JNI�Q�Java Native Interface�Q�调用中考虑的问�?/strong>

      在首�ơ��用JNI的时候有些疑问，后来在��用中一一解决�Q�下面就是这些问题的备忘�Q?/font>

      1�?java和c是如何互通的�Q?br />       其实不能互通的原因主要是数据类型的问题�Q�jni解决了这个问题，例如那个c文�g中的jstring数据�c�d��是java传入的String对象�Q�经�q�jni函数的�{化就能成为c的char*�?br />       对应数据�c�d��关系如下表：
        Java �c�d�� 本地c�c�d�� 说明
        boolean jboolean 无符��P��8 �?br />         byte jbyte 无符��P��8 �?br />         char jchar 无符��P��16 �?br />         short jshort 有符��P��16 �?br />         int jint 有符��P��32 �?br />         long jlong 有符��P��64 �?br />         float jfloat 32 �?br />         double jdouble 64 �?br />         void void N/A

      2. 如何��java传入的String参数转换为c的char*�Q�然后��?
java 传入的String参数�Q�在c文�g中被jni转换为jstring的数据类型，在c文�g中声明char* test�Q�然后test = (char*)(*env)->GetStringUTFChars(env, jstring, NULL);注意�Q�test使用完后�Q�通知虚拟机��^台相关代码无需再访问：(*env)->ReleaseStringUTFChars(env, jstring, test);

      3. ��c中获取的一个char*的buffer传递给java�Q?br /> �q�个char*如果是一般的字符串的话，作�ؓstring传回��d��可以了。如果是含有’\0’的buffer�Q�最好作为bytearray传出�Q�因为可以制定copy的length�Q�如果copy到string�Q�可能到’\0’��截断了�?br />       有两�U�方式传递得到的数据�Q?br />       一�U�是在jni中直接new一个byte数组�Q�然后调用函�?*env)->SetByteArrayRegion(env, bytearray, 0, len, buffer);��buffer的值copy到bytearray中，函数直接return bytearray��可以了�?br />       一�U�是return错误��P��数据作�ؓ参数传出�Q�但是java的基本数据类型是传��|��对象是传递的引用�Q�所以将�q�个需要传出的byte数组用某个类包一下，如下�Q?br /> class RetObj
{
public byte[] bytearray;
}
�q�个对象作�ؓ函数的参数retobj传出�Q�通过如下函数��retobj中的byte数组赋��g��于传出。代码如下：
jclass cls;
jfieldID fid;
jbyteArray bytearray;
bytearray = (*env)->NewByteArray(env,len);
(*env)->SetByteArrayRegion(env, bytearray, 0, len, buffer);
cls = (*env)->GetObjectClass(env, retobj);
fid = (*env)->GetFieldID(env, cls, "retbytes", "[B"]);
(*env)->SetObjectField(env, retobj, fid, bytearray);

      4. 不知道占用多��空间的buffer�Q�如何传递出��d��Q?br />       在jni的c文�g中new出空��_��传递出厅R��java的数据不初始化，指向传递出�ȝ��I�间卛_��?/font>

转自�Q�http://blog.csdn.net/lion_6/archive/2008/03/17/2190442.aspx

矛_��@ 2009-07-22 22:11 发表评论

矛_��@ — Sun, 05 Jul 2009 13:52:00 GMT

在数学运��当中经�怼�涉及到判断两个数是否相等的情�?br /> 对于整数很好处理 A==B�q�样的一个语句就可以解决全部的问�?br /> 但是对于��点数是不同�?br />
首先�Q��Q�Ҏ��在计��机当中的二�q�制表达方式��决定了大多数��Q�Ҏ��都是无法�_��的表辄��
现在的计��机大部分都是数字计��机�Q�不是模拟机�Q�数字机的离散化的数据表�C�方法自然无法精��表辑֤�部分的数据量的�?br />
其次计算机��Q�Ҏ��的精度在单精度float�c�d��下，只有7位，在进行��Q点运��的时候，�q�个�_�ֺ�往往会导致运��的�l�果和实际期望的�l�果之间有误�?br />
因�ؓ前两个原因，我们很难�?A==B来判定两个��Q�Ҏ��是否相同

很自�Ӟ��我们可以惛_�� fabs(A-B) < epsilon �q�样的一�U�判别方�?br /> 但是�q�种判别�Ҏ��E�_��吗？
它也不稳妥�?br />
首先�Q?epsilon是一个绝对的数据�Q�也��是误差分析当中说说的绝对误�?br /> 使用一个固定的数��|��对于float�c�d��可以表达的整个数域来说是不可以的
比如epsilon取��gؓ0.0001�Q�而a和b的数值大��也�?.0001附近的，那么昄��不合�?br /> 另外对于a和b大小�?0000�q�样的数据的时候，它也不合适，因�ؓ10000�?0001也可以认为是相等的呢
适合它的情况只是a或者b�?或�?附近的时�?br />
既然�l�对误差不可以，那么自然的我们就会想��C��相对误差
bool IsEqual(float a, float b, float relError ) {
       return ( fabs ( (a-b)/a ) < relError ) ? true : false;
}
�q�样写还不完善，因�ؓ是拿固定的第一个参数做比较的，那么在调�?br /> IsEqual(a, b, relError ) �?IsEqual(b, a, relError ) 的时候，可能得到不同的结�?br /> 同时如果�W�一个参数是0的话�Q�就有可能是�?溢出
�q�个可以攚w�?br /> 把除数选取为a和b当中�l�对数��D��大的卛_��
bool IsEqual(float a, float b, relError )
{
      if (fabs(a) relError ) ? true : false;
      return (fabs( (a-b)/b) > relError ) ? true : false;
};

使用相对误差��很完善吗？
也不是，在某些特�D�情况下�Q?相对误差也不能代表全�?br /> 比如在判断空间三�Ҏ��否共�U�的时候，使用判断点到另外两个点�Ş成的�U�段的距��ȝ��Ҏ��的时�?br /> 只用相对误差是不够的�Q�应为线�D�距��d��能很�D�，也可能很长，点到�U�段的距��，以及�U�段的长度做�l�合比较的时候，需要相对误差和�l�对误差�l�合的方式才可以
相对完整的比较算法应该如下：
bool IsEqual(float a, float b, float absError, float relError )
{
         if (a==b) return true;
        if (fabs(a-b)         if (fabs(a>b) return (fabs((a-b)/a>relError ) ? true : false;
        return (fabs((a-b)/b>relError ) ? true : false;
}
�q�样才相对完�?br />
�q�仅仅是��点��C��间最初��的比较方�?br /> 高��的方法看 ��点数比较（二） �q�个文章 —�?如何把两个��Q�Ҏ��之间的比较�{化成��Z��个整��C��间的比较�?br /> -------------------------------------

��点数的内存�l�构

�Ҏ��IEEE的标准，��点数的定义如下

�W�号�?/font> 指数�?/font> ��数部分指数偏移�?/font>

单精度��Q�Ҏ�� 1 位[31] 8�?[30-23] 23�?[22-00] 127

双精度��Q�Ҏ�� 1 位[63] 11 位[62-52] 52 位[51-00] 1023

我们以单�_�ֺ��点数来说明�Q?br /> �W�号位，表述��点数的正或者负
指数实际也有正负的，但是没有单独的符号位�Q�而是采用了一个偏�U�L��表示
在计��机的世界里�Q�进位都是二�q�制的，指数表示的也�?的N�ơ幂
�q�个数据格式当中的，指数�?位，可表辄��范围�?�?55
而对应的实际的指数是�Q?27刎ͼ�128
�q�里�Ҏ��说明�Q�－127和＋128�q�两个数据在IEEE当中是保留的用作多种用途的
�Q?27表示的数字是0
128和其他位数组合表�C�多�U�意义，最典型的就是NAN状�?br />
��数部分�Q��ƈ不是一个��Q�Ҏ��的实际的��数
实际的小数在�q�个��数前面�q�保留了一�?
拿��Q�Ҏ��1.0来说
�W�号位是0�Q?实际指数�?�Q�对应这里的指数��是127了，也就�?x7f
而小数部分就�?.0了， 1是暗含的不存储，实际的小数部分就�?�?br /> 因此�l�合��h��的数据就是，0x3f80000

可以用一个类来表�C�：
class FloatType
{
public:
      union {
         DWORD m_dwInt;
         float          m_fFloat;
       struct {

        int    m_nFra: 23;

          int    m_nExp : 8;

          bool m_bSign : 1;

      };
};

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

参考IEEE的��Q�Ҏ��格式说明
对于0�?范围内的��点数是可以压羃�?br />
昄��?�?的范围内�Q�一个单�_�ֺ�的��Q�Ҏ��Q�指数和�W�号位占�?个bit
而这9个bit是可以不用的�Q�把它去除，只保留小数部分的23bit��可以达到压�~�的目的
可以把一个��Q�Ҏ��?2bit�Q?字节压羃�?3bit�Q?字节的范围内

�q�也是在3dmax�{�一些工兯��Y件当中对��点数进行压�~�存储的�Ҏ��?br /> 比如�Q�在单位化的法向量当中，每个��点数都�?�Q?范围之间的数�?br /> 正常情况下表�C�Z��l�空间当中的单位化法向量��需�?2个字�?br /> 而经�q�这个压�~�处理，只需�?个字�?/div>
-----------------------------

在写了上��?��点数的比较以及 ��点数内存结�?两篇文章�?br /> 对于��点数的比较有新的想�?br />
我们先看正数的情�?br /> �Ҏ��IEEE的内存结构，指数在高位，��数在低�?br /> ��点数大的对应的把其内存�l�构按照整数来理解进行比较的时候，情况也是成立�?br /> 因此在这里如果把他们�q�行比较的话�Q�作为整数运��效率会非常的高�Q�比�?br /> float f1 = 1.23;
float f2 = 1.24
f1 > f2 成立
(int&)f1 > (int&)f2 也是成立�?br />
而且�Q�仔�l�研�I�IEEE的��Q点结构，可以发现在《��Q�Ҏ��比较》当中提到的��点数精度的问题——不是所有的��点数都可以�_��的表�?br /> 可以�_��表达的��Q�Ҏ��实际上是有限的，��是那些IEEE的各�U�情�늚�枚�D�?2^32个。不能表辄��占据了大多数

IEEE�?2位的情况下，��数�?3位的�Q�暗含了�W�一个位数是1�Q?br /> 对于可以�_��表达的��Q�Ҏ��来说�Q�如果我们把�q?3位当作整数来理解�Q?它加1�Q�就意味着可以扑ֈ�比当前对应��Q�Ҏ��大的最��的��点��C��
反之�Q�我们把两个��点敎ͼ�对应的整数做差��D��，得到的整数表明的是两个��Q�Ҏ��之间有多��个实际可以表达的��Q�Ҏ��Q�对应的指数相同的情况下很好理解�Q�指��C��同的时候，也是同样有效的）

�q�样�Q�对于两个正的��Q�Ҏ��Q�他们的大小比较��可以用 (int&)f1 - (int&)f2 来进行比较了
差值的�l�果实际上就应该是相对误差了
�q�个相对误差�Q�不�{�同于普遍意义上的相对误�?br /> 它所表达的是�Q�两个��Q�Ҏ��之间可能�q�有多少个可以精��表辄��点�?br /> �q�样通过指定�q�个阈值来控制两个��点数的比较��更有效�?br /> 对于两个正的��点�?br /> bool IsEqual(float f1, float f2, int absDelta)
{
     if ( abs ( (int&)f1 - (int&)f2 ) < absDelta ) return true;
}
�q�里用abs而不是fabs�q�在asm上面的运��差距也是很大的�?br />
对于两个负数�q�行比较的情况也是相同的
只不�q�负数内存对应的整数�?�Q�相应的扑ֈ�的是更小的负数而已

但是负数和整��C��间现在还不能�q�行直接的比较，因�ؓ�Ҏ��IEEE的内存结�?br /> 正数和负数是不同的，对应的整��C��能连�l?br /> 正的最��的数就�?了，对应的整��C��?x00000000
负的最��的数就是－0�Q�对应的整数则是0x 80000000
不用奇怪－0
在IEEE的表辑ֽ�中是有两�?的，一个是 +0 一个是-0

有趣的是�Q�按�?f1 == f2 的判�?+0�?0是相�{�的

通过�Ҏ��我们可以发现�Q?
+0 和正的��Q�Ҏ��可以按照转换成�ؓ整数的方式直接进行比�?br /> -0 和负的��Q�Ҏ��可以按照转换成�ؓ整数的方式直接进行比�?br />
如果我们能够把他们连接�v来，整个整数方式的直接比较就完备�?br /> �Ҏ��一下负数的�l�构�Q?可以扑ֈ�一个简单的办法了：
        把负数内存对应的整数减去 -0 �Q�他们就�q�箋�?br /> 而且更好的结果是�Q�所有的负数�l�过�q�次减法后，对应的整��C��都是负数�?br /> �q�样整个整数比较��变得连�l�了�Q�而且在整个��Q�Ҏ��范围内都是有效的�?br />
最后的比较��法��是�Q?br /> // 函数:   bool IsEqual(float f1, float f2, int absDelta)
// 功能�Q�把比较两个��点数是否近似相�?br /> // 输入�Q�f1, f2参与比较的两个��Q�Ҏ��
//               absDelta 两个��点��C��间允许有多少个其他可以精��表辄��点数存在，相当于相对误�?br /> // 输出:   true�Q�两个��Q�Ҏ��q�行相等�Q?false 两个��点��C��{?br /> // 注意�Q�仅仅适合IEEE 32位��Q�Ҏ��l�构
bool IsEqual(float f1, float f2, int absDelta)
{
       int i1, i2;
       i1 = ( f1>0) ? ((int&)f1) : ( (int&) f1 - 0x80000000 );
       i2 = (f2>0) ? ((int&)f2) : ( (int&) f2 - 0x80000000 );
       return   ((abs(i1-i2)) }

矛_��@ 2009-07-05 21:52 发表评论

矛_��@ — Wed, 01 Jul 2009 09:43:00 GMT
public static int byte2int(byte[] res)
{
     int firstByte = (0x000000FF & ((int)res[0]));
     int secondByte = (0x000000FF & ((int)res[1]));
     int ToUnsignedInt = ((int)( firstByte << 8 |secondByte)) & 0xFFFFFFFF;

     return ToUnsignedInt;
}

矛_��@ 2009-07-01 17:43 发表评论

矛_��@ — Mon, 29 Jun 2009 10:41:00 GMT

Java 语言的一个优点就是取消了指针的概念，但也��D��了许多程序员在编�E�中常常忽略了对象与引用的区别，本文会试图澄清这一概念。�ƈ且由于Java不能通过��? 的赋值来解决对象复制的问题，在开发过�E�中�Q�也常常要要应用clone�Q�）�Ҏ��来复制对象。本文会让你了解什么是影子clone与深度clone�Q�认识它们的区别、优点及�~�点�?
看到�q�个标题�Q�是不是有点困惑�Q�Java语言明确说明取消了指针，因�ؓ指针往往是在带来方便的同时也是导致代码不安全的根源，同时也会使程序的变得非常�? 杂难以理解，滥用指针写成的代码不亚于使用早已臭名昭著�?GOTO"语句。Java攑ּ�指针的概�늻��Ҏ��极其明智的。但�q�只是在Java语言中没有明��? 的指针定义，实质上每一个new语句�q�回的都是一个指针的引用�Q�只不过在大多时候Java中不用关心如何操作这�?指针"�Q�更不用象在操作C�Q�＋的指针那栯��战心惊。唯一要多多关心的是在�l�函��C��递对象的时候。如下例�E�：

package reference;
class Obj{
String str = "init value";
public String toString(){
return str;
}
}
public class ObjRef{
Obj aObj = new Obj();
int aInt = 11;
public void changeObj(Obj inObj){
inObj.str = "changed value";
}
public void changePri(int inInt){
inInt = 22;
}
public static void main(String[] args)
{
ObjRef oRef = new ObjRef();

System.out.println("Before call changeObj() method: " + oRef.aObj);
oRef.changeObj(oRef.aObj);
System.out.println("After call changeObj() method: " + oRef.aObj);

System.out.println("==================Print Primtive=================");
System.out.println("Before call changePri() method: " + oRef.aInt);
oRef.changePri(oRef.aInt);
System.out.println("After call changePri() method: " + oRef.aInt);

}
}

/* RUN RESULT
Before call changeObj() method: init value
After call changeObj() method: changed value
==================Print Primtive=================
Before call changePri() method: 11
After call changePri() method: 11

*
*/

�q�段代码的主要部分调用了两个很相�q�的�Ҏ��Q�changeObj()和changePri()。唯一不同的是它们一个把对象作�ؓ输入参数�Q�另一个把 Java中的基本�c�d��int作�ؓ输入参数。�ƈ且在�q�两个函��C��内部都对输入的参数进行了改动。看��g��L��Ҏ��Q�程序输出的�l�果却不太一栗��? changeObj()�Ҏ��真正的把输入的参数改变了�Q�而changePri()�Ҏ��对输入的参数没有��M��的改变�?

从这个例子知道Java对对象和基本的数据类型的处理是不一��L��。和C语言一��P��当把Java的基本数据类型（如int�Q�char�Q�double�{�）作�ؓ 入口参数传给函数体的时候，传入的参数在函数体内部变成了局部变量，�q�个局部变量是输入参数的一个拷贝，所有的函数体内部的操作都是针对�q�个拯��的操作，函数执行�l�束后，�q�个局部变量也��完成了它的使命�Q�它影响不到作�ؓ输入参数的变量。这�U�方式的参数传递被�U�Cؓ"��g��?。而在Java中用对象的作为入�? 参数的传递则�~�省�?引用传�?�Q�也��是说仅仅传递了对象的一�?引用"�Q�这�?引用"的概念同C语言中的指针引用是一��L��。当函数体内部对输入变量改变 �Ӟ��实质上就是在对这个对象的直接操作�?

除了在函��C��值的时候是"引用传�?�Q�在��M��?�Q?向对象变量赋值的时候都�?引用传�?。如�Q?

package reference;
class PassObj
{
String str = "init value";
}
public class ObjPassvalue
{

public static void main(String[] args)
{
PassObj objA = new PassObj();
PassObj objB = objA;

objA.str = "changed in objA";
System.out.println("Print objB.str value: " + objB.str);

2 JAVA中的指针,引用及对象的clone

}
}
/* RUN RESULT
Print objB.str value: changed in objA
*/

�W�一句是在内存中生成一个新的PassObj对象�Q�然后把�q�个PassObj的引用赋�l�变量objA�Q�第二句是把PassObj对象的引用又赋给了变�? objB。此时objA和objB是两个完全一致的变量�Q�以后�Q何对objA的改变都�{�同于对objB的改变�?

即��明白了Java语言中的"指针"概念也许�q�会不经意间犯下面的错误�?

Hashtable真的能存储对象吗�Q?

看一看下面的很简单的代码�Q�先是声明了一个Hashtable和StringBuffer对象�Q�然后分四次把StriingBuffer对象攑օ��? Hashtable表中�Q�在每次攑օ�之前都对�q�个StringBuffer对象append()了一些新的字�W�串�Q?

package reference;
import java.util.*;
public class HashtableAdd{
public static void main(String[] args){
Hashtable ht = new Hashtable();
StringBuffer sb = new StringBuffer();
sb.append("abc,");
ht.put("1",sb);
sb.append("def,");
ht.put("2",sb);
sb.append("mno,");
ht.put("3",sb);
sb.append("xyz.");
ht.put("4",sb);

int numObj=0;
Enumeration it = ht.elements();
while(it.hasMoreElements()){
System.out.print("get StringBufffer "+(++numObj)+" from Hashtable: ");
System.out.println(it.nextElement());
}
}
}

如果你认��出的�l�果是：
get StringBufffer 1 from Hashtable: abc,
get StringBufffer 2 from Hashtable: abc,def�Q?
get StringBufffer 3 from Hashtable: abc,def,mno,
get StringBufffer 4 from Hashtable: abc,def,mno,xyz.

那么你就要回�q�头再仔�l�看一看上一个问题了�Q�把对象时作为入口参��C��l�函敎ͼ�实质上是传递了对象的引用，向Hashtable传�? StringBuffer对象也是只传递了�q�个StringBuffer对象的引用！每一�ơ向Hashtable表中put一��? StringBuffer�Q��ƈ没有生成新的StringBuffer对象�Q�只是在Hashtable表中又放入了一个指向同一StringBuffer�? 象的引用而已�?

对Hashtable表存储的��M��一个StringBuffer对象�Q�更��切的说应该是对象的引用�Q�的改动�Q�实际上都是对同一 �?StringBuffer"的改动。所以Hashtable�q�不能真正存储能对象�Q�而只能存储对象的引用。也应该知道�q�条原则对与Hashtable �怼�的Vector, List, Map, Set�{�都是一��L��?

上面的例�E�的实际输出的结果是�Q?

/* RUN RESULT
get StringBufffer 1 from Hashtable: abc,def,mno,xyz.
get StringBufffer 2 from Hashtable: abc,def,mno,xyz.
get StringBufffer 3 from Hashtable: abc,def,mno,xyz.
get StringBufffer 4 from Hashtable: abc,def,mno,xyz.
*/

�c�，对象与引�?

Java最基本的概念就是类�Q�类包括函数和变量。如果想要应用类�Q�就要把�cȝ��成对象，�q�个�q�程被称�?�cȝ��实例�?。有几种�Ҏ��把类实例化成对象�Q�最常用的就是用"new"操作�W�。类实例化成对象后，��意味着要在内存中占据一块空间存攑֮�例。想要对�q�块�I�间操作��p��应用到对象的引用。引用在Java语言�? 的体现就是变量，而变量的�c�d��是�q�个引用的对象。虽然在语法上可以在生成一个对象后直接调用该对象的函数或变量，如：

new String("Hello NDP")).substring(0,3)　　//RETURN RESULT: Hel

但由于没有相应的引用�Q�对�q�个对象的��用也只能局限这条语句中了�?

产生�Q�引用��L��在把对象作参�?传�?的过�E�中自动发生�Q�不需要�h为的产生�Q�也不能��Zؓ的控制引用的产生。这个传递包括把对象作�ؓ函数的入口参数的情况�Q�也包括�?�Q?�q�行对象赋值的时候�?
范围�Q�只有局部的引用�Q�没有局部的对象。引用在Java语言的体现就是变量，而变量在Java语言中是有范围的�Q�可以是局部的�Q�也可以是全局的�?
生存期：�E�序只能控制引用的生存周期。对象的生存期是由Java控制。用"new Object()"语句生成一个新的对象，是在计算机的内存中声明一块区域存储对象，只有Java的垃圾收集器才能军_��在适当的时候回收对象占用的内存�?

3 JAVA中的指针,引用及对象的clone

没有办法��L��对引用的改动�?
什么是"clone"�Q?

在实际编�E�过�E�中�Q�我们常常要遇到�q�种情况�Q�有一个对象A�Q�在某一时刻A中已�l�包含了一些有效��|��此时可能会需要一个和A完全相同新对象B�Q��ƈ且此后对B ��M��改动都不会媄响到A中的��|��也就是说�Q�A与B是两个独立的对象�Q�但B的初始值是由A对象��定的。在Java语言中，用简单的赋��D��句是不能满��q�种需求的。要满��q�种需求虽然有很多途径�Q�但实现clone�Q�）�Ҏ��是其中最��单，也是最高效的手�D�c�?

Java的所有类都默认��承java.lang.Object�c�，在java.lang.Object�c�M��有一个方法clone()。JDK API的说明文档解释这个方法将�q�回Object对象的一个拷贝。要说明的有两点�Q�一是拷贝对象返回的是一个新对象�Q�而不是一个引用。二是拷贝对象与�? new操作�W�返回的新对象的区别��是�q�个拯��已经包含了一些原来对象的信息�Q�而不是对象的初始信息�?

怎样应用clone()�Ҏ��Q?

一个很典型的调用clone()代码如下�Q?

class CloneClass implements Cloneable{
public int aInt;
public Object clone(){
CloneClass o = null;
try{
o = (CloneClass)super.clone();
}catch(CloneNotSupportedException e){
e.printStackTrace();
}
return o;
}
�?
有三个值得注意的地方，一是希望能实现clone功能的CloneClass�c�d��C��Cloneable接口�Q�这个接口属于java.lang 包，java.lang包已�l�被�~�省的导入类中，所以不需要写成java.lang.Cloneable。另一个值得��h��意的是重载了clone()�? 法。最后在clone()�Ҏ��中调用了super.clone()�Q�这也意味着无论clone�cȝ��l�承�l�构是什么样的，super.clone()直接�? 间接调用了java.lang.Object�cȝ��clone()�Ҏ��。下面再详细的解释一下这几点�?

应该说第三点是最重要的，仔细观察一下Object�cȝ��clone()一个native�Ҏ��Q�native�Ҏ��的效率一般来说都是远高于java中的�? native�Ҏ��。这也解释了��Z��么要用Object中clone()�Ҏ��而不是先new一个类�Q�然后把原始对象中的信息赋到新对象中�Q�虽然这也实��C�� clone功能。对于第二点�Q�也要观察Object�c�M��的clone()�q�是一个protected属性的�Ҏ��。这也意味着如果要应用clone()�? 法，必须�l�承Object�c�，在Java中所有的�c�L��~�省�l�承Object�cȝ��Q�也��׃��用关心这点了。然后重载clone()�Ҏ��。还有一点要考虑的是�? 了让其它�c�能调用�q�个clone�cȝ��clone()�Ҏ��Q�重载之后要把clone()�Ҏ��的属性设�|��ؓpublic�?

那么clone�c�Mؓ什么还要实现Cloneable接口呢？�E�微注意一下，Cloneable接口是不包含��M��Ҏ��的！其实�q�个接口仅仅是一个标志，而且 �q�个标志也仅仅是针对Object�c�M��clone()�Ҏ��的，如果clone�c�L��有实现Cloneable接口�Q��ƈ调用了Object的clone()�? 法（也就是调用了super.Clone()�Ҏ��Q�，那么Object的clone()�Ҏ��׃��抛出 CloneNotSupportedException异常�?

以上是clone的最基本的步骤，惌��完成一个成功的clone�Q�还要了解什么是"影子clone"�?深度clone"�?

什么是影子clone�Q?

下面的例子包含三个类UnCloneA�Q�CloneB�Q�CloneMain。CloneB�c�d��含了一个UnCloneA的实例和一个int�c�d��变量�Q��ƈ�? 重蝲clone()�Ҏ��。CloneMain�c�d��始化UnCloneA�cȝ��一个实例b1�Q�然后调用clone()�Ҏ��生成了一个b1的拷贝b2。最后考察一下b1和b2的输出：

package clone;
class UnCloneA {
private int i;
public UnCloneA(int ii) { i = ii; }
public void doublevalue() { i *= 2; }
public String toString() {
return Integer.toString(i);
}
}
class CloneB implements Cloneable{
public int aInt;
public UnCloneA unCA = new UnCloneA(111);
public Object clone(){
CloneB o = null;
try{
o = (CloneB)super.clone();
}catch(CloneNotSupportedException e){

4 JAVA中的指针,引用及对象的clone

e.printStackTrace();
}
return o;
}
}
public class CloneMain {
public static void main(String[] a){
CloneB b1 = new CloneB();
b1.aInt = 11;
System.out.println("before clone,b1.aInt = "+ b1.aInt);
System.out.println("before clone,b1.unCA = "+ b1.unCA);

CloneB b2 = (CloneB)b1.clone();
b2.aInt = 22;
b2.unCA.doublevalue();
System.out.println("=================================");
System.out.println("after clone,b1.aInt = "+ b1.aInt);
System.out.println("after clone,b1.unCA = "+ b1.unCA);
System.out.println("=================================");
System.out.println("after clone,b2.aInt = "+ b2.aInt);
System.out.println("after clone,b2.unCA = "+ b2.unCA);
}
}

/** RUN RESULT:
before clone,b1.aInt = 11
before clone,b1.unCA = 111
=================================
after clone,b1.aInt = 11
after clone,b1.unCA = 222
=================================
after clone,b2.aInt = 22
after clone,b2.unCA = 222
*/

输出的结果说明int�c�d��的变量aInt和UnCloneA的实例对象unCA的clone�l�果不一��_��int�c�d��是真正的被clone了，因�ؓ改变�? b2中的aInt变量�Q�对b1的aInt没有产生影响�Q�也��是��_��b2.aInt与b1.aInt已经占据了不同的内存�I�间�Q�b2.aInt�? b1.aInt的一个真正拷贝。相反，对b2.unCA的改变同时改变了b1.unCA�Q�很明显�Q�b2.unCA和b1.unCA是仅仅指向同一个对象的不同引用�Q�从中可以看出，调用Object�c�M��clone()�Ҏ��产生的效果是�Q�先在内存中开辟一块和原始对象一��L��I�间�Q�然后原��h��贝原始对象中的内宏V��对基本数据�c�d��Q�这��L��操作是没有问题的�Q�但寚w��基本�c�d��变量�Q�我们知道它们保存的仅仅是对象的引用�Q�这也导致clone后的非基本类型变量和原始�? 象中相应的变量指向的是同一个对象�?

大多时候，�q�种clone的结果往往不是我们所希望的结果，�q�种clone也被�U�Cؓ"影子clone"。要惌��b2.unCA指向与b2.unCA不同�? 对象�Q�而且b2.unCA中还要包含b1.unCA中的信息作�ؓ初始信息�Q�就要实现深度clone�?

怎么�q�行深度clone�Q?

把上面的例子�Ҏ��深度clone很简单，需要两个改变：一是让UnCloneA�c�M��实现和CloneB�c�M��L��clone功能�Q�实现Cloneable�? 口，重蝲clone()�Ҏ��Q�。二是在CloneB的clone()�Ҏ��中加入一句o.unCA = (UnCloneA)unCA.clone();

�E�序如下�Q?

package clone.ext;
class UnCloneA implements Cloneable{
private int i;
public UnCloneA(int ii) { i = ii; }
public void doublevalue() { i *= 2; }
public String toString() {
return Integer.toString(i);
}
public Object clone(){
UnCloneA o = null;
try{
o = (UnCloneA)super.clone();
}catch(CloneNotSupportedException e){
e.printStackTrace();
}
return o;
}
}
class CloneB implements Cloneable{
public int aInt;
public UnCloneA unCA = new UnCloneA(111);
public Object clone(){
CloneB o = null;
try{
o = (CloneB)super.clone();
}catch(CloneNotSupportedException e){
e.printStackTrace();
}
o.unCA = (UnCloneA)unCA.clone();
return o;
}
}
public class CloneMain {
public static void main(String[] a){
CloneB b1 = new CloneB();
b1.aInt = 11;
System.out.println("before clone,b1.aInt = "+ b1.aInt);
System.out.println("before clone,b1.unCA = "+ b1.unCA);

CloneB b2 = (CloneB)b1.clone();
b2.aInt = 22;
b2.unCA.doublevalue();
System.out.println("=================================");

5 JAVA中的指针,引用及对象的clone

System.out.println("after clone,b1.aInt = "+ b1.aInt);
System.out.println("after clone,b1.unCA = "+ b1.unCA);
System.out.println("=================================");
System.out.println("after clone,b2.aInt = "+ b2.aInt);
System.out.println("after clone,b2.unCA = "+ b2.unCA);
}
}

/** RUN RESULT:
before clone,b1.aInt = 11
before clone,b1.unCA = 111
=================================
after clone,b1.aInt = 11
after clone,b1.unCA = 111
=================================
after clone,b2.aInt = 22
after clone,b2.unCA = 222
*/

可以看出�Q�现在b2.unCA的改变对b1.unCA没有产生影响。此时b1.unCA与b2.unCA指向了两个不同的UnCloneA实例�Q�而且�? CloneB b2 = (CloneB)b1.clone();调用的那一刻b1和b2拥有相同的��|��在这里，b1.i = b2.i = 11�?

要知道不是所有的�c�都能实现深度clone的。例如，如果把上面的CloneB�c�M��的UnCloneA�c�d��变量�Ҏ��StringBuffer�c�d��Q�看一�? JDK API中关于StringBuffer的说明，StringBuffer没有重蝲clone()�Ҏ��Q�更��Z��重的是StringBuffer�q�是一�? final�c�，�q�也是说我们也不能用�l�承的办法间接实现StringBuffer的clone。如果一个类中包含有StringBuffer�c�d��对象或和 StringBuffer�怼��cȝ��对象�Q�我们有两种选择�Q�要么只能实现媄子clone�Q�要么就在类的clone()�Ҏ��中加一句（假设�? SringBuffer对象�Q�而且变量名仍是unCA�Q�： o.unCA = new StringBuffer(unCA.toString()); //原来的是�Q�o.unCA = (UnCloneA)unCA.clone();

�q�要知道的是除了基本数据�c�d��能自动实现深度clone以外�Q�String对象是一个例外，它clone后的表现好象也实��C��深度clone�Q�虽然这只是一个假象，但却大大方便了我们的�~�程�?

Clone中String和StringBuffer的区�?

应该说明的是�Q�这里不是着重说明String和StringBuffer的区别，但从�q�个例子里也能看出String�cȝ��一些与众不同的地方�?

下面的例子中包括两个�c�，CloneC�c�d��含一个String�c�d��变量和一个StringBuffer�c�d��变量�Q��ƈ且实��C��clone()�Ҏ��。在 StrClone�c�M��声明了CloneC�c�d��变量c1�Q�然后调用c1的clone()�Ҏ��生成c1的拷贝c2�Q�在对c2中的String�? StringBuffer�c�d��变量用相应的�Ҏ��改动之后打印�l�果�Q?

package clone;
class CloneC implements Cloneable{
public String str;
public StringBuffer strBuff;
public Object clone(){
CloneC o = null;
try{
o = (CloneC)super.clone();
}catch(CloneNotSupportedException e){
e.printStackTrace();
}
return o;
}

}
public class StrClone {
public static void main(String[] a){
CloneC c1 = new CloneC();
c1.str = new String("initializeStr");
c1.strBuff = new StringBuffer("initializeStrBuff");
System.out.println("before clone,c1.str = "+ c1.str);
System.out.println("before clone,c1.strBuff = "+ c1.strBuff);

CloneC c2 = (CloneC)c1.clone();
c2.str = c2.str.substring(0,5);
c2.strBuff = c2.strBuff.append(" change strBuff clone");
System.out.println("=================================");
System.out.println("after clone,c1.str = "+ c1.str);
System.out.println("after clone,c1.strBuff = "+ c1.strBuff);
System.out.println("=================================");
System.out.println("after clone,c2.str = "+ c2.str);
System.out.println("after clone,c2.strBuff = "+ c2.strBuff);
}
}
/* RUN RESULT
before clone,c1.str = initializeStr
before clone,c1.strBuff = initializeStrBuff
=================================
after clone,c1.str = initializeStr
after clone,c1.strBuff = initializeStrBuff change strBuff clone
=================================
after clone,c2.str = initi
after clone,c2.strBuff = initializeStrBuff change strBuff clone
*
*/

打印的结果可以看出，String�c�d��的变量好象已�l�实��C��深度clone�Q�因为对c2.str的改动�ƈ没有影响到c1.str�Q�难道Java�? Sring�cȝ��成了基本数据�c�d��Q�其实不�Ӟ��q�里有一个小��的把戏�Q�秘密就在于c2.str = c2.str.substring(0,5)�q�一语句�Q�实质上�Q�在clone的时候c1.str与c2.str仍然是引用，而且都指向了同一�? String对象。但在执行c2.str = c2.str.substring(0,5)的时候，它作用相当于生成了一个新的String�c�d��Q�然后又赋回�l�c2.str。这是因为String�? Sun公司的工�E�师写成了一个不可更改的�c�（immutable class�Q�，在所有String�c�M��的函数都不能更改自��n的倹{��下面给出很��单的一个例子：

package clone; public class StrTest { public static void main(String[] args) { String str1 = "This is a test for immutable"; String str2 = str1.substring(0,8); System.out.println("print str1 : " + str1); System.out.println("print str2 : " + str2); } } /* RUN RESULT print str1 : This is a test for immutable print str2 : This is */

例子中，虽然str1调用了substring()�Ҏ��Q�但str1的值�ƈ没有改变。类似的�Q�String�c�M��的其它方法也是如此。当然如果我们把最上面的例子中的这两条语句

c2.str = c2.str.substring(0,5);
c2.strBuff = c2.strBuff.append(" change strBuff clone");

�Ҏ��下面�q�样�Q?

c2.str.substring(0,5);
c2.strBuff.append(" change strBuff clone");

��L��了重新赋值的�q�程�Q�c2.str也就不能有变化了�Q�我们的把戏也就露馅了。但在编�E�过�E�中只调�?

c2.str.substring(0,5);

语句是没有�Q何意义的�?

应该知道的是在Java中所有的基本数据�c�d��都有一个相对应的类�Q�象Integer�c�d��应int�c�d��Q�Double�c�d��应double�c�d��{�等�Q�这些类�? 与String�cȝ��同，都是不可以改变的�c�R��也��是��_��q�些的类中的所有方法都是不能改变其自��n的值的。这也让我们在编clone�cȝ��时候有了一个更多的选择。同时我们也可以把自��q��cȝ��成不可更改的�c�R�?/font>

矛_��@ 2009-06-29 18:41 发表评论

	�W�号�?/font>	指数�?/font>	��数部分	指数偏移�?/font>
单精度��Q�Ҏ��	1 位[31]	8�?[30-23]	23�?[22-00]	127
双精度��Q�Ҏ��	1 位[63]	11 位[62-52]	52 位[51-00]	1023