BlogJava-海阔天空-文章分类-java_base

优化你的java代码性能

石头@ — Mon, 24 Aug 2009 13:40:00 GMT

一、避免在循环条件中使用复杂表达式

在不做编译优化的情况下，在循环中，循环条件会被反复计算，如果不使用复杂表达式，而使循环条件值不变的话，程序将会运行的更快。

例子：
import java.util.Vector;
class CEL {
    void method (Vector vector) {
        for (int i = 0; i < vector.size (); i++)  // Violation
            ; // ...
    }
}

更正：
class CEL_fixed {
    void method (Vector vector) {
        int size = vector.size ()
        for (int i = 0; i < size; i++)
            ; // ...
    }
}

二、为'Vectors' 和 'Hashtables'定义初始大小

JVM为Vector扩充大小的时候需要重新创建一个更大的数组，将原原先数组中的内容复制过来，最后，原先的数组再被回收。可见Vector容量的扩大是一个颇费时间的事。
通常，默认的10个元素大小是不够的。你最好能准确的估计你所需要的最佳大小。

例子：
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.
}

更正：
自己设定初始大小。
    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

程序中使用到的资源应当被释放，以避免资源泄漏。这最好在finally块中去做。不管程序执行的结果如何，finally块总是会执行的，以确保资源的正确关闭。

例子：
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) {
        }
    }
}

更正：
在最后一个catch后添加一个finally块

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

四、使用'System.arraycopy ()'代替通过来循环复制数组

'System.arraycopy ()' 要比通过循环来复制数组快的多。

例子：
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
        }
    }
}

更正：
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

五、让访问实例内变量的getter/setter方法变成”final”

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

例子：
class MAF {
    public void setSize (int size) {
         _size = size;
    }
    private int _size;
}

更正：
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操作

如果左边的对象的静态类型等于右边的，instanceof表达式返回永远为true。

例子：
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");
    }
}

更正：
删掉不需要的instanceof操作。

class Dog extends UISO {
    void method () {
        Dog d;
        System.out.println ("Dog is an UISO");
        System.out.println ("UISO is an UISO");
    }
}

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

所有的类都是直接或者间接继承自Object。同样，所有的子类也都隐含的“等于”其父类。那么，由子类造型至父类的操作就是不必要的了。
例子：
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.
    }
}

更正：
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

八、如果只是查找单个字符的话，用charAt()代替startsWith()

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

例子：
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'操作

"/"是一个很“昂贵”的操作，使用移位操作将会更快更有效。

例子：
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;
    }
}

更正：
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;       // 不能转换成位移操作
    }
}

十、使用移位操作代替'a * b'

同上。
[i]但我个人认为，除非是在一个非常大的循环内，性能非常重要，而且你很清楚你自己在做什么，方可使用这种方法。否则提高性能所带来的程序晚读性的降低将是不合算的。

例子：
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;
    }
}

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

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

例子：
public class STR {
    public void method(String s) {
        String string = s + "d"  // violation.
        string = "abc" + "d"      // violation.
    }
}

更正：
将一个字符的字符串替换成' '
public class STR {
    public void method(String s) {
        String string = s + 'd'
        string = "abc" + 'd'
    }
}

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

方法的同步需要消耗相当大的资料，在一个循环中调用它绝对不是一个好主意。

例子：
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);
}

更正：
不要在循环体中调用同步方法，如果必须同步的话，推荐以下方式：
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块移出循环

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

例子：
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;
}

更正：
将try/catch块移出循环
    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值与一个true比较是一个恒等操作(直接返回该boolean变量的值). 移走对于boolean的不必要操作至少会带来2个好处：
1)代码执行的更快 (生成的字节码少了5个字节)；
2)代码也会更加干净。

例子：
public class UEQ
{
    boolean method (String string) {
        return string.endsWith ("a") == true;   // Violation
    }
}

更正：
class UEQ_fixed
{
    boolean method (String string) {
        return string.endsWith ("a");
    }
}

十五、对于常量字符串，用'String' 代替 'StringBuffer'

常量字符串并不需要动态改变长度。
例子：
public class USC {
    String method () {
        StringBuffer s = new StringBuffer ("Hello");
        String t = s + "World!";
        return t;
    }
}

更正：
把StringBuffer换成String，如果确定这个String不会再变的话，这将会减少运行开销提高性能。

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

字符串的分析在很多应用中都是常见的。使用indexOf()和substring()来分析字符串容易导致StringIndexOutOfBoundsException。而使用StringTokenizer类来分析字符串则会容易一些，效率也会高一些。

例子：
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;" 结构

条件操作符更加的简捷
例子：
public class IF {
    public int method(boolean isDone) {
        if (isDone) {
            return 0;
        } else {
            return 10;
        }
    }
}

更正：
public class IF {
    public int method(boolean isDone) {
        return (isDone ? 0 : 10);
    }
}

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

例子：
public class IFAS {
    void method(boolean isTrue) {
        if (isTrue) {
            _value = 0;
        } else {
            _value = 1;
        }
    }
    private int _value = 0;
}

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

十九、不要在循环体中实例化变量

在循环体中实例化临时变量将会增加内存消耗

例子：
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);
        }
    }
}

更正：
在循环体外定义变量，并反复使用
import java.util.Vector;
public class LOOP {
    void method (Vector v) {
        Object o;
        for (int i=0;i             o = v.elementAt(i);
        }
    }
}

二十、确定 StringBuffer的容量

StringBuffer 的构造器会创建一个默认大小(通常是16)的字符数组。在使用中，如果超出这个大小，就会重新分配内存，创建一个更大的数组，并将原先的数组复制过来，再丢弃旧的数组。在大多数情况下，你可以在创建 StringBuffer的时候指定大小，这样就避免了在容量不够的时候自动增长，以提高性能。

例子：
public class RSBC {
    void method () {
        StringBuffer buffer = new StringBuffer(); // violation
        buffer.append ("hello");
    }
}

更正：
为StringBuffer提供寝大小。
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

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

如果一个变量需要经常访问，那么你就需要考虑这个变量的作用域了。static? local?还是实例变量？访问静态变量和实例变量将会比访问局部变量多耗费2-3个时钟周期。

例子：
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;
}

更正：
如果可能，请使用局部变量作为你经常访问的变量。
你可以按下面的方法来修改getSum()方法：
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

二十二、不要总是使用取反操作符(!)

取反操作符(!)降低程序的可读性，所以不要总是使用。

例子：
public class DUN {
    boolean method (boolean a, boolean b) {
        if (!a)
            return !a;
        else
            return !b;
    }
}

更正：
如果可能不要使用取反操作符(!)

二十三、与一个接口进行instanceof操作

基于接口的设计通常是件好事，因为它允许有不同的实现，而又保持灵活。只要可能，对一个对象进行instanceof操作，以判断它是否某一接口要比是否某一个类要快。

例子：
public class INSOF {
    private void method (Object o) {
        if (o instanceof InterfaceBase) { }  // better
        if (o instanceof ClassBase) { }   // worse.
    }
}

class ClassBase {}
interface InterfaceBase {}

摘自：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程序员都会遇到的问题,程序在本地运行一切正常,可是布署到远端就会出现内存无限制的增长,最后系统瘫痪,那么如何最快最好的检测程序的稳定性,防止系统崩盘,作者用自已的亲身经历与各位分享解决这些问题的办法.

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

一. Java是如何管理内存

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

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

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

二. 什么是Java中的内存泄露

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

在Java中,内存泄漏就是存在一些被分配的对象,这些对象有下面两个特点,首先,这些对象是有被引用的,即在有向树形图中,存在树枝通路可以与其相连；其次,这些对象是无用的,即程序以后不会再使用这些对象.如果对象满足这两个条件,这些对象就可以判定为Java中的内存泄漏,这些对象不会被GC所回收,然而它却占用内存.

这里引用一个常看到的例子,在下面的代码中,循环申请Object对象,并将所申请的对象放入一个 Vector中,如果仅仅释放对象本身,但因为Vector仍然引用该对象,所以这个对象对GC来说是不可回收的.因此,如果对象加入到Vector后, 还必须从Vector中删除,最简单的方法就是将Vector对象设置为null.实际上这些对象已经是无用的,但还被引用,GC就无能为力了(事实上 GC认为它还有用),这一点是导致内存泄漏最重要的原因. 再引用另一个例子来说明Java的内存泄漏.假设有一个日志类Logger,其提供一个静态的log(String msg),任何其它类都可以调用Logger.Log(message)来将message的内容记录到系统的日志文件中.

Logger类有一个类型为HashMap的静态变量temp,每次在执行log(message) 的时候,都首先将message的值写入temp中(以当前线程+当前时间为键),在退出之前再从temp中将以当前线程和当前时间为键的条目删除.注意,这里当前时间是不断变化的,所以log在退出之前执行删除条目的操作并不能删除执行之初写入的条目.这样,任何一个作为参数传给log的字符串最终由于被Logger的静态变量temp引用,而无法得到回收,这种对象保持就是我们所说的Java内存泄漏. 总的来说,内存管理中的内存泄漏产生的主要原因：保留下来却永远不再使用的对象引用.

三. 几种典型的内存泄漏

我们知道了在Java中确实会存在内存泄漏,那么就让我们看一看几种典型的泄漏,并找出他们发生的原因和解决方法.

3.1 全局集合

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

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

3.2 缓存
缓存一种用来快速查找已经执行过的操作结果的数据结构.因此,如果一个操作执行需要比较多的资源并会多次被使用,通常做法是把常用的输入数据的操作结果进行缓存,以便在下次调用该操作时使用缓存的数据.缓存通常都是以动态方式实现的,如果缓存设置不正确而大量使用缓存的话则会出现内存溢出的后果,因此需要将所使用的内存容量与检索数据的速度加以平衡.

常用的解决途径是使用java.lang.ref.SoftReference类坚持将对象放入缓存.这个方法可以保证当虚拟机用完内存或者需要更多堆的时候,可以释放这些对象的引用.

3.3 类装载器
Java类装载器的使用为内存泄漏提供了许多可乘之机.一般来说类装载器都具有复杂结构,因为类装载器不仅仅是只与"常规"对象引用有关,同时也和对象内部的引用有关.比如数据变量,方法和各种类.这意味着只要存在对数据变量,方法,各种类和对象的类装载器,那么类装载器将驻留在JVM中.既然类装载器可以同很多的类关联,同时也可以和静态数据变量关联,那么相当多的内存就可能发生泄漏.

四. 如何检测和处理内存泄漏

如何查找引起内存泄漏的原因一般有两个步骤:第一是安排有经验的编程人员对代码进行走查和分析,找出内存泄漏发生的位置;第二是使用专门的内存泄漏测试工具进行测试.

第一个步骤:在代码走查的工作中,可以安排对系统业务和开发语言工具比较熟悉的开发人员对应用的代码进行了交叉走查,尽量找出代码中存在的数据库连接声明和结果集未关闭、代码冗余等故障代码.

第二个步骤:就是检测Java的内存泄漏.在这里我们通常使用一些工具来检查Java程序的内存泄漏问题.市场上已有几种专业检查Java内存泄漏的工具,它们的基本工作原理大同小异,都是通过监测Java程序运行时,所有对象的申请、释放等动作,将内存管理的所有信息进行统计、分析、可视化.开发人员将根据这些信息判断程序是否有内存泄漏问题.这些工具包括Optimizeit Profiler,JProbe Profiler,JinSight , Rational 公司的Purify等.

4.1检测内存泄漏的存在
这里我们将简单介绍我们在使用Optimizeit检查的过程.通常在知道发生内存泄漏之后,第一步是要弄清楚泄漏了什么数据和哪个类的对象引起了泄漏.

一般说来,一个正常的系统在其运行稳定后其内存的占用量是基本稳定的,不应该是无限制的增长的.同样,对任何一个类的对象的使用个数也有一个相对稳定的上限,不应该是持续增长的.根据这样的基本假设,我们持续地观察系统运行时使用的内存的大小和各实例的个数,如果内存的大小持续地增长,则说明系统存在内存泄漏,如果特定类的实例对象个数随时间而增长(就是所谓的“增长率”),则说明这个类的实例可能存在泄漏情况.

另一方面通常发生内存泄漏的第一个迹象是：在应用程序中出现了OutOfMemoryError.在这种情况下,需要使用一些开销较低的工具来监控和查找内存泄漏.虽然OutOfMemoryError也有可能应用程序确实正在使用这么多的内存；对于这种情况则可以增加JVM可用的堆的数量,或者对应用程序进行某种更改,使它使用较少的内存.

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

4.2处理内存泄漏的方法
一旦知道确实发生了内存泄漏,就需要更专业的工具来查明为什么会发生泄漏.JVM自己是不会告诉您的.这些专业工具从JVM获得内存系统信息的方法基本上有两种：JVMTI和字节码技术(byte code instrumentation).Java虚拟机工具接口(Java Virtual Machine Tools Interface,JVMTI)及其前身Java虚拟机监视程序接口(Java Virtual Machine Profiling Interface,JVMPI)是外部工具与JVM通信并从JVM收集信息的标准化接口.字节码技术是指使用探测器处理字节码以获得工具所需的信息的技术.

Optimizeit是Borland公司的产品,主要用于协助对软件系统进行代码优化和故障诊断,其中的Optimizeit Profiler主要用于内存泄漏的分析.Profiler的堆视图就是用来观察系统运行使用的内存大小和各个类的实例分配的个数的.

首先,Profiler会进行趋势分析,找出是哪个类的对象在泄漏.系统运行长时间后可以得到四个内存快照.对这四个内存快照进行综合分析,如果每一次快照的内存使用都比上一次有增长,可以认定系统存在内存泄漏,找出在四个快照中实例个数都保持增长的类,这些类可以初步被认定为存在泄漏.通过数据收集和初步分析,可以得出初步结论:系统是否存在内存泄漏和哪些对象存在泄漏(被泄漏).

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

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

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

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

石头@ 2009-08-24 21:39 发表评论

JVM的载入

石头@ — 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
同时，Java2 SDK安装程序将会把java.exe，javaw.exe，javareg.exe这3个可执行文件拷贝到winnt\system32目录下，由于winnt\system32被操作系统缺省的设置为最高优先权的PATH搜索路径，因此可保证用户在命令行任何目录下可运行java.exe来启动JVM。
那么java.exe在启动时如何确定其JRE所在的目录以及需要动态加载的链接库呢？java.exe是通过下面方式来确定的：
假如存在../jre/bin/java.dll文件，则查找../jre/lib/ jvm.cfg文件，在该文件中，第1个被列出的jvm.dll类型作为缺省值（假如在java.exe命令行指定了jvm.dll的类型，则使用指定类型）。jvm.dll类型分为hotspot，classic，server三种。假如不存在../jre/lib/jvm.cfg文件，则打印下面的错误信息：
Error: could not open 'c:\jdk1.3\jre\lib\jvm.cfg'
如不存在../jre/bin/java.dll（当运行的是winnt\system32\java.exe），则注册表将在此时发挥作用，HKEY_LOCAL_MACHINE\SOFTWARE\JavaSoft\Java Runtime Environment\ CurrentVersion键值所记录的实际上是winnt\system32\java.exe的版本值，该版本值只保存主、次两个版本号，如 1.2，1.3等。
同时java.exe程序内部本身也有一个标识自身的版本值，如1.2、1.3等。java.exe根据自己内部的版本值和CurrentVersion值相比较，假如发现两个值相等，则将在HKEY_LOCAL_MACHINE\SOFTWARE\JavaSoft \Java Runtime Environment\MainVersion.MicroVersion项下获取JRE所在目录及动态链接库，这两个键的名称分别是JavaHome和RuntimeLib，MainVersion表示主版本号，MicroVersion表示次版本号。
假如java.exe内部版本值和CurrentVersion不一致，则报类似以下的错误：
Registry key 'Software\JavaSoft\Java Runtime Environment\CurrentVersion'
has value '1.2', but '1.3' is required.
意思是说，注册表当前所记载的winnt\system32\java.exe版本为1.2，但是此时运行的java.exe版本为1.3。 java.exe抱怨除非注册表有1.3版的记载，否则自己无法正确定位JRE目录和jvm.dll，因此提示1.3是需要的。
这里，我们不能简单的修改注册表的CurrentVersion值来达到这个目的。一般地，当在系统中装了两套版本的Java2 SDK（如先装1.2而后又装了1.3），后面安装的Java2 SDK会将自己带的java.exe和javaw.exe拷贝到winnt\system32目录下，从而覆盖先前版本的java.exe和 javaw.exe，并且在注册表中改写CurrentVersion为1.3。所以建议在安装Java2 SDK前，先卸载以前安装的版本。假如人为的修改CurrentVersion，会使得不同版本的java.exe加载与己版本不符的java.dll及 jvm.dll，将引起难以预料的后果！
非凡情况：
JBuilder自己带一套JDK，在JBuilder安装完成后，JBuilder安装程序会修改CurrentVersion为自己所带JDK的版本，但不会覆盖winnt\system32下的java.exe和javaw.exe。
WebLogic自己带一套JDK，在WebLogic安装完成后，WebLogic安装程序不会修改注册表，也不会覆盖winnt\system32下的java.exe和javaw.exe。
Oracle自己带一套JDK（一般是比较低版本的，例如8.1.7仅仅带JDK 1.1.7），在Oracle安装完成后，Oracle安装程序不会修改注册表，也不会覆盖winnt\system32下的java.exe和 javaw.exe。但是，Oralce安装程序会修改系统PATH变量，将自带的JRE的bin路径加入其中，且置于最前面。随着Oracle安装版本的不同，其自带JRE的JVM启动程序也不同。在笔者机器上安装的Oracle 8.1.7，其JRE就装在C:\Program Files\Oracle下，并将C:\Program Files\Oracle\jre\1.1.7\bin放在PATH变量最前，其JVM启动程序是jre.exe而非java.exe。
以上就是Java2 SDK在Windows下安装时所做的动作，这样会带来兼容性问题：
问题背景：安装Java2 SDK后，安装了JBuilder6，未修改任何PATH变量
问题1
当在操作系统中安装了JDK 1.2，其后安装了JBuilder6（自带JDK 1.3.1），这时CurrentVersion为1.3，在命令行执行java -version时，提示：
Registry key 'Software\JavaSoft\Java Runtime Environment\CurrentVersion'
has value '1.3', but '1.2' is required.
解决方法：将JDK 1.2中java.exe所在路径加入到操作系统PATH的首位，从而保证在命令行调用java时总是执行JDK 1.2中的java.exe，以使得java.exe可正确定位JRE和jvm.dll。
问题2
当在操作系统中安装了JDK 1.3.0，而后安装了JBuilder6（自带JDK 1.3.1），这时CurrentVersion为1.3，但是此1.3是指向的是JBuilder6自带的JDK 1.3.1的JRE，而非指向先前JDK 1.3.0的JRE，当在命令行执行java -version时，此时执行的是JDK 1.3.0拷贝到winnt\system32的一个java.exe副本，但打印的版本信息却是：
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)
导致该问题的原因是java.exe只维护小数点后1位的版本号，而非2位。
解决方法：同问题1
问题3：
假如在操作系统中先安装了JDK 1.3.0，而后安装了带有与安装JDK主次版本相同的JBuilder6（带JDK 1.3.1，前两位相同），则问题1实际上被隐蔽了，没有发生的机会；而问题2的隐蔽性也很强，不轻易发觉，因为人们往往会忽略JDK的第3个版本号。
如问题2所叙，在命令行执行java，虽然是使用JDK 1.3.0的一个java.exe副本（winnt\system32目录下），而实际上却是使用JBuilder6下JDK 1.3.1的JRE及其目录结构，其结果是当我们使用Java2的extension mechanism将jar文件放到JDK 1.3.0的jre\lib\ext目录下时，发现达不到希望的效果 – 在命令行用java启动程序时，不会自动去JDK 1.3.0的jre\lib\ext目录下去搜索jar文件，它只会去JBuilder6下JDK 1.3.1的jre\lib\ext去搜索jar文件，而JBuilder6下的JDK 1.3.1并不存在jre\lib\ext这么一个目录！
问题3极为隐蔽，除非完全对Java2 SDK的安装及class定位机制了解，一般的开发者是难以发现问题所在的。有关Java2中class定位机制，见《Java2中的class定位机制》一文。
事实上，即使仅仅在系统中存在一份JDK 1.3.0，假如在命令行运行java的话，使用的JRE目录是C:\Program Files\JavaSoft\JRE\1.3，也就是说，即使我们在c:\jdk1.3\jre\lib\ext下放置我们的extension jar，也得不到预期的结果。正确的做法是放在C:\Program Files\JavaSoft\JRE\1.3\lib\ext目录下。
解决方法：同问题1
综上所叙，强烈建议将%JDK_HOME%\bin目录放在Windows操作系统的PATH变量的首位，以避免潜在的问题。
而在UNIX下，则完全不存在类似Windows操作系统上的问题。
我们在命令下执行的java是/bin/java
$which java
$/bin/java
而/bin是到/usr/bin的链接，也就是说/bin/java实际上是/usr/bin/java
而/usr/bin/java实际上链接到/usr/java/bin/java，/usr/java是到/usr/java1.2的链接（Solaris 7或更高系统内置JDK 1.2），所以我们实际上执行的java是
/usr/java1.2/bin/java
根据UNIX上的情况，java在运行时实际上总是可以用../jre/lib/sparc/libjava.so和../jre/lib/sparc /libjvm.so来找到这2个文件，前者类似于Windows下的java.dll，而后者类似于Windows下的jvm.dll。所以java也总是可以确定自己JRE的目录。
Windows和UNIX上用到的动态链接库，实际上在Sun的文档中称为optional package's native code binaries，optional pakage实际上即为extension mechanism classes，详见《Java2中的class定位机制》。
要更改UNIX上java的版本，更改/usr/java的链接是其中一个方法，具体可参见JDK在UNIX上的安装介绍。
补充：（2002-12-23）
Windows如何定位Plug-in
根据在PATH环境变量中找到的java.exe的版本号，到HKEY_LOCAL_MACHINE\SOFTWARE\JavaSoft\Java Plug-in下寻找对应版本的Java Plug-in，在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。

石头@ 2009-08-22 16:53 发表评论

java程序的运行机制

石头@ — Sat, 22 Aug 2009 01:52:00 GMT

(一) Java应用程序的开发周期包括编译、下载、解释和执行几个部分。Java编译程序将 Java源程序翻译为JVM可执行代码--字节码。这一编译过程同C/C++的编译有些不同。当C编译器编译生成一个对象的代码时，该代码是为在某一特定硬件平台运行而产生的。因此，在编译过程中，编译程序通过查表将所有对符号的引用转换为特定的内存偏移量，以保证程序运行。Java编译器却不将对变量和方法的引用编译为数值引用，也不确定程序执行过程中的内存布局，而是将这些符号引用信息保留在字节码中，由解释器在运行过程中创立内存布局，然后再通过查表来确定一个方法所在的地址。这样就有效的保证了Java的可移植性和安全性。

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

随后，被装入的代码由字节码校验器进行检查。校验器可发现操作数栈溢出，非法数据类型转化等多种错误。通过校验后，代码便开始执行了。

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

1.即时编译方式：解释器先将字节码编译成机器码，然后再执行该机器码。

2.解释执行方式：解释器通过每次解释并执行一小段代码来完成Java字节码程序的所有操作。

通常采用的是第二种方法。由于JVM规格描述具有足够的灵活性，这使得将字节码翻译为机器代码的工作

具有较高的效率。对于那些对运行速度要求较高的应用程序，解释器可将Java字节码即时编译为机器码，从而很好地保证了Java代码的可移植性和高性能。

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

Java宣称的一处编写随处运行就是由JVM来完成. 在sun的网站上你可以下载到基于各种cpu和各种操作系统的Jdk和jre的下载版本,只要寻找到合适你使用的版本,以前你所编写的class文件copy到其他的机器上可以直接运行,不需要再编译.

其实j2se是一种规范,这种规范约定了其跨平台执行的所需要关注很多实现,基于该规范开发人员可以任意编写自己的Java代码而不需要关心这个程序可能在其他的机器和cpu上无法很好运行问题.

其实你也可以看到Ibm和Weblogic都有基于j2se规范的自己实现的Java 虚拟机 . 而且Sun所宣称的不需要编译而可以直接用class文件在各个JVM上直接运行并不精确,博格曾经遇到过用sun jre开发的class文件在ibm jre上有一个自动转换的过程,然后这个类可以很好的工作了,幸好这种情况是自动完成,否则我们又要陷入类似于各种c c++的版本编译器兼容性问题中.

以下下摘录了几个主要的概念:

JVM Java Virtual Machine（Java虚拟机），它是一个虚构出来的计算机,是通过在实际的计算机上仿真模拟各种计算机功能来实现的。 Java虚拟机有自己完善的硬件架构,如处理器、堆栈、寄存器等,还具有相应的指令系统。JVM屏蔽了与具体操作系统平台相关的信息,使得Java程序只需生成在Java虚拟机上运行的目标代码(字节码),就可以在多种平台上不加修改地运行。Java虚拟机在执行字节码时,实际上最终还是把字节码解释成具体平台上的机器指令执行。

JRE Java Runtime Environment（Java运行环境），运行JAVA程序所必须的环境的集合，包含JVM标准实现及Java核心类库。

JSDK Java Software Development Kit，和JDK以及J2SE等同。

JDK Java Development Kit(Java开发工具包):包括运行环境、编译工具及其它工具、源代码等，基本上和J2SE等同。

J2ME Java 2 Micro Edition（JAVA2精简版）API规格基于J2SE ，但是被修改为可以适合某种产品的单一要求。J2ME使JAVA 程序可以很方便的应用于电话卡、寻呼机等小型设备，它包括两种类型的组件，即配置（configuration）和描述（profile）。

J2EE Java 2 Enterprise Edition（JAVA2企业版），使用Java进行企业开发的一套扩展标准，必须基于J2SE，提供一个基于组件设计、开发、集合、展开企业应用的途径。J2EE 平台提供了多层、分布式的应用模型，重新利用组件的能力，统一安全的模式以及灵活的处理控制能力。 J2EE包括EJB, JTA, JDBC, JCA, JMX, JNDI, JMS, JavaMail, Servlet, JSP等规范。

J2SE Java 2 Standard Edition（JAVA2标准版），用来开发Java程序的基础，包括编译器、小工具、运行环境，SUN发布的标准版本中还包括核心类库的所有源代码。

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

石头@ 2009-08-22 09:52 发表评论

如何“快速”掌握一门语言

石头@ — Fri, 21 Aug 2009 13:45:00 GMT

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

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

以下列出一个学习提纲，主要针对的是有经验的人，初学者不合适。这个提纲只能用于一般的庸俗编程语言学习，目前在流行编程语言排行榜上排前20的基本上都是庸俗语言。如果你要学的是LISP之类非庸俗语言，或是某个软件中的二次开发语言，这里的建议未必合适。还是那句话，仅供参考。

1. 首先了解该语言的基本数据类型，基本语法和主要语言构造，主要数学运算符和print函数的使用，达到能够写谭浩强程序设计书课后数学习题的程度；

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

3. 简单字符串处理。所谓简单，就是Regex和Parser以下的内容，什么查找替换，截断去字串之类的。不过这个阶段有一个难点，就是字符编码问题。如果理解不了，可以先跳过，否则的话最好在这时候把这个问题搞定，免留后患；

4. 基本面向对象或者函数式编程的特征，无非是什么继承、多态、Lambda函数之类的，如果有经验的话很快就明白了；

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

6. 程序代码和可执行代码的组织机制，运行时模块加载、符号查找机制，这是初学时的一个难点，因为大部分书都不太注意介绍这个极为重要的内容；

7. 基本输入输出和文件处理，输入输出流类的组织，这通常是比较繁琐的一部分，可以提纲挈领学一下，搞清楚概念，用到的时候查就是了。到这个阶段可以写大部分控制台应用了；

8. 该语言如何进行callback方法调用，如何支持事件驱动编程模型。在现代编程环境下，这个问题是涉及开发思想的一个核心问题，几乎每种语言在这里都会用足功夫，.NET的delegate，Java的anonymous inner class，Java 7的closure，C++OX的 tr1::function/bind，五花八门。如果能彻底理解这个问题，不但程序就不至于写得太走样，而且对该语言的设计思路也能有比较好的认识；

9. 如果有必要，可在这时研究regex和XML处理问题，如无必要可跳过；

10. 序列化和反序列化，掌握一下缺省的机制就可以了；

11. 如果必要，可了解一下线程、并发和异步调用机制，主要是为了读懂别人的代码，如果自己要写这类代码，必须专门花时间严肃认真系统地学习，严禁半桶水上阵；

12. 动态编程，反射和元数据编程，数据和程序之间的相互转化机制，运行时编译和执行的机制，有抱负的开发者在这块可以多下些功夫，能够使你对语言的认识高出一个层面；

13. 如果有必要，可研究一下该语言对于泛型的支持，不必花太多时间，只要能使用现成的泛型集合和泛型函数就可以了，可在以后闲暇时抽时间系统学习。需要注意的是，泛型技术跟多线程技术一样，用不好就成为万恶之源，必须系统学习，谨慎使用，否则不如不学不用；

14. 如果还有时间，最好咨询一下有经验的人，看看这个语言较常用的特色features是什么，如果之前没学过，应当补一下。比如Ruby的block interator, Java的dynamic proxy，C# 3的LINQ和extension method。没时间的话，我认为也可以边做边学，没有大问题。

15. 有必要的话，在工作的闲暇时间，可以着重考察两个问题，第一，这个语言有哪些惯用法和模式，第二，这个语言的编译/解释执行机制。

至此语言的基本部分就可以说掌握了，之后是做数据库、网络还是做图形，可以根据具体需求去搞，找相应的成熟框架或库，边做边学，加深理解。对于一个庸俗语言，我自己把上面的内容走一遍大概要花2-3周时间，不能算很快，但也耽误不了太多事情，毕竟不是每个月都学新语言。掌握了以上的内容，就给练武术打好了基本功，虽然不见得有多优秀，但是肯定是根正苗红，将来不必绕大弯子。就算是临时使用的语言，把上面这个提纲精简一下，只看蓝色重体字的部分，大致能在几天到一周内搞定，不算是太耗时，而且写出来的代码不会太不靠谱。

以上提纲未设及内存模型。对于C/C++，这个问题很重要，要放在显著位置来考虑，但对于其他语言，这个问题被透明化了，除非你要做hardcore项目，否则不必太关注。

摘自：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)这个概念, 所谓回调函数,就是指这个函数先在某处注册，而它将在稍后某个需要的时候被调用。比如在利用SDK 进行Windows编程的时候,我们需要注册一个WNDCLASS类,这个类中有这样一个参数 lpfnWndProc, 要进行消息处理,我们就要用处理消息的函数的指针给它赋值。消息处理函数什么时候被调用的？我们没有显式地在程序中看到啊。是OS调用的。这是SDK的试验方式，当然用的是过程式的语言C，可以通过传递函数的指针实现。

C++中怎么来实现呢？当然，C++兼容C，用函数指针就可以。同时C++又提供了面向对象的机制，可不可以有不同的实现机制呢？当然！ STL 中的functor(Function object)就可以用到回调上。比如对一个存放int数据的vector进行递减排序的话，我们可以这样进行。

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

greater()就是我们传递的一个匿名对象，它重载了函数调用运算符“()”。我们没有显式地调用这个对象里面提供的函数，sort函数对对象里面的函数进行call back。

Java中要实现类似functor的功能，应该怎么办呢？Command模式可以帮上忙。Command模式看起来很简单，只要把command封装到一个接口中就可以。Command模式是回调机制的一个面向对象的替代品。

比如 java.io 中已经定义好的一个接口

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

这个FilenameFilter就是Command，实现Command的类就是ConcreteCommand。这个接口所声明的操作 “accept” 就是看看目录dir中的文件name是否满足某种要求，如果满足就返回true，否则就返回false。这个要求是什么呢？你要对这个接口进行实现。比如我想看看这个文件的名称包含不包含指定
的字符串，那么就可以定义下面的类：

    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类中有这样一个方法
public String[] list(FilenameFilter filter)

因此，我们就可以这样做了：
File file = new File(”.”);
String[] list = file.list(new DirFilter(”wf”));

得到的list就是一个当然目录中所有包含字符串”wf”的文件名称的字符串数组。

怎么样，看起来是不是和C++中的functor差不多呢？

anonymous inner class 和 closure （7.0）都是体现回调的思想

石头@ 2009-08-21 21:43 发表评论

java reference

石头@ — Wed, 19 Aug 2009 04:49:00 GMT

Reference
Java世界泰山北斗级大作《Thinking In Java》切入Java就提出“Everything is Object”。在Java这个充满Object的世界中，reference是一切谜题的根源，所有的故事都是从这里开始的。

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

没有null reference。
reference必须有初值。
使用reference要比使用指针效率高。因为reference不需要测试其有效性。
指针可以重新赋值，而reference总是指向它最初获得的对象

设计选择：
当你指向你需要指向的某个东西，而且绝不会改指向其它东西，或是当你实作一个运算符而其语法需要无法有指针达成，你就应该选择reference。其它任何时候，请采用指针。

这和Java有什么关系？
初学Java，鉴于reference的名称，我毫不犹豫的将它和C++中的reference等同起来。不过，我错了。在Java中，reference可以随心所欲的赋值置空，对比一下上面列出的差异，就不难发现，Java的reference如果要与 C/C++对应，它不过是一个穿着reference外衣的指针而已。
于是，所有关于C中关于指针的理解方式，可以照搬到Java中，简而言之，reference就是一个地址。我们可以把它想象成一个把手，抓住它，就抓住了我们想要操纵的数据。如同掌握C的关键在于掌握指针，探索Java的钥匙就是reference。

一段小程序
我知道，太多的文字总是令人犯困，那就来段代码吧！
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;
}

对不起，我知道，把一个字段设成public是一种不好的编码习惯，这里只是为了说明问题。
如果你有兴趣自己运行一下这个程序，我等你！

OK，你已经运行过了吗？结果如何？是否如你预期？下面是我在自己的机器上运行的结果：
Before changeInteger:0
In changeInteger:5
After changeInteger:5

Before changeReference:0
In changeReference: 5
After changeReference:0
这里，我们关注的是两个change——changeReference和changeInteger。从输出的内容中，我们可以看出，两个方法在调用前和调用中完全一样，差异出现在调用后的结果。

糊涂的讲解
先让我们来分析一下changeInteger的行为。
前面说过了，Java中的reference就是一个地址，它指向了一个内存空间，这个空间存放着一个对象的相关信息。这里我们暂时不去关心这个内存具体如何排布，只要知道，通过地址，我们可以找到r这个对象的i字段，然后我们给它赋成5。既然这个字段的内容得到了修改，从函数中返回之后，它自然就是改动后的结果了，所以调用之后，r对象的i字段依然是5。下图展示了changeInteger调用前后内存变化。

     Reference +--------+                Reference +--------+
    ---------->| i = 0 |               ---------->| i = 5 |
               |--------|                          |--------|
               | Memory |                          | Memory |
               |        |                          |        |
               |        |                          |        |
               +--------+                          +--------+

调用changeInteger之前调用changeInteger之后

让我们把目光转向changeReference。
从代码上，我们可以看出，同changeInteger之间的差别仅仅在于多了这么一句。
r = new ReferenceTricks();
这条语句的作用是分配一块新的内存，然后将r指向它。
执行完这条语句，r就不再是原来的r，但它依然是一个ReferenceTricks的对象，所以我们依然可以对这个r的i字段赋值。到此为止，一切都是那么自然。

     Reference +--------+                          +--------+
    ---------->| i = 0 |                          | i = 0 |
               |--------|                          |--------|
               | Memory |                          | Memory |
               |        |                Reference |--------|
               |        |               ---------->| i = 5 |
               +--------+                          +--------+

调用changeReference之前调用changeReference之后

顺着这个思路继续下去的话，执行完changeReference，输出的r的i字段，那么应该是应该是新内存中的i，所以应该是5。至于那块被我们抛弃的内存，Java的GC功能自然会替我们善后的。
事与愿违。
实际的结果我们已经看到了，输出的是0。
肯定哪个地方错了，究竟是哪个地方呢？

参数传递的秘密
知道方法参数如何传递吗？
记得刚开始学编程那会儿，老师教导，所谓参数，有形式参数和实际参数之分，参数列表中写的那些东西都叫形式参数，在实际调用的时候，它们会被实际参数所替代。
编译程序不可能知道每次调用的实际参数都是什么，于是写编译器的高手就出个办法，让实际参数按照一定顺序放到一个大家都可以找得到的地方，以此作为方法调用的一种约定。所谓“没有规矩，不成方圆”，有了这个规矩，大家协作起来就容易多了。这个公共数据区，现在编译器的选择通常是“栈”，而所谓的顺序就是形式参数声明的顺序。
显然，程序运行的过程中，作为实际参数的变量可能遍布于内存的各个位置，而并不一定要老老实实的呆在栈里。为了守“规矩”，程序只好将变量复制一份到栈中，也就是通常所说的将参数压入栈中。
打起精神，谜底就要揭晓了。
我刚才说什么来着？将变量复制一份到栈中，没错，“复制”！
这就是所谓的值传递。
C语言的旷世经典《The C Programming Language》开篇的第一章中，谈到实际参数时说，“在C中，所有函数的实际参数都是传‘值’的”。
马上会有人站出来，“错了，还有传地址，比如以指针传递就是传地址”。
不错，传指针就是传地址。在把指针视为地址的时候，是否考虑过这样一个问题，它也是一个变量。前面的讨论中说过了，参数传递必须要把参数压入栈中，作为地址的指针也不例外。所以，必须把这个指针也复制一份。函数中对于指针操作实际上是对于这个指针副本的操作。
Java的reference等于C的指针。所以，在Java的方法调用中，reference也要复制一份压入堆栈。在方法中对reference的操作就是对这个reference副本的操作。
谜底揭晓
好，让我们回到最初的问题上。
在changeReference中对于reference的赋值实际上是对这个reference的副本进行赋值，而对于reference的本尊没有产生丝毫的影响。
回到调用点，本尊醒来，它并不知道自己睡去的这段时间内发生过什么，所以只好当作什么都没发生过一般。就这样，副本消失了，在方法中对它的修改也就烟消云散了。

也许你会问出这样的问题，“听了你的解释，我反而对changeInteger感到迷惑了，既然是对于副本的操作，为什么changeInteger可以运作正常？”
呵呵，很有趣的大脑短路现象。
好，那我就用前面的说法解释一下changeInteger的运作。
所谓复制，其结果必然是副本完全等同于本尊。reference复制的结果必然是两个reference指向同一块内存空间。
虽然在方法中对于副本的操作并不会影响到本尊，但对内存空间的修改确实实实在在的。
回到调用点，虽然本尊依然不知道曾经发生过的一切，但它按照原来的方式访问内存的时候，取到的确是经过方法修改之后的内容。
于是方法可以把自己的影响扩展到方法之外。

多说几句
这个问题起源于我对C/C++中同样问题的思考。同C/C++相比，在changeReference中对reference赋值可能并不会造成什么很严重的后果，而在C/C++中，这么做却会造成臭名昭著的“内存泄漏”，根本的原因在于Java拥有了可爱的GC功能。即便这样，我仍不推荐使用这种的手法，毕竟GC已经很忙了，我们怎么好意思再麻烦人家。
在C/C++中，这个问题还可以继续引申。既然在函数中对于指针直接赋值行不通，那么如何在函数中修改指针呢？答案很简单，指针的指针，也就是把原来的指针看作一个普通的数据，把一个指向它的指针传到函数中就可以了。
同样的问题到了Java中就没有那么美妙的解决方案了，因为Java中可没有reference的reference这样的语法。可能的变通就是将reference进行封装成类。至于值不值，公道自在人心。

摘自：http://azi.javaeye.com/blog/182792

石头@ 2009-08-19 12:49 发表评论

数据类型转换

石头@ — 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 发表评论

java从控制台读入数据的方法

石头@ — Fri, 14 Aug 2009 10:26:00 GMT

0　引言
从控制台中读取数据是一个比较常用的功能，在 JDK 5.0 以前的版本中的实现是比较复杂的，需要手工处理系统的输入流。有意思的是，从 JDK 5.0 版本开始，能从控制台中输入数据的方法每增加一个版本号，就有一种新增的方法，这也增加了选择的种类，可以依据不同的要求来进行选择。下面来看一下，各个版本中如何从控制台中读取数据以及各自的优缺点。

1　JDK 1.4 及以下版本读取的方法
JDK 1.4 及以下的版本中要想从控制台中输入数据只有一种办法，即使用System.in获得系统的输入流，再桥接至字符流从字符流中读入数据。示例代码如下：

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

public class Test1 {

    public static void main(String[] args) {
        String str = readString("请输入字符串：");
        System.out.println("readString 方法的输入：" + str);
    }

    /**
     * 使用系统的输入流，从控制台中读取数据

     * 用于所用的JDK版本
     * @param prompt 提示信息
     * @return 输入的字符串
     */
    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;
    }
}

从上面的代码段来看，这种控制台输入的方法非常地麻烦，为了能读取整行的数据，采用了BufferedReader类来进行处理，而且在读取的过程中还需要捕获IOException。不过这是 JDK 1.4 及以下版本中从控制台读取数据唯一的办法。还有一种非控制台读入数据的办法，就是采用 Swing 中的JOptionPane，会弹出一个非常漂亮的输入对话框让使用者输入数据，但这是一种比较另类的做法，不推荐使用。

import javax.swing.JOptionPane;

public class Test2 {

    public static void main(String[] args) {
        String str = readStringFromDialog("请输入字符串：");
        System.out.println("readStringFromDialog 方法的输入：" + str);
    }

    /**
     * 使用JOptionPane的输入对话框，输入字符串

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

2　JDK 5.0 读取的方法
从 JDK 5.0 开始，基本类库中增加了java.util.Scanner类，根据它的 API 文档说明，这个类是采用正则表达式进行基本类型和字符串分析的文本扫描器。使用它的Scanner(InputStream source)构造方法，可以传入系统的输入流System.in而从控制台中读取数据。示例代码如下：

import java.util.Scanner;

public class Test3 {

    public static void main(String[] args) {
        String str = readString5("请输入字符串：");
        System.out.println("readString5 方法的输入：" + str);
    }

    /**
     * 使用扫描器类（Scanner）从控制台中读取字符串

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

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

使用System.in作为它的构造参数时，它只扫描了系统输入流中的字符。它还有其他的构造，分别可以从文件或者是字符串中扫描分析字符串的，具体的使用方法可以参考 API 文档说明。

3　JDK 6.0 读取的方法
从 JDK 6.0 开始，基本类库中增加了java.io.Console类，用于获得与当前 Java 虚拟机关联的基于字符的控制台设备。在纯字符的控制台界面下，可以更加方便地读取数据。示例代码如下：

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

public class Test4 {

    public static void main(String[] args) {
        String str = readString6("请输入字符串：");
        System.out.println("readString6 方法的输入：" + str);
    }

    /**
     * 使用控制台类（Console）从控制台中读取字符串

     * 适用于JDK 1.6或以后的版本
     * @param prompt 提示信息
     * @return 输入的字符串
     */
    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();来输出，但是使用基于Console的Test4类，可以在方法参数中直接放入提示信息。

如果需要在控制台中输入密码等敏感信息的话，像在浏览器或者是应用程序中那样显示替代字符，在 JDK 6.0 以前的做法是相当麻烦的（具体的做法可以参考《Java 编程语言中的口令屏蔽》一文），而使用Console类的readPassword()方法可以在控制台上不回显地输入密码，并将密码结果保存在char 数组中，根据 API 文档的建议，在使用后应立即将数组清空，以减少其在内存中占用的时间，以便增强安全性。

但是，Console也有一些缺点，根据ConsoleAPI 文档的说明：

虚拟机是否具有控制台取决于底层平台，还取决于调用虚拟机的方式。如果虚拟机从一个交互式命令行开始启动，且没有重定向标准输入和输出流，那么其控制台将存在，并且通常连接到键盘并从虚拟机启动的地方显示。如果虚拟机是自动启动的（例如，由后台作业调度程序启动），那么它通常没有控制台。

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

4　总结
以上囊括了 Java 中各种版本从控制台中读入数据的方法，将对它们的优缺点进行了分析。下面给出了一些使用建议，可供参考：

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

石头@ 2009-08-14 18:26 发表评论

StringIndexOutOfBoundException 引出的对String类的看法

石头@ — Wed, 12 Aug 2009 08:15:00 GMT

邂逅StringIndexOutOfBoundsException

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

迫使我对它做了一些分析

首先：
“不断的将被选中的字符串加到某一字符串末尾，当长度超过一定量时提示：
java.lang.StringIndexOutOfBoundsException: String index out of range: 10
”并不能说明String有长度限制

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。
上面的错误是因为
String.length()<10;
而你又要取index>=10的字符从而抛出上面异常
String其实是没有限制的，而是当String太大了，超过JVM的自身的内存后会抛出
java.lang.OutOfMemoryError错误

String是没有长度限制的，而是有JVM的内存限制了String的长度

在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的默认参数执行（我的机器内存是128M）
java testString
结果：
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，当String为12M，JVM使用了63M多时
JVM溢出。

然后，我们用限制JVM内存大小的参数来执行,限制最大内存5M
java -mx5m testString
结果：
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，当String为768k，JVM使用了5M多时
JVM溢出。

大家还可以改变 -mx参数，来进一步做实验。
以上两个实验证明,String是没有长度限制的，而是有JVM的内存限制了String的长度。同时说明，并不会抛出任何Exception而只会抛出Error.

OutMemoryError表明程序的设计很差，或者遇到了超出编程人员所预想的大批量的数据。不管哪种情况，都只有下面这几种解决办法。它们是：

设计人员重新设计程序，不致使程序一次载入所有的数据。

数据可以分割成更小的块。

可以为程序分配更多的内存。

为Java虚拟机提供更多的内存。

而上面的例子是为虚拟机提供更多的内存

=======================================
其实应该少用String这东西，特别是 String的 +=操作
不仅原来的String对象不能继续使用，主要是又要new出N多的新对象出来，再多的memory也要out~~
String用char array实现，就肯定由长度限制的，不能用memory来衡量

==================================
例如上面的程序改用StringBuffer实现，就可以得到极大的改善。
下面是我改用StringBuffer做的测试：
注意：程序循环了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;
}

}
}
}

输出结果：
JVM IS USING MEMORY:1M
Loop times:2097150
String has used memory:23M
JVM IS USING MEMORY:63.75M
MemoryError:java.lang.OutOfMemoryError

=====================
从另一方面说，如果你要处理的字符串达到百兆甚至上GB，使用String对象，根本没法工作，所以这个问题不需要太多讨论。看一下jdk的源文件，String的长度是String对象的一个成员count，类型是int，不是long，也不是char。知道这些，我认为够了

摘自：http://blog.chinaunix.net/u/18/showart_18583.html

石头@ 2009-08-12 16:15 发表评论

有点变态的问题

石头@ — Sun, 09 Aug 2009 10:09:00 GMT

第一，谈谈final, finally, finalize的区别。

第二，Anonymous Inner Class (匿名内部类) 是否可以extends(继承)其它类，是否
可以implements(实现)interface(接口)?

第三，Static Nested Class 和 Inner Class的不同，说得越多越好(面试题有的很笼
统)。

第四，&和&&的区别。

第五，HashMap和Hashtable的区别。

第六，Collection 和 Collections的区别。

第七，什么时候用assert。

第八，GC是什么? 为什么要有GC?

第九，String s = new String("xyz");创建了几个String Object?

第十，Math.round(11.5)等於多少? Math.round(-11.5)等於多少?

第十一，short s1 = 1; s1 = s1 + 1;有什么错? short s1 = 1; s1 += 1;有什么错
?

第十二，sleep() 和 wait() 有什么区别?

第十三，Java有没有goto?

第十四，数组有没有length()这个方法? String有没有length()这个方法?

第十五，Overload和Override的区别。Overloaded的方法是否可以改变返回值的类型
?

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

第十七，给我一个你最常见到的runtime exception。

第十八，error和exception有什么区别?

第十九，List, Set, Map是否继承自Collection接口?

第二十，abstract class和interface有什么区别?

第二十一，abstract的method是否可同时是static,是否可同时是native，是否可同时
是synchronized?

第二十二，接口是否可继承接口? 抽象类是否可实现(implements)接口? 抽象类是否
可继承实体类(concrete class)?

第二十三，启动一个线程是用run()还是start()?

第二十四，构造器Constructor是否可被override?

第二十五，是否可以继承String类?

第二十六，当一个线程进入一个对象的一个synchronized方法后，其它线程是否可进
入此对象的其它方法?

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

第二十八，编程题: 用最有效率的方法算出2乘以8等於几?

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

第三十，当一个对象被当作参数传递到一个方法后，此方法可改变这个对象的属性，
并可返回变化后的结果，那么这里到底是值传递还是引用传递?

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

第三十二，编程题: 写一个Singleton出来。

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

以下是答案：

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

第一，谈谈final, finally, finalize的区别。
final—修饰符（关键字）如果一个类被声明为final，意味着它不能再派生出新的子
类，不能作为父类被继承。因此一个类不能既被声明为 abstract的，又被声明为final的
。将变量或方法声明为final，可以保证它们在使用中不被改变。被声明为final的变量必
须在声明时给定初值，而在以后的引用中只能读取，不可修改。被声明为final的方法也同
样只能使用，不能重载
finally—再异常处理时提供 finally 块来执行任何清除操作。如果抛出一个异常，
那么相匹配的 catch 子句就会执行，然后控制就会进入 finally 块（如果有的话）。

　　finalize—方法名。Java 技术允许使用 finalize() 方法在垃圾收集器将对象从内存
中清除出去之前做必要的清理工作。这个方法是由垃圾收集器在确定这个对象没有被引用
时对这个对象调用的。它是在 Object 类中定义的，因此所有的类都继承了它。子类覆盖
finalize() 方法以整理php?name=%CF%B5%CD%B3" onclick="tagshow(event)" class="t_tag">系统资源或者执行其他清理工作。finalize() 方法是在垃圾收集
器删除对象之前对这个对象调用的。

第二，Anonymous Inner Class (匿名内部类) 是否可以extends(继承)其它类，是否
可以implements(实现)interface(接口)?
匿名的内部类是没有名字的内部类。不能extends(继承) 其它类，但一个内部类可以
作为一个接口，由另一个内部类实现。

第三，Static Nested Class 和 Inner Class的不同，说得越多越好(面试题有的很笼
统)。
Nested Class （一般是C++的说法），Inner Class (一般是JAVA的说法)。Java内部
类与C++嵌套类最大的不同就在于是否有指向外部的引用上。具体可见http: //www.front
free.net/articles/services/view.asp?id=704&page=1
注：静态内部类（Inner Class）意味着1创建一个static内部类的对象，不需要一个
外部类对象，2不能从一个static内部类的一个对象访问一个外部类对象
Hashtable继承自Dictionary类，而HashMap是Java1.2引进的Map interface的一个实
现

　　HashMap允许将null作为一个entry的key或者value，而Hashtable不允许

　　还有就是，HashMap把Hashtable的contains方法去掉了，改成containsvalue和conta
insKey。因为contains方法容易让人引起误解。

　　最大的不同是，Hashtable的方法是Synchronize的，而HashMap不是，在
多个线程访问Hashtable时，不需要自己为它的方法实现同步，而HashMap
就必须为之提供外同步。
第四，&和&&的区别。
&是位运算符。&&是布尔逻辑运算符。

第五，HashMap和Hashtable的区别。
都属于Map接口的类，实现了将惟一键映射到特定的值上。
HashMap 类没有分类或者排序。它允许一个 null 键和多个 null 值。
Hashtable 类似于 HashMap，但是不允许 null 键和 null 值。它也比 HashMap 慢，
因为它是同步的。
Hashtable继承自Dictionary类，而HashMap是Java1.2引进的Map interface的一个实
现

　　还有就是，HashMap把Hashtable的contains方法去掉了，改成containsvalue和conta
insKey。因为contains方法容易让人引起误解。

　　最大的不同是，Hashtable的方法是Synchronize的，而HashMap不是，在
多个线程访问Hashtable时，不需要自己为它的方法实现同步，而HashMap
就必须为之提供外同步。

　　第六，Collection 和 Collections的区别。
Collections是个java.util下的类，它包含有各种有关集合操作的静态方法。
Collection是个java.util下的接口，它是各种集合结构的父接口.
第七，什么时候用assert。
断言是一个包含布尔表达式的语句，在执行这个语句时假定该表达式为 true。如果表
达式计算为 false，那么系统会报告一个 AssertionError。它用于调试目的：
assert(a > 0); // throws an AssertionError if a <= 0
断言可以有两种形式：
assert Expression1 ;
assert Expression1 : Expression2 ;
Expression1 应该总是产生一个布尔值。
Expression2 可以是得出一个值的任意表达式。这个值用于生成显示更多调试信息的
String 消息。
断言在默认情况下是禁用的。要在编译时启用断言，需要使用 source 1.4 标记：

　　javac -source 1.4 Test.java
要在运行时启用断言，可使用 -enableassertions 或者 -ea 标记。
要在运行时选择禁用断言，可使用 -da 或者 -disableassertions 标记。
要系统类中启用断言，可使用 -esa 或者 -dsa 标记。还可以在包的基础上启用或者
禁用断言。
可以在预计正常情况下不会到达的任何位置上放置断言。断言可以用于验证传递给私
有方法的参数。不过，断言不应该用于验证传递给公有方法的参数，因为不管是否启用了
断言，公有方法都必须检查其参数。不过，既可以在公有方法中，也可以在非公有方法中
利用断言测试后置条件。另外，断言不应该以任何方式改变程序的状态。

第八，GC是什么? 为什么要有GC? (基础)。
GC是垃圾收集器。Java 程序员不用担心内存管理，因为垃圾收集器会自动进行管理。
要请求垃圾收集，可以调用下面的方法之一：
System.gc()
Runtime.getRuntime().gc()

第九，String s = new String("xyz");创建了几个String Object?
两个对象，一个是“xyx”,一个是指向“xyx”的引用对象s。

第十，Math.round(11.5)等於多少? Math.round(-11.5)等於多少?
Math.round(11.5)返回（long）12，Math.round(-11.5)返回（long）-11;

第十一，short s1 = 1; s1 = s1 + 1;有什么错? short s1 = 1; s1 += 1;有什么错
?
short s1 = 1; s1 = s1 + 1;有错，s1是short型，s1+1是int型,不能显式转化为sho
rt型。可修改为s1 =(short)(s1 + 1) 。short s1 = 1; s1 += 1正确。

第十二，sleep() 和 wait() 有什么区别? 搞线程的最爱
sleep()方法是使线程停止一段时间的方法。在sleep 时间间隔期满后，线程不一定立
即恢复执行。这是因为在那个时刻，其它线程可能正在运行而且没有被调度为放弃执行，
除非(a)“醒来”的线程具有更高的优先级
(b)正在运行的线程因为其它原因而阻塞。
wait()是线程交互时，如果线程对一个同步对象x 发出一个wait()调用，该线程会暂
停执行，被调对象进入等待状态，直到被唤醒或等待时间到。
第十三，Java有没有goto?
Goto—java中的保留字，现在没有在java中使用。

第十四，数组有没有length()这个方法? String有没有length()这个方法？
数组没有length()这个方法，有length的属性。
String有有length()这个方法。

第十五，Overload和Override的区别。Overloaded的方法是否可以改变返回值的类型
?
方法的重写Overriding和重载Overloading是Java多态性的不同表现。重写Overridin
g是父类与子类之间多态性的一种表现，重载Overloading是一个类中多态性的一种表现。
如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 (Overridi
ng)。子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被
“屏蔽”了。如果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同
的参数类型，则称为方法的重载(Overloading)。Overloaded的方法是可以改变返回值的类
型。

第十六，Set里的元素是不能重复的，那么用什么方法来区分重复与否呢? 是用==还是
equals()? 它们有何区别?
Set里的元素是不能重复的，那么用iterator()方法来区分重复与否。equals()是判读
两个Set是否相等。
equals()和==方法决定引用值是否指向同一对象equals()在类中被覆盖，为的是当两
个分离的对象的内容和类型相配的话，返回真值。

第十七，给我一个你最常见到的runtime exception。
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

第十八，error和exception有什么区别?
error 表示恢复不是不可能但很困难的情况下的一种严重问题。比如说内存溢出。不
可能指望程序能处理这样的情况。
exception 表示一种设计或实现问题。也就是说，它表示如果程序运行正常，从不会
发生的情况。
第十九，List, Set, Map是否继承自Collection接口?
List，Set是

Map不是

第二十，abstract class和interface有什么区别?
声明方法的存在而不去实现它的类被叫做抽象类（abstract class），它用于要创建
一个体现某些基本行为的类，并为该类声明方法，但不能在该类中实现该类的情况。不能
创建abstract 类的实例。然而可以创建一个变量，其类型是一个抽象类，并让它指向具体
子类的一个实例。不能有抽象构造函数或抽象静态方法。Abstract 类的子类为它们父类中
的所有抽象方法提供实现，否则它们也是抽象类为。取而代之，在子类中实现该方法。知
道其行为的其它类可以在类中实现这些方法。
接口（interface）是抽象类的变体。在接口中，所有方法都是抽象的。多继承性可通
过实现这样的接口而获得。接口中的所有方法都是抽象的，没有一个有程序体。接口只可
以定义static final成员变量。接口的实现与子类相似，除了该实现类不能从接口定义中
继承行为。当类实现特殊接口时，它定义（即将程序体给予）所有这种接口的方法。然后
，它可以在实现了该接口的类的任何对象上调用接口的方法。由于有抽象类，它允许使用
接口名作为引用变量的类型。通常的动态联编将生效。引用可以转换到接口类型或从接口
类型转换，instanceof 运算符可以用来决定某对象的类是否实现了接口。

第二十一，abstract的method是否可同时是static,是否可同时是native，是否可同时
是synchronized?
都不能

第二十二，接口是否可继承接口? 抽象类是否可实现(implements)接口? 抽象类是否
可继承实体类(concrete class)?
接口可以继承接口。抽象类可以实现(implements)接口，抽象类是否可继承实体类，
但前提是实体类必须有明确的构造函数。

第二十三，启动一个线程是用run()还是start()?
启动一个线程是调用start()方法，使线程所代表的虚拟处理机处于可运行状态，这意
味着它可以由JVM调度并执行。这并不意味着线程就会立即运行。run()方法可以产生必须
退出的标志来停止一个线程。
第二十四，构造器Constructor是否可被override?
构造器Constructor不能被继承，因此不能重写Overriding，但可以被重载Overloadi
ng。

第二十五，是否可以继承String类?
String类是final类故不可以继承。

第二十六，当一个线程进入一个对象的一个synchronized方法后，其它线程是否可进
入此对象的其它方法?
不能，一个对象的一个synchronized方法只能由一个线程访问。

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

第二十八，编程题: 用最有效率的方法算出2乘以8等於几?
有C背景的程序员特别喜欢问这种问题。

2 << 3

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

第三十，当一个对象被当作参数传递到一个方法后，此方法可改变这个对象的属性，
并可返回变化后的结果，那么这里到底是值传递还是引用传递?
是值传递。Java 编程语言只由值传递参数。当一个对象实例作为一个参数被传递到方
法中时，参数的值就是对该对象的引用。对象的内容可以在被调用的方法中改变，但对象
的引用是永远不会改变的。

第三十一，swtich是否能作用在byte上，是否能作用在long上，是否能作用在String
上?
switch（expr1）中，expr1是一个整数表达式。因此传递给 switch 和 case 语句的
参数应该是 int、 short、 char 或者 byte。long,string 都不能作用于swtich。
第三十二，编程题: 写一个Singleton出来。
Singleton模式主要作用是保证在Java应用程序中，一个类Class只有一个实例存在。

　　一般Singleton模式通常有几种种形式:
第一种形式: 定义一个类，它的构造函数为private的，它有一个static的private的
该类变量，在类初始化时实例话，通过一个public的getInstance方法获取对它的引用,继
而调用其中的方法。
public class Singleton {
private Singleton(){}
//在自己内部定义自己一个实例，是不是很奇怪？
//注意这是private 只供内部调用
private static Singleton instance = new Singleton();
//这里提供了一个供外部访问本class的静态方法，可以直接访问
public static Singleton getInstance() {
return instance;
}
}
第二种形式:
public class Singleton {
private static Singleton instance = null;
public static synchronized Singleton getInstance() {
//这个方法比上面有所改进，不用每次都进行生成对象，只是第一次
//使用时生成实例，提高了效率！
if (instance==null)
instance＝new Singleton();
return instance; }
}
其他形式:
定义一个类，它的构造函数为private的，所有方法为static的。
一般认为第一种形式要更加安全

石头@ 2009-08-09 18:09 发表评论

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

石头@ — Sat, 08 Aug 2009 01:04:00 GMT

【转】JAVA常见十大异常

关键字: java异常

java 10大常见异常，出现的原因和解决方法
作为JAVA程序员，写代码难免出现bug，我们来看看java 10大常见异常

NO.1　java.lang.NullPointerException

这个异常大家肯定都经常遇到，异常的解释是 "程序遇上了空指针 "，简单地说就是调用了未经初始化的对象或者是不存在的对象，这个错误经常出现在创建图片，调用数组这些操作中，比如图片未经初始化，或者图片创建时的路径错误等等。对数组操作中出现空指针，很多情况下是一些刚开始学习编程的朋友常犯的错误，即把数组的初始化和数组元素的初始化混淆起来了。数组的初始化是对数组分配需要的空间，而初始化后的数组，其中的元素并没有实例化，依然是空的，所以还需要对每个元素都进行初始化（如果要调用的话）

NO.2　java.lang.ClassNotFoundException

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

NO.3　java.lang.ArithmeticException

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

NO.4　java.lang.ArrayIndexOutOfBoundsException

这个异常相信很多朋友也经常遇到过，异常的解释是 "数组下标越界 "，现在程序中大多都有对数组的操作，因此在调用数组的时候一定要认真检查，看自己调用的下标是不是超出了数组的范围，一般来说，显示（即直接用常数当下标）调用不太容易出这样的错，但隐式（即用变量表示下标）调用就经常出错了，还有一种情况，是程序中定义的数组的长度是通过某些特定方法决定的，不是事先声明的，这个时候，最好先查看一下数组的length，以免出现这个异常。

NO.5　java.lang.IllegalArgumentException

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

NO.6　java.lang.IllegalAccessException

这个异常的解释是 "没有访问权限 "，当应用程序要调用一个类，但当前的方法即没有对该类的访问权限便会出现这个异常。对程序中用了Package的情况下要注意这个异常。

NO.7　java.lang.IncompatibleClassChangeError

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

NO.8　java.lang.InstantiationError

实例化错误。当一个应用试图通过Java的new操作符构造一个抽象类或者接口时抛出该异常.

NO.9　java.lang.LinkageError

链接错误。该错误及其所有子类指示某个类依赖于另外一些类，在该类编译之后，被依赖的类改变了其类定义而没有重新编译所有的类，进而引发错误的情况。

NO.10　java.lang.StackOverflowError

堆栈溢出错误。当一个应用递归调用的层次太深而导致堆栈溢出时抛出该错误。

石头@ 2009-08-08 09:04 发表评论

很有深度的几个java题目！

石头@ — Wed, 05 Aug 2009 02:32:00 GMT

在2009年的JavaOne大会上，Joshua Bloch和Neal Gafter又为我们带来的7道谜题，挺有意思的。大家不妨看看。
摘自：
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"));

}

}

问题：程序打印什么？
如果熟悉Boolean.getBoolean（）这个方法的话，应该不会出错。方法的功能参考文档。

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);

}

}

问题：打印结果是什么？

这个看第一遍可能会出错，不过也算容易理解。

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());

}

}

}

问题：输出结果是什么？

理解如何正确的设计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);

}

};

}

问题：打印结果是什么？

如果看过《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);

}

}

问题：打印结果是什么？

如果理解java加载类和创建对象的顺序的话这个问题容易理解。

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);

}

}

问题：打印结果是什么？

理解内部类和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文件。
修改Words.java文件为

Java code



public class Words{

public static final String FIRST = "physics";

public static final String SECOND = "chemistry";

public static final String THIRD = "biology";

}

问题：再次编译运行PrintWords.java，打印结果是什么？

需要了解常量折叠现象，理解什么是常量。

石头@ 2009-08-05 10:32 发表评论

java io系统概述

石头@ — Thu, 30 Jul 2009 11:05:00 GMT

Java 流在处理上分为字符流和字节流。字符流处理的单元为 2 个字节的 Unicode 字符，分别操作字符、字符数组或字符串，而字节流处理单元为 1 个字节，操作字节和字节数组。

Java 内用 Unicode 编码存储字符，字符流处理类负责将外部的其他编码的字符流和 java 内 Unicode 字符流之间的转换。而类 InputStreamReader 和 OutputStreamWriter 处理字符流和字节流的转换。字符流（一次可以处理一个缓冲区）一次操作比字节流（一次一个字节）效率高。

( 一 )以字节为导向的 stream------InputStream/OutputStream

InputStream 和 OutputStream 是两个 abstact 类，对于字节为导向的 stream 都扩展这两个鸡肋（基类 ^_^ ） ;

1、 InputStream

1.1

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

construct---

(A)ByteArrayInputStream(byte[]) 创建一个新字节数组输入流（ ByteArrayInputStream ），它从指定字节数组中读取数据（使用 byte 作为其缓冲区数组）

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

---mark:: 该字节数组未被复制。

1.2

StringBufferInputStream -- 把一个 String 对象作为 InputStream .

construct---

StringBufferInputStream(String) 据指定串创建一个读取数据的输入流串。

注释：不推荐使用 StringBufferInputStream 方法。此类不能将字符正确的转换为字节。

同 JDK 1.1 版中的类似，从一个串创建一个流的最佳方法是采用 StringReader 类。

1.3

FileInputStream -- 把一个文件作为 InputStream ，实现对文件的读取操作

construct---

(A)FileInputStream(File name) 创建一个输入文件流，从指定的 File 对象读取数据。

(B)FileInputStream(FileDescriptor) 创建一个输入文件流，从指定的文件描述器读取数据。

(C)-FileInputStream(String name) 创建一个输入文件流，从指定名称的文件读取数据。

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

read(byte[]) 将当前输入流中 b.length 个字节数据读到一个字节数组中。

read(byte[], int, int) 将输入流中 len 个字节数据读入一个字节数组中。

1.4

PipedInputStream ：实现了 pipe 的概念，主要在线程中使用 . 管道输入流是指一个通讯管道的接收端。

一个线程通过管道输出流发送数据，而另一个线程通过管道输入流读取数据，这样可实现两个线程间的通讯。

construct---

PipedInputStream() 创建一个管道输入流，它还未与一个管道输出流连接。

PipedInputStream(PipedOutputStream) 创建一个管道输入流 , 它已连接到一个管道输出流。

1.5

SequenceInputStream ：把多个 InputStream 合并为一个 InputStream . “序列输入流”类允许应用程序把几个输入流连续地合并起来，

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

然后“序列输入流”类关闭这个流并自动地切换到下一个输入流。

construct---

SequenceInputStream(Enumeration) 创建一个新的序列输入流，并用指定的输入流的枚举值初始化它。

SequenceInputStream(InputStream, InputStream) 创建一个新的序列输入流，初始化为首先读输入流 s1, 然后读输入流 s2 。

2、 OutputSteam

2.1

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

当数据写入缓冲区时，它自动扩大。用 toByteArray() 和 toString() 能检索数据。

constructor

(A)--- ByteArrayOutputStream() 创建一个新的字节数组输出流。

(B)--- ByteArrayOutputStream() 创建一个新的字节数组输出流。

(C)--- ByteArrayOutputStream(int) 创建一个新的字节数组输出流，并带有指定大小字节的缓冲区容量。

toString(String) 根据指定字符编码将缓冲区内容转换为字符串，并将字节转换为字符。

write(byte[], int, int) 将指定字节数组中从偏移量 off 开始的 len 个字节写入该字节数组输出流。

write(int) 将指定字节写入该字节数组输出流。

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

2.2

FileOutputStream: 文件输出流是向 File 或 FileDescriptor 输出数据的一个输出流。

constructor

(A)FileOutputStream(File name) 创建一个文件输出流，向指定的 File 对象输出数据。

(B)FileOutputStream(FileDescriptor) 创建一个文件输出流，向指定的文件描述器输出数据。

(C)FileOutputStream(String name) 创建一个文件输出流，向指定名称的文件输出数据。

(D)FileOutputStream(String, boolean) 用指定系统的文件名，创建一个输出文件。

2.3

PipedOutputStream: 管道输出流是指一个通讯管道的发送端。一个线程通过管道输出流发送数据，

而另一个线程通过管道输入流读取数据，这样可实现两个线程间的通讯。

constructor

(A)PipedOutputStream() 创建一个管道输出流，它还未与一个管道输入流连接。

(B)PipedOutputStream(PipedInputStream) 创建一个管道输出流，它已连接到一个管道输入流。

( 二 )以字符为导向的 stream Reader/Writer

以 Unicode 字符为导向的 stream ，表示以 Unicode 字符为单位从 stream 中读取或往 stream 中写入信息。

Reader/Writer 为 abstact 类

以 Unicode 字符为导向的 stream 包括下面几种类型：

1. Reader

1.1

CharArrayReader ：与 ByteArrayInputStream 对应此类实现一个可用作字符输入流的字符缓冲区

constructor

CharArrayReader(char[]) 用指定字符数组创建一个 CharArrayReader 。

CharArrayReader(char[], int, int) 用指定字符数组创建一个 CharArrayReader

1.2

StringReader ：与 StringBufferInputStream 对应其源为一个字符串的字符流。

StringReader(String) 创建一新的串读取者。

1.3

FileReader ：与 FileInputStream 对应

1.4

PipedReader ：与 PipedInputStream 对应

2. Writer

2.1 CharArrayWrite ：与 ByteArrayOutputStream 对应

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

2.3 FileWrite ：与 FileOutputStream 对应

2.4 PipedWrite ：与 PipedOutputStream 对应

3、两种不同导向的 stream 之间的转换

3.1

InputStreamReader 和 OutputStreamReader ：

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

InputStreamReader 类是从字节流到字符流的桥梁：它读入字节，并根据指定的编码方式，将之转换为字符流。

使用的编码方式可能由名称指定，或平台可接受的缺省编码方式。

InputStreamReader 的 read() 方法之一的每次调用，可能促使从基本字节输入流中读取一个或多个字节。

为了达到更高效率，考虑用 BufferedReader 封装 InputStreamReader ，

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

例如： // 实现从键盘输入一个整数

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)// 当应用程序试图将字符串转换成一种数值类型，但该字符串不能转换为适当格式时，抛出该异常。
{
System.out.println(" 输入的不是数字 ");
}

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)// 当应用程序试图将字符串转换成一种数值类型，但该字符串不能转换为适当格式时，抛出该异常。 { System.out.println(" 输入的不是数字 "); }

InputStreamReader(InputStream) 用缺省的字符编码方式，创建一个 InputStreamReader 。

InputStreamReader(InputStream, String) 用已命名的字符编码方式，创建一个 InputStreamReader 。

OutputStreamWriter 将多个字符写入到一个输出流，根据指定的字符编码将多个字符转换为字节。

每个 OutputStreamWriter 合并它自己的 CharToByteConverter, 因而是从字符流到字节流的桥梁。

（三）Java IO 的一般使用原则：

一、按数据来源（去向）分类：

1 、是文件： FileInputStream, FileOutputStream, ( 字节流 )FileReader, FileWriter( 字符 )

2 、是 byte[] ： ByteArrayInputStream, ByteArrayOutputStream( 字节流 )

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

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

5 、网络数据流： InputStream, OutputStream,( 字节流 ) Reader, Writer( 字符流 )

二、按是否格式化输出分：

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

三、按是否要缓冲分：

1 、要缓冲： BufferedInputStream, BufferedOutputStream,( 字节流 ) BufferedReader, BufferedWriter( 字符流 )

四、按数据格式分：

1 、二进制格式（只要不能确定是纯文本的） : InputStream, OutputStream 及其所有带 Stream 结束的子类

2 、纯文本格式（含纯英文与汉字或其他编码方式）； Reader, Writer 及其所有带 Reader, Writer 的子类

五、按输入输出分：

1 、输入： Reader, InputStream 类型的子类

2 、输出： Writer, OutputStream 类型的子类

六、特殊需要：

1 、从 Stream 到 Reader,Writer 的转换类： InputStreamReader, OutputStreamWriter

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

3 、进程间通信： PipeInputStream, PipeOutputStream, PipeReader, PipeWriter

4 、合并输入： SequenceInputStream

5 、更特殊的需要： PushbackInputStream, PushbackReader, LineNumberInputStream, LineNumberReader

决定使用哪个类以及它的构造进程的一般准则如下（不考虑特殊需要）：

首先，考虑最原始的数据格式是什么：原则四

第二，是输入还是输出：原则五

第三，是否需要转换流：原则六第 1 点

第四，数据来源（去向）是什么：原则一

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

第六，是否要格式化输出：原则二

出处：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操作（三：流的使用）

石头@ — Sat, 25 Jul 2009 12:24:00 GMT

1: 分割符输出
     可以确定自己的分割符，“|”，“：”，等等，
     如果在要保留的字符串中存在一个分割符，
2：字符串记号处理器
    当读取一行输入时，会得到很长的一个字符串，有时需要将它分割为独立的字符串，这时就需要找出其中的分割符且将它分离成单独的片段， java.util中的StringToKenizer类就是为这个目的设计的，它提供了一个很简单的方法来分隔带分隔符文本的字符串，思路是：将字符串记号处理器对象附在字符串上，当构造字符串记号处理器对象时，要指定哪些字符是分割符， eg:
                     StringTokenizer tokenizer = new StringTokenizer(line,"|");
也可在在字符串中指定多个分割符， eg:
                     StringTokenizer tokenizer = new StringTokenizer(line,"|,:");
这就意味着字符串中的任意字符都能做为分割符出现。如果不指定分割符，则默认为"\t\n\r"

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

石头@ 2009-07-25 20:24 发表评论

java中的io 操作(—：类的框架)

石头@ — Sat, 25 Jul 2009 12:04:00 GMT

最经学习了java io包中的类，对io 操作熟悉了点，写点东西整理一下自己的思路。

首先回顾一下这些类的框架；

石头@ 2009-07-25 20:04 发表评论

java中的transient关键字

石头@ — Thu, 23 Jul 2009 11:25:00 GMT

在对象传输的情况下,有些域是"瞬时的",也就是说只与当前进程环境相关,出了这个进程就没有意义了,这样的域是"本地化的",没有序列化的价值,标为瞬时态的.

Java 的serialization提供了一种持久化对象实例的机制。当持久化对象时，可能有一个特殊的对象数据成员，我们不想用serialization机制来保存它。为了在一个特定对象的一个域上关闭serialization，可以在这个域前加上关键字transient。

transient是Java语言的关键字，用来表示一个域不是该对象串行化的一部分。当一个对象被串行化的时候，transient型变量的值不包括在串行化的表示中，然而非transient型的变量是被包括进去的。

首先，让我们看一些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;
    }
}

现在我们创建一个这个类的实例，并且串行化(serialize)它 ,然后将这个串行化对象写入磁盘。

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}

如果我们运行这段代码，我们会注意到从磁盘中读回(read——back (de-serializing))的对象打印password为"NOT SET"。这是当我们定义pwd域为transient时，所期望的正确结果。
现在，让我们来看一下粗心对待transient域可能引起的潜在问题。假设我们修改了类定义，提供给transient域一个默认值，
代码如下：

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的一个实例，将它写入磁盘，并且再将它从磁盘中读出，我们仍然看到读回的对象打印password 为 "NOT SET"。当从磁盘中读出某个类的实例时，实际上并不会执行这个类的构造函数，而是载入了一个该类对象的持久化状态，并将这个状态赋值给该类的另一个对象。

摘自：http://www.devx.com/tips/Tip/13726

石头@ 2009-07-23 19:25 发表评论

java中的native关键字

石头@ — Wed, 22 Jul 2009 14:11:00 GMT

JNI是Java Native Interface的缩写。从Java 1.1开始，Java Native Interface (JNI)标准成为java平台的一部分，它允许Java代码和其他语言写的代码进行交互。JNI一开始是为了本地已编译语言，尤其是C和C++而设计的，但是它并不妨碍你使用其他语言，只要调用约定受支持就可以了。

使用java与本地已编译的代码交互，通常会丧失平台可移植性。但是，有些情况下这样做是可以接受的，甚至是必须的，比如，使用一些旧的库，与硬件、操作系统进行交互，或者为了提高程序的性能。JNI标准至少保证本地代码能工作在任何Java 虚拟机实现下。

JNI（Java Native Interface）的书写步骤

      ·编写带有native声明的方法的java类
      ·使用javac命令编译所编写的java类
      ·使用javah ?jni java类名生成扩展名为h的头文件
      ·使用C/C++（或者其他编程想语言）实现本地方法
      ·将C/C++编写的文件生成动态连接库

1) 编写java程序：
这里以HelloWorld为例。
代码1：
class HelloWorld {
public native void displayHelloWorld();

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

public static void main(String[] args) {
new HelloWorld().displayHelloWorld();
}
}
声明native方法：如果你想将一个方法做为一个本地方法的话，那么你就必须声明改方法为native的，并且不能实现。其中方法的参数和返回值在后面讲述。
Load 动态库：System.loadLibrary("hello");加载动态库（我们可以这样理解：我们的方法displayHelloWorld()没有实现，但是我们在下面就直接使用了，所以必须在使用之前对它进行初始化）这里一般是以static块进行加载的。同时需要注意的是 System.loadLibrary();的参数“hello”是动态库的名字。
main()方法
2) 编译没有什么好说的了
javac HelloWorld.java
3) 生成扩展名为h的头文件
javah ?jni HelloWorld
头文件的内容：
/* 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
（这里我们可以这样理解：这个h文件相当于我们在java里面的接口，这里声明了一个Java_HelloWorld_displayHelloWorld (JNIEnv *, jobject);方法，然后在我们的本地方法里面实现这个方法，也就是说我们在编写C/C++程序的时候所使用的方法名必须和这里的一致）。
4) 编写本地方法
实现和由javah命令生成的头文件里面声明的方法名相同的方法。
代码2：
1 #include
2 #include "HelloWorld.h"
3 #include

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

JNI（Java Native Interface）调用中考虑的问题

在首次使用JNI的时候有些疑问，后来在使用中一一解决，下面就是这些问题的备忘：

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

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

      3. 将c中获取的一个char*的buffer传递给java？
这个char*如果是一般的字符串的话，作为string传回去就可以了。如果是含有’\0’的buffer，最好作为bytearray传出，因为可以制定copy的length，如果copy到string，可能到’\0’就截断了。
      有两种方式传递得到的数据：
      一种是在jni中直接new一个byte数组，然后调用函数(*env)->SetByteArrayRegion(env, bytearray, 0, len, buffer);将buffer的值copy到bytearray中，函数直接return bytearray就可以了。
      一种是return错误号，数据作为参数传出，但是java的基本数据类型是传值，对象是传递的引用，所以将这个需要传出的byte数组用某个类包一下，如下：
class RetObj
{
public byte[] bytearray;
}
这个对象作为函数的参数retobj传出，通过如下函数将retobj中的byte数组赋值便于传出。代码如下：
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，如何传递出去呢？
在jni的c文件中new出空间，传递出去。java的数据不初始化，指向传递出去的空间即可。

转自：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

在数学运算当中经常会涉及到判断两个数是否相等的情况
对于整数很好处理 A==B这样的一个语句就可以解决全部的问题
但是对于浮点数是不同的

首先，浮点数在计算机当中的二进制表达方式就决定了大多数浮点数都是无法精确的表达的
现在的计算机大部分都是数字计算机，不是模拟机，数字机的离散化的数据表示方法自然无法精确表达大部分的数据量的。

其次计算机浮点数的精度在单精度float类型下，只有7位，在进行浮点运算的时候，这个精度往往会导致运算的结果和实际期望的结果之间有误差

因为前两个原因，我们很难用 A==B来判定两个浮点数是否相同

很自然，我们可以想到 fabs(A-B) < epsilon 这样的一种判别方法
但是这种判别方法稳妥吗？
它也不稳妥。

首先， epsilon是一个绝对的数据，也就是误差分析当中说说的绝对误差
使用一个固定的数值，对于float类型可以表达的整个数域来说是不可以的
比如epsilon取值为0.0001，而a和b的数值大小也是0.0001附近的，那么显然不合适
另外对于a和b大小是10000这样的数据的时候，它也不合适，因为10000和10001也可以认为是相等的呢
适合它的情况只是a或者b在1或者0附近的时候

既然绝对误差不可以，那么自然的我们就会想到了相对误差
bool IsEqual(float a, float b, float relError ) {
       return ( fabs ( (a-b)/a ) < relError ) ? true : false;
}
这样写还不完善，因为是拿固定的第一个参数做比较的，那么在调用
IsEqual(a, b, relError ) 和 IsEqual(b, a, relError ) 的时候，可能得到不同的结果
同时如果第一个参数是0的话，就有可能是除0溢出
这个可以改造
把除数选取为a和b当中绝对数值较大的即可
bool IsEqual(float a, float b, relError )
{
      if (fabs(a) relError ) ? true : false;
      return (fabs( (a-b)/b) > relError ) ? true : false;
};

使用相对误差就很完善吗？
也不是，在某些特殊情况下，相对误差也不能代表全部
比如在判断空间三点是否共线的时候，使用判断点到另外两个点形成的线段的距离的方法的时候
只用相对误差是不够的，应为线段距离可能很段，也可能很长，点到线段的距离，以及线段的长度做综合比较的时候，需要相对误差和绝对误差结合的方式才可以
相对完整的比较算法应该如下：
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;
}
这样才相对完整

这仅仅是浮点数之间最初级的比较方法
高级的方法看浮点数比较（二）这个文章 —— 如何把两个浮点数之间的比较转化成为两个整数之间的比较。
-------------------------------------

浮点数的内存结构

根据IEEE的标准，浮点数的定义如下

	符号位	指数位	小数部分	指数偏移量
单精度浮点数	1 位[31]	8位 [30-23]	23位 [22-00]	127
双精度浮点数	1 位[63]	11 位[62-52]	52 位[51-00]	1023

我们以单精度浮点数来说明：
符号位，表述浮点数的正或者负
指数实际也有正负的，但是没有单独的符号位，而是采用了一个偏移来表示
在计算机的世界里，进位都是二进制的，指数表示的也是2的N次幂
这个数据格式当中的，指数是8位，可表达的范围是0到255
而对应的实际的指数是－127到＋128
这里特殊说明，－127和＋128这两个数据在IEEE当中是保留的用作多种用途的
－127表示的数字是0
128和其他位数组合表示多种意义，最典型的就是NAN状态

小数部分，并不是一个浮点数的实际的小数
实际的小数在这个小数前面还保留了一个1
拿浮点数1.0来说
符号位是0，实际指数是0，对应这里的指数就是127了，也就是0x7f
而小数部分就是1.0了， 1是暗含的不存储，实际的小数部分就是0了
因此组合起来的数据就是，0x3f80000

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

int m_nFra: 23;

int m_nExp : 8;

bool m_bSign : 1;

};
};

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

参考IEEE的浮点数格式说明
对于0到1范围内的浮点数是可以压缩的

显然在0到1的范围内，一个单精度的浮点数，指数和符号位占据9个bit
而这9个bit是可以不用的，把它去除，只保留小数部分的23bit就可以达到压缩的目的
可以把一个浮点数从32bit，4字节压缩到23bit，3字节的范围内

这也是在3dmax等一些工具软件当中对浮点数进行压缩存储的方法。
比如，在单位化的法向量当中，每个浮点数都是0，1范围之间的数据
正常情况下表示三维空间当中的单位化法向量就需要12个字节
而经过这个压缩处理，只需要9个字节

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

在写了上篇浮点数的比较以及浮点数内存结构两篇文章后
对于浮点数的比较有新的想法

我们先看正数的情况
根据IEEE的内存结构，指数在高位，尾数在低位
浮点数大的对应的把其内存结构按照整数来理解进行比较的时候，情况也是成立的
因此在这里如果把他们进行比较的话，作为整数运算效率会非常的高，比如
float f1 = 1.23;
float f2 = 1.24
f1 > f2 成立
(int&)f1 > (int&)f2 也是成立的

而且，仔细研究IEEE的浮点结构，可以发现在《浮点数比较》当中提到的浮点数精度的问题——不是所有的浮点数都可以精确的表达
可以精确表达的浮点数实际上是有限的，就是那些IEEE的各种情况的枚举了 2^32个。不能表达的占据了大多数

IEEE在32位的情况下，尾数是23位的（暗含了第一个位数是1）
对于可以精确表达的浮点数来说，如果我们把这23位当作整数来理解，它加1，就意味着可以找到比当前对应浮点数大的最小的浮点数了
反之，我们把两个浮点数，对应的整数做差值运算，得到的整数表明的是两个浮点数之间有多少个实际可以表达的浮点数（对应的指数相同的情况下很好理解；指数不同的时候，也是同样有效的）

这样，对于两个正的浮点数，他们的大小比较就可以用 (int&)f1 - (int&)f2 来进行比较了
差值的结果实际上就应该是相对误差了
这个相对误差，不等同于普遍意义上的相对误差
它所表达的是，两个浮点数之间可能还有多少个可以精确表达的浮点数
这样通过指定这个阈值来控制两个浮点数的比较就更有效了
对于两个正的浮点数
bool IsEqual(float f1, float f2, int absDelta)
{
     if ( abs ( (int&)f1 - (int&)f2 ) < absDelta ) return true;
}
这里用abs而不是fabs这在asm上面的运算差距也是很大的了

对于两个负数进行比较的情况也是相同的
只不过负数内存对应的整数加1，相应的找到的是更小的负数而已

但是负数和整数之间现在还不能进行直接的比较，因为根据IEEE的内存结构
正数和负数是不同的，对应的整数不能连续
正的最小的数就是0了，对应的整数也是0x00000000
负的最小的数就是－0，对应的整数则是0x 80000000
不用奇怪－0
在IEEE的表达当中是有两个0的，一个是 +0 一个是-0

有趣的是，按照 f1 == f2 的判断 +0和-0是相等的

通过对比我们可以发现，
+0 和正的浮点数可以按照转换成为整数的方式直接进行比较
-0 和负的浮点数可以按照转换成为整数的方式直接进行比较

如果我们能够把他们连接起来，整个整数方式的直接比较就完备了
对比一下负数的结构，可以找到一个简单的办法了：
        把负数内存对应的整数减去 -0 ，他们就连续了
而且更好的结果是，所有的负数经过这次减法后，对应的整数也都是负数了
这样整个整数比较就变得连续了，而且在整个浮点数范围内都是有效的了

最后的比较算法就是：
// 函数:   bool IsEqual(float f1, float f2, int absDelta)
// 功能：把比较两个浮点数是否近似相同
// 输入：f1, f2参与比较的两个浮点数
//               absDelta 两个浮点数之间允许有多少个其他可以精确表达的浮点数存在，相当于相对误差
// 输出:   true，两个浮点数进行相等； false 两个浮点数不等
// 注意：仅仅适合IEEE 32位浮点数结构
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 发表评论

byte型数组转化成无符号整型的函数

石头@ — 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 发表评论

java中的对象名与c++中的指针和引用的区别！

石头@ — Mon, 29 Jun 2009 10:41:00 GMT

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

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

*
*/

这段代码的主要部分调用了两个很相近的方法，changeObj()和changePri()。唯一不同的是它们一个把对象作为输入参数，另一个把 Java中的基本类型int作为输入参数。并且在这两个函数体内部都对输入的参数进行了改动。看似一样的方法，程序输出的结果却不太一样。 changeObj()方法真正的把输入的参数改变了，而changePri()方法对输入的参数没有任何的改变。

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

除了在函数传值的时候是"引用传递"，在任何用"＝"向对象变量赋值的时候都是"引用传递"。如：

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);

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

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

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

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

Hashtable真的能存储对象吗？

看一看下面的很简单的代码，先是声明了一个Hashtable和StringBuffer对象，然后分四次把StriingBuffer对象放入到 Hashtable表中，在每次放入之前都对这个StringBuffer对象append()了一些新的字符串：

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());
}
}
}

如果你认为输出的结果是：
get StringBufffer 1 from Hashtable: abc,
get StringBufffer 2 from Hashtable: abc,def，
get StringBufffer 3 from Hashtable: abc,def,mno,
get StringBufffer 4 from Hashtable: abc,def,mno,xyz.

那么你就要回过头再仔细看一看上一个问题了，把对象时作为入口参数传给函数，实质上是传递了对象的引用，向Hashtable传递 StringBuffer对象也是只传递了这个StringBuffer对象的引用！每一次向Hashtable表中put一次 StringBuffer，并没有生成新的StringBuffer对象，只是在Hashtable表中又放入了一个指向同一StringBuffer对象的引用而已。

对Hashtable表存储的任何一个StringBuffer对象（更确切的说应该是对象的引用）的改动，实际上都是对同一个"StringBuffer"的改动。所以Hashtable并不能真正存储能对象，而只能存储对象的引用。也应该知道这条原则对与Hashtable 相似的Vector, List, Map, Set等都是一样的。

上面的例程的实际输出的结果是：

/* 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.
*/

类，对象与引用

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

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

但由于没有相应的引用，对这个对象的使用也只能局限这条语句中了。

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

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

没有办法阻止对引用的改动。
什么是"clone"？

在实际编程过程中，我们常常要遇到这种情况：有一个对象A，在某一时刻A中已经包含了一些有效值，此时可能会需要一个和A完全相同新对象B，并且此后对B 任何改动都不会影响到A中的值，也就是说，A与B是两个独立的对象，但B的初始值是由A对象确定的。在Java语言中，用简单的赋值语句是不能满足这种需求的。要满足这种需求虽然有很多途径，但实现clone（）方法是其中最简单，也是最高效的手段。

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

怎样应用clone()方法？

一个很典型的调用clone()代码如下：

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类实现了Cloneable接口，这个接口属于java.lang 包，java.lang包已经被缺省的导入类中，所以不需要写成java.lang.Cloneable。另一个值得请注意的是重载了clone()方法。最后在clone()方法中调用了super.clone()，这也意味着无论clone类的继承结构是什么样的，super.clone()直接或间接调用了java.lang.Object类的clone()方法。下面再详细的解释一下这几点。

应该说第三点是最重要的，仔细观察一下Object类的clone()一个native方法，native方法的效率一般来说都是远高于java中的非 native方法。这也解释了为什么要用Object中clone()方法而不是先new一个类，然后把原始对象中的信息赋到新对象中，虽然这也实现了 clone功能。对于第二点，也要观察Object类中的clone()还是一个protected属性的方法。这也意味着如果要应用clone()方法，必须继承Object类，在Java中所有的类是缺省继承Object类的，也就不用关心这点了。然后重载clone()方法。还有一点要考虑的是为了让其它类能调用这个clone类的clone()方法，重载之后要把clone()方法的属性设置为public。

那么clone类为什么还要实现Cloneable接口呢？稍微注意一下，Cloneable接口是不包含任何方法的！其实这个接口仅仅是一个标志，而且这个标志也仅仅是针对Object类中clone()方法的，如果clone类没有实现Cloneable接口，并调用了Object的clone()方法（也就是调用了super.Clone()方法），那么Object的clone()方法就会抛出 CloneNotSupportedException异常。

以上是clone的最基本的步骤，想要完成一个成功的clone，还要了解什么是"影子clone"和"深度clone"。

什么是影子clone？

下面的例子包含三个类UnCloneA，CloneB，CloneMain。CloneB类包含了一个UnCloneA的实例和一个int类型变量，并且重载clone()方法。CloneMain类初始化UnCloneA类的一个实例b1，然后调用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){

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类型的变量aInt和UnCloneA的实例对象unCA的clone结果不一致，int类型是真正的被clone了，因为改变了 b2中的aInt变量，对b1的aInt没有产生影响，也就是说，b2.aInt与b1.aInt已经占据了不同的内存空间，b2.aInt是 b1.aInt的一个真正拷贝。相反，对b2.unCA的改变同时改变了b1.unCA，很明显，b2.unCA和b1.unCA是仅仅指向同一个对象的不同引用！从中可以看出，调用Object类中clone()方法产生的效果是：先在内存中开辟一块和原始对象一样的空间，然后原样拷贝原始对象中的内容。对基本数据类型，这样的操作是没有问题的，但对非基本类型变量，我们知道它们保存的仅仅是对象的引用，这也导致clone后的非基本类型变量和原始对象中相应的变量指向的是同一个对象。

大多时候，这种clone的结果往往不是我们所希望的结果，这种clone也被称为"影子clone"。要想让b2.unCA指向与b2.unCA不同的对象，而且b2.unCA中还要包含b1.unCA中的信息作为初始信息，就要实现深度clone。

怎么进行深度clone？

把上面的例子改成深度clone很简单，需要两个改变：一是让UnCloneA类也实现和CloneB类一样的clone功能（实现Cloneable接口，重载clone()方法）。二是在CloneB的clone()方法中加入一句o.unCA = (UnCloneA)unCA.clone();

程序如下：

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("=================================");

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
*/

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

要知道不是所有的类都能实现深度clone的。例如，如果把上面的CloneB类中的UnCloneA类型变量改成StringBuffer类型，看一下 JDK API中关于StringBuffer的说明，StringBuffer没有重载clone()方法，更为严重的是StringBuffer还是一个 final类，这也是说我们也不能用继承的办法间接实现StringBuffer的clone。如果一个类中包含有StringBuffer类型对象或和 StringBuffer相似类的对象，我们有两种选择：要么只能实现影子clone，要么就在类的clone()方法中加一句（假设是 SringBuffer对象，而且变量名仍是unCA）： o.unCA = new StringBuffer(unCA.toString()); //原来的是：o.unCA = (UnCloneA)unCA.clone();

还要知道的是除了基本数据类型能自动实现深度clone以外，String对象是一个例外，它clone后的表现好象也实现了深度clone，虽然这只是一个假象，但却大大方便了我们的编程。

Clone中String和StringBuffer的区别

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

下面的例子中包括两个类，CloneC类包含一个String类型变量和一个StringBuffer类型变量，并且实现了clone()方法。在 StrClone类中声明了CloneC类型变量c1，然后调用c1的clone()方法生成c1的拷贝c2，在对c2中的String和 StringBuffer类型变量用相应的方法改动之后打印结果：

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类型的变量好象已经实现了深度clone，因为对c2.str的改动并没有影响到c1.str！难道Java把 Sring类看成了基本数据类型？其实不然，这里有一个小小的把戏，秘密就在于c2.str = c2.str.substring(0,5)这一语句！实质上，在clone的时候c1.str与c2.str仍然是引用，而且都指向了同一个 String对象。但在执行c2.str = c2.str.substring(0,5)的时候，它作用相当于生成了一个新的String类型，然后又赋回给c2.str。这是因为String被 Sun公司的工程师写成了一个不可更改的类（immutable class），在所有String类中的函数都不能更改自身的值。下面给出很简单的一个例子：

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()方法，但str1的值并没有改变。类似的，String类中的其它方法也是如此。当然如果我们把最上面的例子中的这两条语句

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

改成下面这样：

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

去掉了重新赋值的过程，c2.str也就不能有变化了，我们的把戏也就露馅了。但在编程过程中只调用

c2.str.substring(0,5);

语句是没有任何意义的。

应该知道的是在Java中所有的基本数据类型都有一个相对应的类，象Integer类对应int类型，Double类对应double类型等等，这些类也与String类相同，都是不可以改变的类。也就是说，这些的类中的所有方法都是不能改变其自身的值的。这也让我们在编clone类的时候有了一个更多的选择。同时我们也可以把自己的类编成不可更改的类。

石头@ 2009-06-29 18:41 发表评论

BlogJava-海阔天空-文章分类-java_base

优化你的java代码性能

一、避免在循环条件中使用复杂表达式

二、为'Vectors' 和 'Hashtables'定义初始大小

三、在finally块中关闭Stream

四、使用'System.arraycopy ()'代替通过来循环复制数组

五、让访问实例内变量的getter/setter方法变成”final”

六、避免不需要的instanceof操作

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

八、如果只是查找单个字符的话，用charAt()代替startsWith()

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

十、使用移位操作代替'a * b'

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

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

十三、将try/catch块移出循环

十四、对于boolean值，避免不必要的等式判断

十五、对于常量字符串，用'String' 代替 'StringBuffer'

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

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

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

十九、不要在循环体中实例化变量

二十、确定 StringBuffer的容量

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

二十二、不要总是使用取反操作符(!)

二十三、与一个接口 进行instanceof操作

java内存泄漏

JVM的载入

java程序的运行机制

如何“快速”掌握一门语言

java中进行callback方法调用

java reference

数据类型转换

java从控制台读入数据的方法

StringIndexOutOfBoundException 引出的对String类的看法

有点变态的问题

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

【转】JAVA常见十大异常

很有深度的几个java题目！

java io系统概述

java IO中的Decorator模式

java中的io操作（三：流的使用）

java中的io 操作(—：类的框架)

java中的transient关键字

java中的native关键字

浮点数比较

浮点数的内存结构

byte型数组转化成无符号整型 的函数

java中的对象名与c++中的指针和引用的区别！

二十三、与一个接口进行instanceof操作

byte型数组转化成无符号整型的函数