BlogJava-lsbwahaha-随笔分类-java基础

java的4种Reference探讨

胡鹏 — Sun, 30 Oct 2011 03:59:00 GMT

摘要: java中的引用分为4种：String Reference， WeakReference， softReference，PhantomReference Strong Reference: 我们平常用的最多的就是强引用了如：String s = new String("opps");这种形式的引用称为强引用，这种引用有以下几个特点 1.强引用可以直接访问目标对象&... 阅读全文

胡鹏 2011-10-30 11:59 发表评论

理解java中的ThreadLocal

胡鹏 — Sat, 29 Oct 2011 09:39:00 GMT

摘要: 一、对ThreadLocal概术 JDK API 写道：该类提供了线程局部 (thread-local) 变量。这些变量不同于它们的普通对应物，因为访问某个变量（通过其 get 或 set 方法）的每个线程都有自己的局部变量，它独立于变量的初始... 阅读全文

胡鹏 2011-10-29 17:39 发表评论

Concurrent学习—Executor框架

胡鹏 — Wed, 12 Oct 2011 09:25:00 GMT

摘要: java.util.concurrent包分成了三个部分，分别是： ... 阅读全文

胡鹏 2011-10-12 17:25 发表评论

TrueZIP使用过程中遇到的问题记录

胡鹏 — Tue, 11 Jan 2011 14:30:00 GMT

最近有Java解压缩的需求，java.util.zip实在不好用，对中文支持也不行。所以选择了强大的TrueZIP，使用时遇到了一个问题，做个记录。
解压缩代码如下：

ArchiveDetector detector = new DefaultArchiveDetector(ArchiveDetector.ALL,

        new Object[] { "zip", new CheckedZip32Driver("GBK") } );

File zipFile = new File("zipFile", detector);

File dst = new File("dst");

// 解压缩

zipFile.copyAllTo(dst);

代码十分简洁，注意这个File是

de.schlichtherle.io.File

不是

java.io.File

当处理完业务要删除这个Zip File时，问题出现了：
这个文件删不掉！！！
把自己的代码检查了好久，确认没问题后，开始从TrueZIP下手，发现它有特殊的地方的，是提示过的：

File file = new File(“archive.zip”); // de.schlichtherle.io.File!
Please do not do this instead:
de.schlichtherle.io.File file = new de.schlichtherle.io.File(“archive.zip”);

This is for the following reasons:
1.Accidentally using java.io.File and de.schlichtherle.io.File instances referring to the same path concurrently will result in erroneous behaviour and may even cause loss of data! Please refer to the section “Third Party Access” in the package Javadoc of de.schlichtherle.io for for full details and workarounds.
2.A de.schlichtherle.io.File subclasses java.io.File and thanks to polymorphism can be used everywhere a java.io.File could be used.

原来两个File不能交叉使用，搞清楚原因了，加这么一句代码搞定。

zipFile.deleteAll();

胡鹏 2011-01-11 22:30 发表评论

antlr简介

胡鹏 — Fri, 17 Dec 2010 11:20:00 GMT

http://www.blogjava.net/Files/lsbwahaha/ANTLR_info.pdf
antlr简介

目前的ANTLR支持的语法层的选项主要包括：

语言选项（Language）、

输出选项（output）、

回溯选项（backtrack）、

记忆选项（memorize）、

记号词库（tokenVocab）、

重写选项（rewrite）、

超类选项（superClass）、

过滤选项（Filter）、

AST标签类型（ASTLabelType）

K选项

/**

        //一些写法















k=2;

backtrack=true;

memoize=true;

1. 语言选项 language

语言选项指定了ANTLR将要产生的代码的目标语言，默认情况下该选项设置为了Java。需要注意的是，ANTLR中的嵌入的动作必须要使用目标语言来写。

grammar T;
options {
language=Java;
}

ANTLR使用了特有的基于字串模板（StringTemplate-based）代码生成器，构建一个新的目标语言显得较为简单，因此我们可以构建多种语言，诸如Java，C，C++，C#，Python，Objective-C，Ruby等等。语言选项让ANNTLR去模板目录（例如 org/antlr/codegen/templates/Java or org/antlr/codegen/templates/C）下寻找合适的模板,并使用模板来构建语言。该目录下包含大量的模板，我们可以向其中加入其他的模板以满足我们的需求。

2. 输出选项 output

输出选项控制了ANTLR输出的数据结构，目前支持两种输出：抽象语法树——AST（Abstract Syntax Trees）和字串模板（StringTemplates）——template。当output这个选项被设置后，所有的规则都被输出成了AST或者 template。

grammar T;
options {
output=AST;
}

3. 回溯选项backtrack

当回溯选项打开的时候，在执行一个LL(K)失败的时候，ANTLR会返回至LL(K)开始而尝试其他的规则。

4. 记忆选项 （memorize）

memoize选项打开以后，每条解析方法（Paser Method）开始之前，ANTLR会首先检测以前的尝试结果，并在该方法执行完成之后记录该规则是否执行成功。但是注意，对于单条的规则打开此选项经常比在全局上打开该规则效率更高。

5. 记号词库（tokenVocab）

说白了就是output输出目录中的XX.tokens文件中的定义可以方便的给大型工程中多个.g中的符号同步更新。

大型的工程中常常利用AST作为中间产物对输入进行多次分析并最终生成代码。对AST的遍历时需要经常使用树语法（tree grammar），而tree grammar中经常需要将符号与其他的文件中的符号进行同步或者更新。tokenVocab实现了这个功能。
例如我们定义了下面的一个语法文件：

grammar P;
options {
   output=AST;
}
expr: INT ('+' ^ INT)* ;
INT : '0'..'9' +;
WS : ' ' | '\r' | '\n' ;
利用该文件生成了一个标记：P.token，并生成了语法树（AST）。这时我们需要一个用于遍历该AST的tree grammar，并通过tree grammar 中的tokenVocab选项来向其中更新tokens:

tree grammar Dump;
options {
   tokenVocab=P;
   ASTLabelType=CommonTree;
}
expr: ^( '+' expr {System.out.print('+' );} expr )
   | INT {System.out.print($INT.text);}
   ;

编译tree grammar的时候ANTLR默认会在当前目录下寻找.token文件，我们可以通过-lib选项来设置用于寻找.token文件的目录，例如：
java org.antlr.Tool -lib . Dump.g

6. 重写选项（rewrite）

通过重写选项可以改变ANTLR对输入的默认处理规则，一般用在输出为template的情况下。将该选项使能之后，ANTLR将一般的输入直接拷贝至输出，而将适于模板重写规则的输入做其他的处理。

7. 超类选项（superClass）

用于指定一个超类。

8. 过滤选项（Filter）

9. AST标签类型（ASTLabelType）

10. K选项

K选项用于限制对LL(K)进行语法分析的次数，从而提高了ANTLR的解析速度。K只能为*或者数字，默认为*。

属性和动作

动作（Actions）实际上是用目标语言写成的、嵌入到规则中的代码（以花括号包裹）。它们通常直接操作输入的标号，但是他们也可以用来调用相应的外部代码。属性，到目前为止我的理解还不多，感觉像是C++中类里面的成员，一会看完应该会更清楚一些。

1. 语法动作（Grammar Actions）
动作（Actions）是指嵌在语法中的、用目标语言写成的代码片段。ANTLR则把这些代码（除了用$或%标记的以外）逐字地插入到生成的识别器中。
动作可以放到规则的外边，也可以嵌入到某条规则当中。当动作位于规则之外时候，这些动作同城定义了一些全局的或者是类的成员（变量或者成员函数）；而当其嵌入规则之中时，则用于执行某些特定的命令，这些命令在识别器识别了其预订的字符的时候就会开始执行。例如下面的例子：

parser grammar T;
@header {
   package p;
}
@members {
   int i;
   public TParser(TokenStream input, int foo) {
       this(input);
       i = foo;
   }
}
a[int x] returns [int y]
@init {int z=0;}
@after {System.out.println("after matching rule; before finally");}
: {《action1》} A {《action2 》}
;
catch[RecognitionException re] {
   System.err.println("error");
}
finally { 《do-this-no-matter-what 》 }

从中可以看出，前面的两个动作，@head and @members是两个处于规则之外的全局的动作，定义了一些变量和类；而后两个则分别在a这个规则的前后执行（@init在前，@after在后，这个在前面提到过）。这里针对两种类型详细叙述。

antlr简介

胡鹏 2010-12-17 19:20 发表评论

责任链中：但个中的处理

胡鹏 — Sun, 15 Aug 2010 12:52:00 GMT

public class CheckQueryParams {

    private static interface Validation{
void check(QueryInfo query);
    }

    private static List validations = new ArrayList();

    static {
validations.add(new Validation() {
     public void check(QueryInfo query) {
  if(StringUtils.isEmpty(query.getStartKey()) && StringUtils.isEmpty(query.getEndKey()))
      throw new RuntimeException("Both keys can not be null or empty at the same time");
     }});
    }

    public static void check(QueryInfo query) {
for(Validation validation : validations) {
     validation.check(query);
}
    }
}

胡鹏 2010-08-15 20:52 发表评论

用linkList实现LRU算法

胡鹏 — Sun, 15 Aug 2010 12:33:00 GMT

public class LRUCache {

    final private int capacity;
    final private Map> map;
    final private ReentrantLock lock = new ReentrantLock();
    final private ReferenceQueue> queue = new ReferenceQueue>();

    public LRUCache(int capacity) {
this.capacity = capacity;
map = new LinkedHashMap>(capacity,1f,true){
     @Override
     protected boolean removeEldestEntry(Map.Entry> eldest) {
         return this.size() > LRUCache.this.capacity;
     }
};
    }

    public V put(K key,V value) {
lock.lock();
try {
map.put(key, new SoftReference(value,queue));
return value;
}finally {
     lock.unlock();
}
    }

    public V get(K key) {
lock.lock();
try {
     queue.poll();
     return map.get(key).get();
}finally {
     lock.unlock();
}
    }

    public void remove(K key) {
lock.lock();
try {
     map.remove(key);
}finally {
     lock.unlock();
}
    }

}

胡鹏 2010-08-15 20:33 发表评论

java collection framework 的一些比较使用的记录

胡鹏 — Fri, 18 Dec 2009 09:13:00 GMT

Collection接口由 Set接口和 List接口继承。

Set 被 Vector . ArrayList LinkedList 实现。

      List 被 HashSet TreeSet 实现。

Map接口由 HashTable HashMap TreeMap 实现。

下面看下每个实现类的特征；；；--》(转的。)

1. List (有重复、有序)

Vector基于Array的List，性能也就不可能超越Array，并且Vector是“sychronized”的，这个也是Vector和ArrayList的唯一的区别。

ArrayList：同Vector一样是一个基于Array的，但是不同的是ArrayList不是同步的。所以在性能上要比Vector优越一些，但是当运行到多线程环境中时，可需要自己在管理线程的同步问题。从其命名中可以看出它是一种类似数组的形式进行存储，因此它的随机访问速度极快。

数据增长:当需要增长时,Vector默认增长为原来一培，而ArrayList却是原来的一半

LinkedList：LinkedList不同于前面两种List，它不是基于Array的，所以不受Array性能的限制。它每一个节点（Node）都包含两方面的内容：1.节点本身的数据（data）；2.下一个节点的信息（nextNode）。所以当对LinkedList做添加，删除动作的时候就不用像基于Array的List一样，必须进行大量的数据移动。只要更改nextNode的相关信息就可以实现了所以它适合于进行频繁进行插入和删除操作。这就是LinkedList的优势。Iterator只能对容器进行向前遍历，而 ListIterator则继承了Iterator的思想，并提供了对List进行双向遍历的方法。
用在FIFO，用addList()加入元素 removeFirst()删除元素
用在FILO,用addFirst()/removeLast()
ListIterator 提供双向遍历next() previous()，可删除、替换、增加元素

List总结： 1. 所有的List中只能容纳单个不同类型的对象组成的表，而不是Key－Value键值对。例如：[ tom,1,c ]； 2. 所有的List中可以有相同的元素，例如Vector中可以有 [ tom,koo,too,koo ]； 3. 所有的List中可以有null元素，例如[ tom,null,1 ]； 4. 基于Array的List（Vector，ArrayList）适合查询，而LinkedList（链表）适合添加，删除操作。

2. Set

HashSet：虽然Set同List都实现了Collection接口，但是他们的实现方式却大不一样。List基本上都是以Array为基础。但是Set则是在HashMap的基础上来实现的，这个就是Set和List的根本区别。HashSet的存储方式是把HashMap中的Key作为Set的对应存储项，这也是为什么在Set中不能像在List中一样有重复的项的根本原因，因为HashMap的key是不能有重复的。HashSet能快速定位一个元素，但是放到HashSet中的对象需要实现hashCode()方法0。

TreeSet则将放入其中的元素按序存放，这就要求你放入其中的对象是可排序的，这就用到了集合框架提供的另外两个实用类Comparable和Comparator。一个类是可排序的，它就应该实现Comparable接口。有时多个类具有相同的排序算法，那就不需要重复定义相同的排序算法，只要实现Comparator接口即可。TreeSet是SortedSet的子类，它不同于HashSet的根本就是TreeSet是有序的。它是通过SortedMap来实现的。
      Set总结： 1. Set实现的基础是Map（HashMap）； 2. Set中的元素是不能重复的，如果使用add(Object obj)方法添加已经存在的对象，则会覆盖前面的对象； Set里的元素是不能重复的，那么用什么方法来区分重复与否呢? 是用==还是equals()? 它们有何区别? Set里的元素是不能重复的，即不能包含两个元素e1、e2（e1.equals（e2））。那么用iterator()方法来区分重复与否。equals()是判读两个Set是否相等。==方法决定引用值(句柄)是否指向同一对象。

3. Map

Map是一种把键对象和值对象进行关联的容器，Map有两种比较常用的实现： HashTable、HashMap和TreeMap。

HashMap也用到了哈希码的算法，以便快速查找一个键，TreeMap则是对键按序存放，因此它有一些扩展的方法，比如firstKey(),lastKey()等。
只有HashMap可以让你将空值作为一个表的条目的key或value

HashMap和Hashtable的区别。 HashMap是Hashtable的轻量级实现（非线程安全的实现），他们都完成了Map接口。主要区别在于HashMap允许空（null）键（key）或值（value）,非同步，由于非线程安全，效率上可能高于Hashtable。 Hashtable不允许空（null）键（key）或值（value），Hashtable的方法是Synchronize的，在多个线程访问Hashtable时，不需要自己为它的方法实现同步，而HashMap 就必须为之提供外同步。 Hashtable和HashMap采用的hash/rehash算法都大概一样，所以性能不会有很大的差异。

HashMap:
    散列表的通用映射表，无序，可在初始化时设定其大小，自动增长。
    只有HashMap可以让你将空值作为一个表的条目的key或value

LinkedHashMap:
    扩展HashMap，对返回集合迭代时，维护插入顺序

WeakHashMap:
    基于弱引用散列表的映射表，如果不保持映射表外的关键字的引用，则内存回收程序会回收它

TreeMap:
    基于平衡树的映射表

胡鹏 2009-12-18 17:13 发表评论

读《effective java》第二版，实用一，遇到多个构造器参数时要考虑用构造器

胡鹏 — Thu, 17 Dec 2009 12:25:00 GMT

第二条遇到多个构造器参数时要考虑用构造器

这里考虑的是参数多的情况，如果参数个数比较少，那直接采用一般的构造方法就可以了。

   书中介绍了写构造方法的时候几种方式：

    1. 重叠构造方法模式:
       缺点：有许多参数的时候，客户端代码会很难写，而且较难以阅读。

     2. javaBeans模式：
       缺点：
            在构造过程中JavaBean可能处于不一致的状态，类本身无法判断是否有效性。
            类做成不可变的可能。

     3. builder模式：
       优点：
            在build方法生成对象的时候，可以做检查，判断是否符合要求
参数灵活
   缺点：
创建对象必须先创建构造器，如果对性能要求非常高的应用少用为妙

具体实现代码：
1.重叠构造方法模式：

public class NutritionFacts {
    private final int servingSize;

    private final int serviings;

    private final int calories;

    private final int fat;

    private int sodium;

    private int carbohydrate;

    public NutritionFacts(int servingSize, int serviings){
        this(servingSize, serviings, 0);
    }

    public NutritionFacts(int servingSize, int serviings, int calories){
        this(servingSize, serviings, calories, 0);
    }

    public NutritionFacts(int servingSize, int serviings, int calories, int fat){
        this(servingSize, serviings, calories, fat,0);
    }

    public NutritionFacts(int servingSize, int serviings, int calories, int fat, int sodium){
        this(servingSize, serviings, calories, fat, sodium,0);
    }

    public NutritionFacts(int servingSize, int serviings, int calories, int fat, int sodium, int carbohydrate){
        this.servingSize = servingSize;
        this.serviings = serviings;
        this.calories = calories;
        this.fat = fat;
        this.sodium = sodium;
        this.carbohydrate = carbohydrate;
    }
}

2. javaBeans模式代码：

public class NutritionFacts {
    private  int servingSize;

    private  int serviings;

    private  int calories;

    private  int fat;

    private int sodium;

    private int carbohydrate;

    public NutritionFacts(){}


    public void setServingSize(int servingSize) {
        this.servingSize = servingSize;
    }

    public void setServiings(int serviings) {
        this.serviings = serviings;
    }

    public void setCalories(int calories) {
        this.calories = calories;
    }

    public void setFat(int fat) {
        this.fat = fat;
    }

    public void setSodium(int sodium) {
        this.sodium = sodium;
    }

    public void setCarbohydrate(int carbohydrate) {
        this.carbohydrate = carbohydrate;
    }

3. builder模式

public class NutritionFacts {
    private final int servingSize;
    private final int serviings;
    private final int calories;
    private final int fat;
    private final int sodium;
    private final int carbohydrate;

    public static class Builder {
        private final int servingSize;
        private final int serviings;

        // 可以为空
        private int calories = 0;
        private int fat = 0;
        private int sodium = 0;
        private int carbohydrate = 0;

        public Builder(int servingSize, int serviings) {
            this.servingSize = servingSize;
            this.serviings = serviings;
        }

        public Builder calories(int val){
            calories = val;
            return this;
        }

        public Builder fat(int val){
            fat = val;
            return this;
        }

        public Builder sodium(int val){
            sodium = val;
            return this;
        }

        public Builder carbohydrate(int val){
            carbohydrate = val;
            return this;
        }

        public NutritionFacts build(){
            return new NutritionFacts(this);
        }

    }

    public NutritionFacts(Builder builder) {
        servingSize = builder.servingSize;
        serviings = builder.serviings;
        calories = builder.calories;
        fat = builder.fat;
        sodium = builder.sodium;
        carbohydrate = builder.carbohydrate;
    }
}

这个调用的时候：
NutritionFacts cocaCola = new NutritionFacts.Builder(11,22).calories(1).fat(2).calories(3).build();

胡鹏 2009-12-17 20:25 发表评论

java中关键字volatile的含义(转)

胡鹏 — Mon, 16 Nov 2009 08:34:00 GMT

在Java中设置变量值的操作，除了long和double类型的变量外都是原子操作，也就是说，对于变量值的简单读写操作没有必要进行同步。

这在JVM 1.2之前，Java的内存模型实现总是从主存读取变量，是不需要进行特别的注意的。而随着JVM的成熟和优化，现在在多线程环境下volatile关键字的使用变得非常重要。

在当前的Java内存模型下，线程可以把变量保存在本地内存（比如机器的寄存器）中，而不是直接在主存中进行读写。这就可能造成一个线程在主存中修改了一个变量的值，而另外一个线程还继续使用它在寄存器中的变量值的拷贝，造成数据的不一致。

要解决这个问题，只需要像在本程序中的这样，把该变量声明为volatile（不稳定的）即可，这就指示JVM，这个变量是不稳定的，每次使用它都到主存中进行读取。一般说来，多任务环境下各任务间共享的标志都应该加volatile修饰。

Volatile修饰的成员变量在每次被线程访问时，都强迫从共享内存中重读该成员变量的值。而且，当成员变量发生变化时，强迫线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。

Java语言规范中指出：为了获得最佳速度，允许线程保存共享成员变量的私有拷贝，而且只当线程进入或者离开同步代码块时才与共享成员变量的原始值对比。

这样当多个线程同时与某个对象交互时，就必须要注意到要让线程及时的得到共享成员变量的变化。

而volatile关键字就是提示VM：对于这个成员变量不能保存它的私有拷贝，而应直接与共享成员变量交互。

使用建议：在两个或者更多的线程访问的成员变量上使用volatile。当要访问的变量已在synchronized代码块中，或者为常量时，不必使用。

由于使用volatile屏蔽掉了VM中必要的代码优化，所以在效率上比较低，因此一定在必要时才使用此关键字。

文章出处：DIY部落(http://www.diybl.com/course/3_program/java/javaxl/20090302/156333.html)

同时查看下IBM中的详细解释：

Java 理论与实践: 正确使用 Volatile 变量

http://www.ibm.com/developerworks/cn/java/j-jtp06197.html

胡鹏 2009-11-16 16:34 发表评论

关于 java.util.ConcurrentModificationException 异常

胡鹏 — Tue, 04 Aug 2009 06:51:00 GMT

        网上的解释原因：
Iterator 是工作在一个独立的线程中，并且拥有一个互斥锁。 Iterator 被创建之后会建立一个指向原来对象的单链索引表，当原来的对象数量发生变化时，这个索引表的内容不会同步改变，所以当索引指针往后移动的时候就找不到要迭代的对象，所以按照 fail-fast 原则 Iterator 会马上抛出 java.util.ConcurrentModificationException 异常。
所以 Iterator 在工作的时候是不允许被迭代的对象被改变的。但你可以使用 Iterator 本身的方法 remove() 来删除对象， Iterator.remove() 方法会在删除当前迭代对象的同时维护索引的一致性。

         廖雪峰大师 Java源码分析：深入探讨Iterator模式 http://gceclub.sun.com.cn/yuanchuang/week-14/iterator.html

在工作碰到这个问题所有看看：
List list = ...;
for(Iterator iter = list.iterator(); iter.hasNext();) {
    Object obj = iter.next();
    ...
    if(***) {
        list.remove(obj); //list.add(obj) 其实也是一样的。
    }
}
在执行了remove方法之后，再去执行循环，iter.next()的时候，报java.util.ConcurrentModificationException(当然，如果remove的是最后一条，就不会再去执行next()操作了)，

下面来看一下源码
public interface Iterator {
    boolean hasNext();
    E next();
    void remove();
}

public interface Collection extends Iterable {
    ...
    Iterator iterator();
    boolean add(E o);
    boolean remove(Object o);
    ...
}

public abstract class AbstractList extends AbstractCollection implements List {
//AbstractCollection和List都继承了Collection
    protected transient int modCount = 0;
    private class Itr implements Iterator { //内部类Itr
        int cursor = 0;
        int lastRet = -1;
        int expectedModCount = modCount;

        public boolean hasNext() {
            return cursor != size();
        }

        public E next() {
            checkForComodification(); //该方法中检测到改变，从而抛出异常
            try {
                E next = get(cursor);
                lastRet = cursor++;
                return next;
            } catch(IndexOutOfBoundsException e) {
                checkForComodification();
                throw new NoSuchElementException();
            }
        }

        public void remove() {
            if (lastRet == -1)
                throw new IllegalStateException();
            checkForComodification();

            try {
                AbstractList.this.remove(lastRet); //执行remove对象的操作
                if (lastRet < cursor)
                    cursor--;
                lastRet = -1;
                expectedModCount = modCount; //重新设置了expectedModCount的值，避免了ConcurrentModificationException的产生
            } catch(IndexOutOfBoundsException e) {
                throw new ConcurrentModificationException();
            }
        }

        final void checkForComodification() {
            if (modCount != expectedModCount) //当expectedModCount和modCount不相等时，就抛出ConcurrentModificationException
                throw new ConcurrentModificationException();
        }
    }
}

remove(Object o)在ArrayList中实现如下：
public boolean remove(Object o) {
    if (o == null) {
            for (int index = 0; index < size; index++)
        if (elementData[index] == null) {
            fastRemove(index);
            return true;
        }
    } else {
        for (int index = 0; index < size; index++)
            if (o.equals(elementData[index])) {
                fastRemove(index);
                return true;
            }
    }
    return false;
}
private void fastRemove(int index) {
    modCount++; //只增加了modCount
    ....
}

所以，产生ConcurrentModificationException的原因就是：
执行remove(Object o)方法之后，modCount和expectedModCount不相等了。然后当代码执行到next()方法时，判断了checkForComodification()，发现两个数值不等，就抛出了该Exception。
要避免这个Exception，就应该使用remove()方法，但是没有add()方法了，只能另建一个list来处理这个问题了。

胡鹏 2009-08-04 14:51 发表评论

看《java优化编程》一些细节上的东东

胡鹏 — Sun, 26 Jul 2009 09:33:00 GMT

java程序设计风格：（类的说明介绍）

Java文件注释头

类中开头处插入如下注释

/******************************************************************

*该类功能及特点的描述(例如:该类是用来.....)

*该类未被编译测试过。

*@see(与该类相关联的类):(AnotherClass.java)

*开发公司或单位:XXX软件有限公司研发中心

*版权:本文件版权归属XXX公司研发中心

*@author(作者):XXX

*@since(该文件所支持的JDK版本):Jdk1.3或Jdk1.4

*@version(版本):1.0

*@date(开发日期): 1999-01-29

*最后更改日期: 2003-01-02

*修改人: XXXX

*复审人: 张三李四王五

内存管理

伊甸园用来保存新的对象，它就像一个堆栈，新的对象被创建，就像指向该栈的指针在不断的增长一样，当伊甸园区域中的对象满了之后，JVM系统将要做可到达性测试，主要任务是检测有哪些对象由根集合出发是不可到达的，这些对象就可以被JVM回收，并且将所有的活动对象从伊甸园区域拷到TO区域，此时一些对象将发生状态交换，有的对象就从TO区域被转移到From区域，此时From区域就有了对象,这个过程都是JVM控制完成的。

Java 中的析构方法 finalize

对象是使用完了尽量都赋为 null

共享静态变量存储空间

不要提前创建对象

........

void f(){

int i;

A a = new A();

//类A的对象a被创建

//在判断语句之中没有

//应用过a对象

.....

if(....){

//类A的对象a仅在此处被应用

a.showMessage();

....

}

.....

}

..........

正确的书写方式为：

void f(){

int i;

.....

if(...){

A a = new A();

//类A的对象a被创建

//应用过a对象

a.showMessage();

}

......

}

JVM内存参数调优

表达式、语句和保留字

非静态方法中可引用静态变量

静态方法不可以引用非静态变量

静态方法中可创建非静态变量

调用父类的构造方法必须将其放置子类构造方法的第一行

JAVA核心类与性能优化

线程同步：Vector Hashtable

非线程同步: ArrayList HashMap

字符串累加尽量使用 StringBuffer +=

方法length() 和 length属性区别

IO缓存，读写文件优化。

类与接口

内部类（Inner Class）是Java语言中特有的类型，内部类只能被主类以外的其他内部类继承，主类是不能继承其内部类的，因为这样就引起了类循环继承的错误，下面的代码就是错误的。

public class A extends x {

public A(){}

……

Classs x{

…..

}

上面的代码将引发类循环继承的错误，这种错误在编译时就会被发现，比较容易发现和排除。

但是下面例子中的内部类的继承方式却是正确的：

class A{

….

public A(){}

……

class X extends Y {

……….

}

calss Y {

……

}

什么时候使用继承，什么样的继承是合理的：

1. 现实世界的事物继承关系，可以作为软件系统中类继承关系的依据。

2. 包含关系的类之间不存在继承关系。如：主机，外设，电脑。把主机类和外设类作为电脑类的成员就可以了。

3. 如果在逻辑上类B是类A的一种，并且类的所有属性和行为对类而言都有意义，则允许B继承A的行为和属性（私有属性与行为除外）。

胡鹏 2009-07-26 17:33 发表评论

java如何进阶(转)

胡鹏 — Thu, 23 Jul 2009 11:36:00 GMT

原帖javaeye上的： http://yongtech.javaeye.com/blog/428671 ，觉得写得挺不错的！不知道您到什么阶段了。。。。hoho

本来我想把这篇文章的名字命名为: <怎样成为一个优秀的Java程序员>的, 但是自己还不够优秀, 而本篇所涉及的都是自己学习和工作中的一些经验, 后来一想, 叫<怎样进阶Java>可能更为合适吧. 能给初学Java的人一个参考, 也就是我本来的心愿. 如果有大牛看到不妥之处, 敬请指正. 我一定会修正的 :).

Java目前是最流行的语言之一, 是很多公司和程序员喜爱的一门程序语言. 而且, Java的入门比C++相对来说要简单一些, 所以有很大一部分程序员都选择Java作为自己的开发语言. 我也是其中之一, 就是因为觉得学C++太难, 当初在学校学了将近一个学期的C++, 啥进步都没有, 哈哈, 天资太差, 所以才选择自学Java(当时学校并没有开设Java的课程), 才走上了程序开发这条路.

Java虽然入门要容易, 然而要精通它, 要成为专家却很难. 主要原因是Java所涉及的技术面比较宽, 人的精力总是有限的. 有些Java方面的技术是必须要要掌握的, 钻研得越深入越好, 比如多线程技术.

1. 基础阶段

基础阶段, 可能需要经历1-2年吧. 这个时段, 应该多写一些基础的小程序(自己动手写的越多越好). 计算机是一门实践性很强的学科, 自己动手的东西, 记忆非常深刻, 效果要胜过读好多书. 当然, 学Java基础的时候, 书籍的选择也非常重要, 好的书籍事半功倍, 能让你打个非常好的基础. 而差的书籍, 很容易将你带入歧途, 多走很多弯路. 书籍不在多, 而在乎读得精(有些书, 你读十遍都不为过). 我记得我学Java的第一本书是的中文版, 网上有很多人都建议不要把这本书作为第一本的入门教程来看, 太难. 我却想在此极力推荐它, 这本书确实是本经典之作. 而且书中确实讲的也是Java中的一些基础技术, 没有什么太难的东西, 只不过比较厚, 学习周期比较长, 所以很多人中途会选择放弃. 其实, 这本书是一本难得的入门教程, 对Java一些基础的东西, 讲得很全, 而且也很清晰, 更重要的是, 这本书能让你养成很多好的编程习惯, 例子也很多. 建议你把大部分的例子自己去实现一遍. 我的亲身经历, 我记得当时认真的看了2遍, 花了大概7个月的时间, 不过真的有很好的效果. 另外一个教程, 就是卷一, 卷二的话可以不必要买. 卷一看完, 自己再钻研一下, 就已经能达到卷二的高度了:). 到那时, 你就会觉得看卷二没啥意思, 感觉浪费钱了. 还有一个, 就是张孝祥的Java视频, 看视频有个好处, 就是比看书的记忆要深刻, 还有很多你可以跟着视频的演示同步操作. 张孝祥的Java视频对初学者来说, 确实很有作用. 总结起来: 看这些资料的时候, 一定要多写例子, 写的越多越好!

2. 中级阶段

中级阶段, 是一个更漫长的时期, 能否突破此阶段, 跟个人的努力和天资有着很大的关系. 你不得不承认, 同样一门新技术, 有些人一个月领悟到的东西, 比你一年的都多. 这就是天资, 程序员是一个需要天才的工作. 我想, 很多人听说李一男吧, 此君就是这样的人物, 三个月的时间就能解决好大一帮人几年解决不了的问题, 给华为某部门带来了很多的收益. 哦, 这是题外话了, 与此篇的主题无关, 只是本人偶尔的感慨而已:). 这个阶段, 就需要研究很多专题性的东西了, 比如: IO的实现原理, 多线程和Java的线程模型, 网络编程, swing, RMI, reflect, EJB, JDBC等等很多很多的专题技术, 钻研得越深越好. 为了更好的提高, 研究的更深入, 你需要经常到网络上搜索资料, 这个时候往往一本书起不来很大的作用. 选一个JDK版本吧, 目前建议选用1.6, 多多研究它, 尤其是源代码(尽量! 就是尽自己最大的努力, 虽然研究透是不可能滴). 比如说: util, collection, io, nio, concurrent等等包. 可能有人会反对我说, 不是有API文档吗, 为什么还要研究这么多的源代码? 错了, 有API文档, 你仅仅只是知道怎么用而已, 而认真仔细的研读这些大牛的源码, 你就会深入更高的一个阶层, 自己的编码, 设计都会有很大的提高. 如果有能力和精力, 我建议你把JDK的每一行代码都熟悉一遍, 绝对只有好处, 没有坏处! 而且你会有些意外的收获, 比如, 当你仔细地读完concurrent包的时候(不多, 好像总共是86个类吧), 你就会对Doug Lea佩服得五体投地. 这个时候最忌碰到难题就去寻找帮助, 去网上找答案! 先把自己的脑袋想破吧, 或者等你的老板拿着砍刀冲过来要把你杀了, 再去寻求帮助吧. 对于专题的学习, 英文原版的阅读是非常必要的, 看的越多越好, 多上上IBM的developer, SUN的网站吧, 当然Javaeye也很不错:), 有很多大牛, 呵呵.

这个时候, 你应该建立自己的代码库了, 你应该自己去研究很多有意思的东西了. 从一个200多M的文件中寻找一个字段, 最坏情况(在文件的末尾咯)也只需要1秒左右的时间, 你知道吗? 这个阶段, 有很多很多类似的有趣的东西可以供你去研究, 你需要更多地关注性能, 规范性, 多解决一些疑难问题. 需要学会所有的调试技术, 运用各种性能工具, 还有JDK附带的很多工具, 这些你都要熟练得跟屠夫操刀一样. 也可以看看, 这本书总结的也不错, 对写高效稳定的Java程序有些帮助. 也可以看看模式方面的东西, 但是我建议模式不要滥用, 非得要用的时候才用, 模式往往会把问题搞复杂:). 总结起来: 这个阶段是一个由点延伸到面的过程, 经过不断的学习, 演变成全面的深入! Java技术中你没什么盲点了, 还能解决很多性能问题和疑难问题, 你就成了一个合格的程序员了! :) [要想成为优秀程序员, 还得对数据库和操作系统很精通.]

3. 高级阶段

高级阶段, 我就不敢妄言了. 呵呵, 我感觉自己也是处于中级阶段吧. 也是根据自己的一些经验, 谈谈自己的理解吧:

这个阶段, 需要研究各种框架, Spring, struts, Junit, Hibernate, iBatis, Jboss, Tomcat, snmp4j等等, 我觉得这个时候, 只要是用Java实现的经典框架, 你都可以去研究. ------在此申明一下, 我的意思不是说会用. 光会用其实是远远不够的, 你可以选择自己喜欢钻研的框架, 去好好研究一下, 兴趣是最好的老师嘛.(2009.07.21)

建议开始的时候, 研究Junit和Struts吧, 小一点, 里面都采用了很多的模式, 呵呵, 可以熟悉一下, 尽量想想人家为什么这么做. 我建议主要的精力可以花在spring和jboss上, 尤其是jboss, 经典中的经典, 设计, 性能, 多线程, 资源管理等等, 你从中可以学到的东西简直是太多了. 而且它还有一本写得很好的参考书, 叫, 英文方面的资料也是非常的多. 在工作中如果有机会参与架构的设计, 业务问题的讨论, 一定想方设法杀进去! 这对自己的设计能力, 以及对设计如何运用在业务上有很大的帮助. 毕竟, 程序都是为了更好地实现用户的业务的. 这个时候, 需要更多看看软件工程和UML方面的资料, 或者自己主持一个项目玩玩, 不一定非得出去拉项目赚钱(能赚钱当然更好), 不管成功或失败, 都是很宝贵的经验, 都能提高很多!

胡鹏 2009-07-23 19:36 发表评论

读《effective java》学习笔记一

胡鹏 — Thu, 23 Jul 2009 11:31:00 GMT

           该书介绍了在Java编程中极具实用价值的经验规则，这些经验规则涵盖了大多数开发人员每天所面临的问题的解决方案。通过对Java平台设计专家所使用的技术的全面描述，揭示了应该做什么，不应该做什么才能产生清晰、健壮和高效的代码。
         每天下班花点时间学习下吧，尽量在一个星期内把它看完，总结出来，大多数内容都来自书上，个人觉得该书不错的地方摘出来。

第一条：考虑用静态工厂方法代替构造函数
    静态工厂方法(优点)：
         1.每次调用的时候，不一定要创建一个新的对象，这个可以自由控制。
         2.它可以返回一个原返回类型的子类型的对象。

第二条：使用私有构造函数强化singleton属性
第一种：提供共有的静态final域

public class Elvis{
public static final Elvis INSTANCE = new Elvis();
private Elvis(){

}

}

第二种：提供一个共有的静态工厂方法

1public class Elvis{
2 private static final Elvis INSTANCE = new Elvis();
3 private Elvis(){
4
5 }
6
7 public static Elvis getInstance(){
8 return INSTANCE;
9 }
10
11}

第一种性能上会稍微好些
第二种提供了灵活性，在不改变API的前提下，允许我们改变想法，把该类做成singleton，或者不做，容易被修改。

注意点：为了使一个singleton类变成克序列花的(Serializable),仅仅在声明中加上implements Serializable是不够的，
为了维护singleton性，必须也要提供一个
private Object readResolve() throws ObjectStreamException{
return INSTANCE;
}

第三条：通过私有构造函数强化不可实例化的能力
只要让这个类包含单个显式的私有构造函数，则它就不可被实例化;

1 public class UtilityClass{
2  private UtilityClass(){
3
4  }
5
6 }

企图通过将一个类做成抽象类来强制该类不可被实例化，这是行不通的。该类可以被子类化，并且该子类也可以被实例化。
更进一步，这样做会误导用户，以为这种类是专门为了继承而设计的。

第四条：避免创建重复的对象
String s = new Sting("silly");//这么恶心的代码就不要写啦。。。

1.静态工厂方法可几乎总是优先于构造方法;Boolean.valueOf(...) > Boolean(...),构造函数每次被调用的时候都会创建一个新的对象，
而静态工厂方法从来不要求这样做。

public class Person {
    private final Date birthDate;

    public Person(Date date){
        this.birthDate = date;
    }

    //don't do this
    public boolean isBabyBoomer(){
        Calendar gmtCal = Calendar.getInstance(TimeZone.getTimeZone("GMT"));
        gmtCal.set(1946,Calendar.JANUARY,1,0,0,0);
        Date boomStart = gmtCal.getTime();
        gmtCal.set(1965,Calendar.JANUARY,1,0,0,0);
        Date boomEnd = gmtCal.getTime();
        return birthDate.compareTo(boomStart) >=0 && birthDate.compareTo(boomEnd) <0;
    }
}

isBabyBoomer每次被调用的时候，都会创建一个新的Calendar，一个新的TimeZone和两个新的Date实例。。。

下面的版本避免了这种低效率的动作，代之以一个static 块初始化Calendar对象，而且最体现效率的是，他的生命周期只实例化一次Calendar并且把
80年，90年的出生的值赋值给类静态变量BOOM_START和BOOM_END

class Person {
private final Date birthDate;

public Person(Date birthDate) {
  this.birthDate = birthDate;
}

private static final Date BOOM_START;
private static final Date BOOM_END;
static {
  Calendar gmtCal = Calendar.getInstance(TimeZone.getTimeZone("GMT"));
  gmtCal.set(1980, Calendar.JANUARY, 1, 0, 0, 0);
  BOOM_START = gmtCal.getTime();
  gmtCal.set(1990, Calendar.JANUARY, 1, 0, 0, 0);
  BOOM_END = gmtCal.getTime();
}

public boolean isBabyBoomer() {
  return birthDate.compareTo(BOOM_START) >= 0
    && birthDate.compareTo(BOOM_END) < 0;
}

胡鹏 2009-07-23 19:31 发表评论

关于eclipse和javac编译结果不一致的问题的分析与解决 (转)

胡鹏 — Fri, 22 May 2009 18:15:00 GMT

问题：

下面一个简单的类：

public class MyTest {
private static String className = String.class.getName(); //红色部分是下面问题的关键
public static void main(String[] args){
System.out.println(className);
}
}

经eclipse3.1.1编译后(指定类兼容性版本为1.4)，再反编译的结果是：

public class MyTest
{

    public MyTest()
    {
    }

    public static void main(String args[])
    {
        System.out.println(className);
    }

private static String className;

    static
    {
        className = java.lang.String.class.getName();
    }
}

而经过sun javac(或者ant, antx)编译后(JDK版本1.4，或者JDK1.5，但是编译结果指定版本为1.4)，再反编译的结果是：

public class MyTest
{

    public MyTest()
    {
    }

    public static void main(String args[])
    {
        System.out.println(className);
    }

    static Class _mthclass$(String x0)
    {
        return Class.forName(x0);
        ClassNotFoundException x1;
        x1;
        throw (new NoClassDefFoundError()).initCause(x1);
    }

private static String className;

    static
    {
        className = (java.lang.String.class).getName();
    }
}

也就是说sun javac编译出来的结果里面多了一个_mthclass$方法，这个通常不会有什么问题，不过在使用hot swap技术(例如Antx eclipse plugin中的快速部署插件利用hot swap来实现类的热替换，或者某些类序列化的地方，这个就成为问题了。

用_mthclass$在google上搜一把，结果不多，比较有价值的是这一篇：http://coding.derkeiler.com/Archive/Java/comp.lang.java.softwaretools/2004-01/0138.html

按照这个说法，这个问题是由于Sun本身没有遵循规范，而eclipse compiler遵循规范导致的，而且eclipse compiler是没有办法替换的。

尝试将JDK版本换成1.5，sun javac生成出来的_mthclass$是不见了，不过，这回奇怪的是eclipse的编译结果中多了一个成员变量class$0，
下面是经eclipse3.1.1编译后(指定类兼容性版本为5.0)，再反编译的结果：
public class MyTest
{

    public MyTest()
    {
    }

    public static void main(String args[])
    {
        System.out.println(className);
    }

private static String className = java/lang/String.getName();
static Class class$0;

}
而经过sun javac(或者ant, antx)编译后(JDK版本1.5)，再反编译的结果是：
public class MyTest
{

    public MyTest()
    {
    }

    public static void main(String args[])
    {
        System.out.println(className);
    }

private static String className = java/lang/String.getName();

}

再在goole上搜了一把，发现了Eclipse3.2有两个比较重要的特征：
1.与javac的兼容性更好。
2.提供了单独的编译器，可以在eclipse外部使用，包括ant中使用。

于是下载eclipse3.2版本，首先验证一下其与sun javac的兼容性如何，
使用JDK1.4版本的时候，还是老样子，sun javac编译出来的_mthclass$方法在eclipse3.2的编译结果中还是不存在，所以还是不兼容的。
不过使用JDK1.5版本的时候，这会eclipse 3.2的编译结果总算和sun javac一致了。

虽然，用JDK1.5加上eclipse 3.2已经保证了这个类在两种编译器下的兼容性，不过总觉得不踏实：
1.谁知道这两个编译器还有没有其它不兼容的地方呢？
2.版本要求太严格，很多由于各种原因没有使用这些版本的很麻烦。

因此，还是从根本上解决这个问题比较合适：根本上解决最好就是不要使用两种不同的编译器，而使用同一种。
由于eclipse环境下的编译器是不可替换的，所以企图都使用sun javac的方式不太可行，那么统一使用eclipse自带的编译器如何呢？
刚才提到的eclipse3.2的第二个比较重要的特性就派上用场了。
独立的eclipse编译器(1M大小而已)可以在如下地址下载：http://www.eclipse.org/downloads/download.php?file=/eclipse/downloads/drops/R-3.2-200606291905/ecj.jar
这个独立的编译器在antx下的使用也很简单：(关于该编译器的独立使用或者ant下面的使用可以参看this help section: JDT Plug-in Developer Guide>Programmer's Guide>JDT Core>Compiling Java code)
1.将下载下来的编译器放在ANTX_HOME/lib目录下面。
2.在总控项目文件的project.xml增加这么一行即可：
这样就保证了通过antx打包的类也是用eclipse的编译器编译出来的，当然就不应该存在类不兼容的情况了。

实际上，eclipse3.1.1版本也已经提供了独立的eclipse编译器，不过当时并没有单独提供独立的包下载，如果希望使用3.1.1版本的eclipse编译器，可以使用org.eclipse.jdt.core_3.1.1.jar以及其中包含的jdtCompilerAdapter.jar。（eclipse3.1.1环境的编译器我没有独立验证过）

胡鹏 2009-05-23 02:15 发表评论

Unicode简介(转)

胡鹏 — Fri, 15 May 2009 17:52:00 GMT

Unicode是一种字符编码规范。

先从ASCII说起。ASCII是用来表示英文字符的一种编码规范，每个ASCII字符占用1个字节（8bits）

因此，ASCII编码可以表示的最大字符数是256，其实英文字符并没有那么多，一般只用前128个（最高位为0），其中包括了控制字符、数字、大小写字母和其他一些符号。

而最高位为1的另128个字符被成为“扩展ASCII”，一般用来存放英文的制表符、部分音标字符等等的一些其他符号

这种字符编码规范显然用来处理英文没有什么问题。（实际上也可以用来处理法文、德文等一些其他的西欧字符，但是不能和英文通用），但是面对中文、阿拉伯文之类复杂的文字，255个字符显然不够用

于是，各个国家纷纷制定了自己的文字编码规范，其中中文的文字编码规范叫做“GB2312-80”，它是和ASCII兼容的一种编码规范，其实就是利用扩展ASCII没有真正标准化这一点，把一个中文字符用两个扩展ASCII字符来表示。

但是这个方法有问题，最大的问题就是，中文文字没有真正属于自己的编码，因为扩展ASCII码虽然没有真正的标准化，但是PC里的ASCII码还是有一个事实标准的（存放着英文制表符），所以很多软件利用这些符号来画表格。这样的软件用到中文系统中，这些表格符就会被误认作中文字，破坏版面。而且，统计中英文混合字符串中的字数，也是比较复杂的，我们必须判断一个ASCII码是否扩展，以及它的下一个ASCII是否扩展，然后才“猜”那可能是一个中文字。

总之当时处理中文是很痛苦的。而更痛苦的是GB2312是国家标准，台湾当时有一个Big5编码标准，很多编码和GB是相同的，所以……，嘿嘿。

这时候，我们就知道，要真正解决中文问题，不能从扩展ASCII的角度入手，也不能仅靠中国一家来解决。而必须有一个全新的编码系统，这个系统要可以将中文、英文、法文、德文……等等所有的文字统一起来考虑，为每个文字都分配一个单独的编码，这样才不会有上面那种现象出现。

于是，Unicode诞生了。

Unicode有两套标准，一套叫UCS-2(Unicode-16)，用2个字节为字符编码，另一套叫UCS-4(Unicode-32)，用4个字节为字符编码。

以目前常用的UCS-2为例，它可以表示的字符数为2^16=65535，基本上可以容纳所有的欧美字符和绝大部分的亚洲字符。

UTF-8的问题后面会提到。

在Unicode里，所有的字符被一视同仁。汉字不再使用“两个扩展ASCII”，而是使用“1个Unicode”，注意，现在的汉字是“一个字符”了，于是，拆字、统计字数这些问题也就自然而然的解决了。

但是，这个世界不是理想的，不可能在一夜之间所有的系统都使用Unicode来处理字符，所以Unicode在诞生之日，就必须考虑一个严峻的问题：和ASCII字符集之间的不兼容问题。

我们知道，ASCII字符是单个字节的，比如“A”的ASCII是65。而Unicode是双字节的，比如“A”的Unicode是0065，这就造成了一个非常大的问题：以前处理ASCII的那套机制不能被用来处理Unicode了。

另一个更加严重的问题是，C语言使用'\0'作为字符串结尾，而Unicode里恰恰有很多字符都有一个字节为0，这样一来，C语言的字符串函数将无法正常处理Unicode，除非把世界上所有用C写的程序以及他们所用的函数库全部换掉。

于是，比Unicode更伟大的东东诞生了，之所以说它更伟大是因为它让Unicode不再存在于纸上，而是真实的存在于我们大家的电脑中。那就是：UTF 。

UTF= UCS Transformation Format UCS转换格式

它是将Unicode编码规则和计算机的实际编码对应起来的一个规则。现在流行的UTF有2种：UTF-8和UTF-16 。

其中UTF-16和上面提到的Unicode本身的编码规范是一致的，这里不多说了。而UTF-8不同，它定义了一种“区间规则”，这种规则可以和ASCII编码保持最大程度的兼容。

UTF-8有点类似于Haffman编码，它将Unicode编码为00000000-0000007F的字符，用单个字节来表示；

00000080-000007FF的字符用两个字节表示

00000800-0000FFFF的字符用3字节表示

因为目前为止Unicode-16规范没有指定FFFF以上的字符，所以UTF-8最多是使用3个字节来表示一个字符。但理论上来说，UTF-8最多需要用6字节表示一个字符。

在UTF-8里，英文字符仍然跟ASCII编码一样，因此原先的函数库可以继续使用。而中文的编码范围是在0080-07FF之间，因此是2个字节表示（但这两个字节和GB编码的两个字节是不同的），用专门的Unicode处理类可以对UTF编码进行处理。

下面说说中文的问题。

由于历史的原因，在Unicode之前，一共存在过3套中文编码标准。

GB2312-80，是中国大陆使用的国家标准，其中一共编码了6763个常用简体汉字。Big5，是台湾使用的编码标准，编码了台湾使用的繁体汉字，大概有8千多个。HKSCS，是中国香港使用的编码标准，字体也是繁体，但跟Big5有所不同。

这3套编码标准都采用了两个扩展ASCII的方法，因此，几套编码互不兼容，而且编码区间也各有不同

因为其不兼容性，在同一个系统中同时显示GB和Big5基本上是不可能的。当时的南极星、RichWin等等软件，在自动识别中文编码、自动显示正确编码方面都做了很多努力。

他们用了怎样的技术我就不得而知了，我知道好像南极星曾经以同屏显示繁简中文为卖点。

后来，由于各方面的原因，国际上又制定了针对中文的统一字符集GBK和GB18030，其中GBK已经在Windows、Linux等多种操作系统中被实现。

GBK兼容GB2312，并增加了大量不常用汉字，还加入了几乎所有的Big5中的繁体汉字。但是GBK中的繁体汉字和Big5中的几乎不兼容。

GB18030相当于是GBK的超集，比GBK包含的字符更多。据我所知目前还没有操作系统直接支持GB18030。

谈谈Unicode编码，简要解释UCS、UTF、BMP、BOM等名词
这是一篇程序员写给程序员的趣味读物。所谓趣味是指可以比较轻松地了解一些原来不清楚的概念，增进知识，类似于打RPG游戏的升级。整理这篇文章的动机是两个问题：

问题一：
使用Windows记事本的“另存为”，可以在GBK、Unicode、Unicode big endian和UTF-8这几种编码方式间相互转换。同样是txt文件，Windows是怎样识别编码方式的呢？

我很早前就发现Unicode、Unicode big endian和UTF-8编码的txt文件的开头会多出几个字节，分别是FF、FE（Unicode）,FE、FF（Unicode big endian）,EF、BB、BF（UTF-8）。但这些标记是基于什么标准呢？

问题二：
最近在网上看到一个ConvertUTF.c，实现了UTF-32、UTF-16和UTF-8这三种编码方式的相互转换。对于Unicode(UCS2)、GBK、UTF-8这些编码方式，我原来就了解。但这个程序让我有些糊涂，想不起来UTF-16和UCS2有什么关系。
查了查相关资料，总算将这些问题弄清楚了，顺带也了解了一些Unicode的细节。写成一篇文章，送给有过类似疑问的朋友。本文在写作时尽量做到通俗易懂，但要求读者知道什么是字节，什么是十六进制。

0、big endian和little endian
big endian和little endian是CPU处理多字节数的不同方式。例如“汉”字的Unicode编码是6C49。那么写到文件里时，究竟是将6C写在前面，还是将49写在前面？如果将6C写在前面，就是big endian。还是将49写在前面，就是little endian。

“endian”这个词出自《格列佛游记》。小人国的内战就源于吃鸡蛋时是究竟从大头(Big-Endian)敲开还是从小头(Little-Endian)敲开，由此曾发生过六次叛乱，其中一个皇帝送了命，另一个丢了王位。

我们一般将endian翻译成“字节序”，将big endian和little endian称作“大尾”和“小尾”。

1、字符编码、内码，顺带介绍汉字编码
字符必须编码后才能被计算机处理。计算机使用的缺省编码方式就是计算机的内码。早期的计算机使用7位的ASCII编码，为了处理汉字，程序员设计了用于简体中文的GB2312和用于繁体中文的big5。

GB2312(1980年)一共收录了7445个字符，包括6763个汉字和682个其它符号。汉字区的内码范围高字节从B0-F7，低字节从A1-FE，占用的码位是72*94=6768。其中有5个空位是D7FA-D7FE。

GB2312支持的汉字太少。1995年的汉字扩展规范GBK1.0收录了21886个符号，它分为汉字区和图形符号区。汉字区包括21003个字符。2000年的GB18030是取代GBK1.0的正式国家标准。该标准收录了27484个汉字，同时还收录了藏文、蒙文、维吾尔文等主要的少数民族文字。现在的PC平台必须支持GB18030，对嵌入式产品暂不作要求。所以手机、MP3一般只支持GB2312。

从ASCII、GB2312、GBK到GB18030，这些编码方法是向下兼容的，即同一个字符在这些方案中总是有相同的编码，后面的标准支持更多的字符。在这些编码中，英文和中文可以统一地处理。区分中文编码的方法是高字节的最高位不为0。按照程序员的称呼，GB2312、GBK到GB18030都属于双字节字符集 (DBCS)。

有的中文Windows的缺省内码还是GBK，可以通过GB18030升级包升级到GB18030。不过GB18030相对GBK增加的字符，普通人是很难用到的，通常我们还是用GBK指代中文Windows内码。

这里还有一些细节：

GB2312的原文还是区位码，从区位码到内码，需要在高字节和低字节上分别加上A0。

在DBCS中，GB内码的存储格式始终是big endian，即高位在前。

GB2312的两个字节的最高位都是1。但符合这个条件的码位只有128*128=16384个。所以GBK和GB18030的低字节最高位都可能不是1。不过这不影响DBCS字符流的解析：在读取DBCS字符流时，只要遇到高位为1的字节，就可以将下两个字节作为一个双字节编码，而不用管低字节的高位是什么。

2、Unicode、UCS和UTF
前面提到从ASCII、GB2312、GBK到GB18030的编码方法是向下兼容的。而Unicode只与ASCII兼容（更准确地说，是与ISO-8859-1兼容），与GB码不兼容。例如“汉”字的Unicode编码是6C49，而GB码是BABA。

Unicode也是一种字符编码方法，不过它是由国际组织设计，可以容纳全世界所有语言文字的编码方案。Unicode的学名是"Universal Multiple-Octet Coded Character Set"，简称为UCS。UCS可以看作是"Unicode Character Set"的缩写。

根据维基百科全书(http://zh.wikipedia.org/wiki/)的记载：历史上存在两个试图独立设计Unicode的组织，即国际标准化组织（ISO）和一个软件制造商的协会（unicode.org）。ISO开发了ISO 10646项目，Unicode协会开发了Unicode项目。

在1991年前后，双方都认识到世界不需要两个不兼容的字符集。于是它们开始合并双方的工作成果，并为创立一个单一编码表而协同工作。从Unicode2.0开始，Unicode项目采用了与ISO 10646-1相同的字库和字码。

目前两个项目仍都存在，并独立地公布各自的标准。Unicode协会现在的最新版本是2005年的Unicode 4.1.0。ISO的最新标准是10646-3:2003。

UCS规定了怎么用多个字节表示各种文字。怎样传输这些编码，是由UTF(UCS Transformation Format)规范规定的，常见的UTF规范包括UTF-8、UTF-7、UTF-16。

IETF的RFC2781和RFC3629以RFC的一贯风格，清晰、明快又不失严谨地描述了UTF-16和UTF-8的编码方法。我总是记不得IETF是Internet Engineering Task Force的缩写。但IETF负责维护的RFC是Internet上一切规范的基础。

3、UCS-2、UCS-4、BMP

UCS有两种格式：UCS-2和UCS-4。顾名思义，UCS-2就是用两个字节编码，UCS-4就是用4个字节（实际上只用了31位，最高位必须为0）编码。下面让我们做一些简单的数学游戏：

UCS-2有2^16=65536个码位，UCS-4有2^31=2147483648个码位。

UCS-4根据最高位为0的最高字节分成2^7=128个group。每个group再根据次高字节分为256个plane。每个plane根据第3个字节分为256行 (rows)，每行包含256个cells。当然同一行的cells只是最后一个字节不同，其余都相同。

group 0的plane 0被称作Basic Multilingual Plane, 即BMP。或者说UCS-4中，高两个字节为0的码位被称作BMP。

将UCS-4的BMP去掉前面的两个零字节就得到了UCS-2。在UCS-2的两个字节前加上两个零字节，就得到了UCS-4的BMP。而目前的UCS-4规范中还没有任何字符被分配在BMP之外。

4、UTF编码

UTF-8就是以8位为单元对UCS进行编码。从UCS-2到UTF-8的编码方式如下：

UCS-2编码(16进制) UTF-8 字节流(二进制)
0000 - 007F 0xxxxxxx
0080 - 07FF 110xxxxx 10xxxxxx
0800 - FFFF 1110xxxx 10xxxxxx 10xxxxxx

例如“汉”字的Unicode编码是6C49。6C49在0800-FFFF之间，所以肯定要用3字节模板了：1110xxxx 10xxxxxx 10xxxxxx。将6C49写成二进制是：0110 110001 001001，用这个比特流依次代替模板中的x，得到：11100110 10110001 10001001，即E6 B1 89。

读者可以用记事本测试一下我们的编码是否正确。

UTF-16以16位为单元对UCS进行编码。对于小于0x10000的UCS码，UTF-16编码就等于UCS码对应的16位无符号整数。对于不小于0x10000的UCS码，定义了一个算法。不过由于实际使用的UCS2，或者UCS4的BMP必然小于0x10000，所以就目前而言，可以认为UTF-16和UCS-2基本相同。但UCS-2只是一个编码方案，UTF-16却要用于实际的传输，所以就不得不考虑字节序的问题。

5、UTF的字节序和BOM
UTF-8以字节为编码单元，没有字节序的问题。UTF-16以两个字节为编码单元，在解释一个UTF-16文本前，首先要弄清楚每个编码单元的字节序。例如收到一个“奎”的Unicode编码是594E，“乙”的Unicode编码是4E59。如果我们收到UTF-16字节流“594E”，那么这是“奎”还是“乙”？

Unicode规范中推荐的标记字节顺序的方法是BOM。BOM不是“Bill Of Material”的BOM表，而是Byte Order Mark。BOM是一个有点小聪明的想法：

在UCS编码中有一个叫做"ZERO WIDTH NO-BREAK SPACE"的字符，它的编码是FEFF。而FFFE在UCS中是不存在的字符，所以不应该出现在实际传输中。UCS规范建议我们在传输字节流前，先传输字符"ZERO WIDTH NO-BREAK SPACE"。

这样如果接收者收到FEFF，就表明这个字节流是Big-Endian的；如果收到FFFE，就表明这个字节流是Little-Endian的。因此字符"ZERO WIDTH NO-BREAK SPACE"又被称作BOM。

UTF-8不需要BOM来表明字节顺序，但可以用BOM来表明编码方式。字符"ZERO WIDTH NO-BREAK SPACE"的UTF-8编码是EF BB BF（读者可以用我们前面介绍的编码方法验证一下）。所以如果接收者收到以EF BB BF开头的字节流，就知道这是UTF-8编码了。

Windows就是使用BOM来标记文本文件的编码方式的。

6、进一步的参考资料
本文主要参考的资料是 "Short overview of ISO-IEC 10646 and Unicode" (http://www.nada.kth.se/i18n/ucs/unicode-iso10646-oview.html)。

我还找了两篇看上去不错的资料，不过因为我开始的疑问都找到了答案，所以就没有看：

"Understanding Unicode A general introduction to the Unicode Standard" (http://scripts.sil.org/cms/scripts/page.php?site_id=nrsi&item_id=IWS-Chapter04a)
"Character set encoding basics Understanding character set encodings and legacy encodings" (http://scripts.sil.org/cms/scripts/page.php?site_id=nrsi&item_id=IWS-Chapter03)

胡鹏 2009-05-16 01:52 发表评论

常用的匹配正则表达式和实例(转)

胡鹏 — Fri, 15 May 2009 08:06:00 GMT

匹配中文字符的正则表达式： [\u4e00-\u9fa5]
匹配双字节字符(包括汉字在内)：[^\x00-\xff]
应用：计算字符串的长度（一个双字节字符长度计2，ASCII字符计1）
String.prototype.len=function(){return this.replace([^\x00-\xff]/g,"aa").length;}
匹配空行的正则表达式：\n[\s| ]*\r
匹配HTML标记的正则表达式：/<(.*)>.*<\/\1>|<(.*) \/>/
匹配首尾空格的正则表达式：(^\s*)|(\s*$)
应用：javascript中没有像vbscript那样的trim函数，我们就可以利用这个表达式来实现，如下：
String.prototype.trim = function()
{ return this.replace(/(^\s*)|(\s*$)/g, "");
} 利用正则表达式分解和转换IP地址：
下面是利用正则表达式匹配IP地址，并将IP地址转换成对应数值的Javascript程序：
function IP2V(ip)
{
re=/(\d+)\.(\d+)\.(\d+)\.(\d+)/g //匹配IP地址的正则表达式
if(re.test(ip))
{
return RegExp.$1*Math.pow(255,3))+RegExp.$2*Math.pow(255,2))+RegExp.$3*255+RegExp.$4*1
}
else
{
throw new Error("Not a valid IP address!")
}
}

不过上面的程序如果不用正则表达式，而直接用split函数来分解可能更简单，程序如下：

var ip="10.100.20.168"
ip=ip.split(".")
alert("IP值是："+(ip[0]*255*255*255+ip[1]*255*255+ip[2]*255+ip[3]*1))

匹配Email地址的正则表达式：\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*

匹配网址URL的正则表达式：http://([\w-]+\.)+[\w-]+(/[\w- ./?%&=]*)?

利用正则表达式限制网页表单里的文本框输入内容：

用正则表达式限制只能输入中文：onkeyup="value=value.replace(/[^\u4E00-\u9FA5]/g,'')"
onbeforepaste="clipboardData.setData('text',clipboardData.getData('text').replace(/[^\u4E00-\u9FA5]/g,''))"

用正则表达式限制只能输入全角字符： onkeyup="value=value.replace(/[^\uFF00-\uFFFF]/g,'')"
onbeforepaste="clipboardData.setData('text',clipboardData.getData('text').replace(/[^\uFF00-\uFFFF]/g,''))"

用正则表达式限制只能输入数字：onkeyup="value=value.replace(/

[^\d]/g,'') "onbeforepaste="clipboardData.setData('text',clipboardData.getData('text').replace(/[^\d]/g,''))"

用正则表达式限制只能输入数字和英文：onkeyup="value=value.replace(/
[\W]/g,'') "onbeforepaste="clipboardData.setData('text',clipboardData.getData('text').replace(/[^\d]/g,''))"

胡鹏 2009-05-15 16:06 发表评论

java获取qq邮箱中的好友列表

胡鹏 — Thu, 07 May 2009 09:54:00 GMT

       首先访问qq.mail.com 这个url分析html代码，发现，里面有很多加密的js，而且配合httpwatch工具发现，哇，靠，这个太复杂了。
如果简单的使用java模拟浏览器访问qq mail服务器获取好友列表，实在是太困难了，个人能力有限实现不了，想了其他办法，创建了
web项目，分析不了腾讯是怎么加密，但我可以作为一种代理，如图：

   要采用上面的方式来获取好友，大致可以分为一下几个步骤：
1.首先制作一个login.jsp页面，代码直接从腾讯邮件的登陆页面中复制过来，把页面交互的改成我们自己的服务器.
    (1)获取验证码的地址：http://ptlogin2.qq.com/getimage?aid=23000101 后面带个随机数，为了防止浏览器缓存。
    (2)当用户输入用户名密码和验证码，点登陆的时候，也让用户提交到我们的服务器来。
2. 我这里写了一个servlet，该类是从qq邮件服务器中获取验证码的，如何获取呢？我采用的是
httpclient4.0-beta2 包，该包是apache的 Apache HttpComponents project，是个开源的，具体使用和了解可以访问：
http://hc.apache.org/httpcomponents-client/index.html，（该项目功能很强大）
    在获取了验证码之后，qq服务器他在cookie中写了一个verifysession，当你点登陆的时候
客户端校验需要。
3. 把客户端提交过来的信息我们去请求qq服务器，这样就会登陆成功了，服务器会返回带sid的html代码，解析出来sid的值
然后访问http://m11.mail.qq.com/cgi-bin/addr_listall?sid=" +sid+"&sorttype=null&category=common，就获取到qq中好友分组，以及每一个组的链接地址
4.请求每一个链接就可以得到每一组的好友了

         上面我只是写了实现的思路，有兴趣的可以跟我联系，具体代码可以分享给大家。。。 qq：253041869

胡鹏 2009-05-07 17:54 发表评论

CSVReader的下载地址

胡鹏 — Mon, 04 May 2009 12:04:00 GMT

目前最高版本： http://downloads.sourceforge.net/opencsv/opencsv-1.8-src-with-libs.tar.gz
开源的opencsv，用来操作csv，这个还是不错的。要看介绍还是去看官方的文档吧，下了，感觉还不错的~ 一些使用的东东上面说的很清楚，我也懒的复制了，这个给自己标注下吧。。 hoho

胡鹏 2009-05-04 20:04 发表评论

servlet中获取（其他网站的）验证码，显示在自己页面上

胡鹏 — Thu, 23 Apr 2009 12:38:00 GMT

有时候要获取其他网站的代码来实现模拟登陆，下面使用servlet来实现：程序代码如下：

String urlStr = "http://xxx.xxx.xx.xx";
         URL url = new URL(urlStr);
         URLConnection conn = url.openConnection();
          conn.connect();
          InputStream is = conn.getInputStream();

        //得到输入的编码器，将文件流进行jpg格式编码
            JPEGImageDecoder decoder = JPEGCodec.createJPEGDecoder(is);
         //得到编码后的图片对象
         BufferedImage image = decoder.decodeAsBufferedImage();
         //得到输出的编码器
          OutputStream output = response.getOutputStream();
          JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(output);
          encoder.encode(image);//对图片进行输出编码
          is.close();//关闭文件流
          output.close();

比较简单。。。。。hoho

胡鹏 2009-04-23 20:38 发表评论

String,StringBuffer,StringBuilder之间的区别，以及使用中该注意什么(转)

胡鹏 — Wed, 22 Apr 2009 12:31:00 GMT

   只是了解个大概，具体细节上不太清楚，这篇文章不错，基本上都讲清楚了。。。嘿嘿，学习下。。。相信大家对 String 和 StringBuffer 的区别也已经很了解了，但是估计还是会有很多同志对这两个类的工作原理有些不清楚的地方，今天我在这里重新把这个概念给大家复习一下，顺便牵出 J2SE 5.0 里面带来的一个新的字符操作的类—— StringBuilder （先别忙着扔我砖头，我还算清醒，我这里说的不是 C ＃， Java 也有 StringBuilder 类）。那么这个 StringBuilder 和 StringBuffer 以及我们最早遇见的 String 类有那些区别呢？在不同的场合下我们应该用哪个呢？我讲讲自己对这几个类的一点看法，也希望大家提出意见，每个人都有错的地方，在错了改的同时更是一个学习的好机会。

    简要的说， String 类型和 StringBuffer 类型的主要性能区别其实在于 String 是不可变的对象（为什么？问问 Java 的设计者吧，为什么 String 不是原生类型呢？）因此在每次对 String 类型进行改变的时候其实都等同于生成了一个新的 String 对象，然后将指针指向新的 String 对象，所以经常改变内容的字符串最好不要用 String ，因为每次生成对象都会对系统性能产生影响，特别当内存中无引用对象多了以后， JVM 的 GC 就会开始工作，那速度是一定会相当慢的。这里尝试举个不是很恰当的例子：

String S1 = “abc”;
For(int I = 0 ; I < 10000 ; I ++) // For 模拟程序的多次调用
{
S1 + = “def”;
S1 = “abc”;
}

    如果是这样的话，到这个 for 循环完毕后，如果内存中的对象没有被 GC 清理掉的话，内存中一共有 2 万多个了，惊人的数目，而如果这是一个很多人使用的系统，这样的数目就不算很多了，所以大家使用的时候一定要小心。

    而如果是使用 StringBuffer 类则结果就不一样了，每次结果都会对 StringBuffer 对象本身进行操作，而不是生成新的对象，再改变对象引用。所以在一般情况下我们推荐使用 StringBuffer ，特别是字符串对象经常改变的情况下。而在某些特别情况下， String 对象的字符串拼接其实是被 JVM 解释成了 StringBuffer 对象的拼接，所以这些时候 String 对象的速度并不会比 StringBuffer 对象慢，而特别是以下的字符串对象生成中， String 效率是远要比 StringBuffer 快的：

String S1 = “This is only a” + “ simple” + “ test”;
StringBuffer Sb = new StringBuilder(“This is only a”).append(“ simple”).append(“ test”);

    你会很惊讶的发现，生成 String S1 对象的速度简直太快了，而这个时候 StringBuffer 居然速度上根本一点都不占优势。其实这是 JVM 的一个把戏，在 JVM 眼里，这个

String S1 = “This is only a” + “ simple” + “test”; 其实就是： String S1 = “This is only a simple test”; 所以当然不需要太多的时间了。但大家这里要注意的是，如果你的字符串是来自另外的 String 对象的话，速度就没那么快了，譬如：

String S2 = “This is only a”;
String S3 = “ simple”;
String S4 = “ test”;
String S1 = S2 +S3 + S4;

    这时候 JVM 会规规矩矩的按照原来的方式去做， S1 对象的生成速度就不像刚才那么快了，一会儿我们可以来个测试作个验证。

    由此我们得到第一步结论：在大部分情况下 StringBuffer > String

    而 StringBuilder 跟他们比又怎么样呢？先简单介绍一下， StringBuilder 是 JDK5.0 中新增加的一个类，它跟 StringBuffer 的区别看下面的介绍（来源 JavaWorld ）：

    Java.lang.StringBuffer 线程安全的可变字符序列。类似于 String 的字符串缓冲区，但不能修改。可将字符串缓冲区安全地用于多个线程。可以在必要时对这些方法进行同步，因此任意特定实例上的所有操作就好像是以串行顺序发生的，该顺序与所涉及的每个线程进行的方法调用顺序一致。

    每个字符串缓冲区都有一定的容量。只要字符串缓冲区所包含的字符序列的长度没有超出此容量，就无需分配新的内部缓冲区数组。如果内部缓冲区溢出，则此容量自动增大。从 JDK 5.0 开始，为该类增添了一个单个线程使用的等价类，即 StringBuilder 。与该类相比，通常应该优先使用 StringBuilder 类，因为它支持所有相同的操作，但由于它不执行同步，所以速度更快。

    但是如果将 StringBuilder 的实例用于多个线程是不安全的。需要这样的同步，则建议使用 StringBuffer 。

    这样说估计大家都能明白他们之间的区别了，那么下面我们再做一个一般性推导：

    在大部分情况下 StringBuilder > StringBuffer

    因此，根据这个不等式的传递定理：在大部分情况下 StringBuilder > StringBuffer > String

    既然有这样的推导结果了，我们做个测试验证一下：

    测试代码如下：

public class testssb {

/** Creates a new instance of testssb */
final static int ttime = 10000;// 测试循环次数
public testssb() {
}

public void test(String s){
long begin = System.currentTimeMillis();
for(int i=0;i s += "add";
}
long over = System.currentTimeMillis();
System.out.println(" 操作 "+s.getClass().getName()+" 类型使用的时间为： " + (over - begin) + " 毫秒 " );
}

public void test(StringBuffer s){
long begin = System.currentTimeMillis();
for(int i=0;i s.append("add");
}
long over = System.currentTimeMillis();
System.out.println(" 操作 "+s.getClass().getName()+" 类型使用的时间为： " + (over - begin) + " 毫秒 " );
}

public void test(StringBuilder s){
long begin = System.currentTimeMillis();
for(int i=0;i s.append("add");
}
long over = System.currentTimeMillis();
System.out.println(" 操作 "+s.getClass().getName()+" 类型使用的时间为： " + (over - begin) + " 毫秒 " );
}

// 对 String 直接进行字符串拼接的测试
public void test2(){
String s2 = "abadf";
long begin = System.currentTimeMillis();
for(int i=0;i String s = s2 + s2 + s2 ;
}
long over = System.currentTimeMillis();
System.out.println(" 操作字符串对象引用相加类型使用的时间为： " + (over - begin) + " 毫秒 " );
}

public void test3(){
long begin = System.currentTimeMillis();
for(int i=0;i String s = "abadf" + "abadf" + "abadf" ;
}
long over = System.currentTimeMillis();
System.out.println(" 操作字符串相加使用的时间为： "+ (over - begin) + " 毫秒 " );
}

public static void main(String[] args){
String s1 ="abc";
StringBuffer sb1 = new StringBuffer("abc");
StringBuilder sb2 = new StringBuilder("abc");

testssb t = new testssb();
t.test(s1);
t.test(sb1);
t.test(sb2);
t.test2();
t.test3();
}
}

    以上代码在 NetBeans 5.0 IDE/JDK1.6 上编译通过,循环次数 ttime 为 10000 次的测试结果如下：
操作 java.lang.String 类型使用的时间为： 4392 毫秒
操作 java.lang.StringBuffer 类型使用的时间为： 0 毫秒
操作 java.lang.StringBuilder 类型使用的时间为： 0 毫秒
操作字符串对象引用相加类型使用的时间为： 15 毫秒
操作字符串相加使用的时间为： 0 毫秒

    好像还看不出 StringBuffer 和 StringBuilder 的区别，把 ttime 加到 30000 次看看：
操作 java.lang.String 类型使用的时间为： 53444 毫秒
操作 java.lang.StringBuffer 类型使用的时间为： 15 毫秒
操作 java.lang.StringBuilder 类型使用的时间为： 15 毫秒
操作字符串对象引用相加类型使用的时间为： 31 毫秒
操作字符串相加使用的时间为： 0 毫秒

    StringBuffer 和 StringBuilder 的性能上还是没有太大的差异，再加大到 100000 看看，这里就不加入对 String 类型的测试了，因为对 String 类型这么大数据量的测试会很慢滴……
操作 java.lang.StringBuffer 类型使用的时间为： 31 毫秒
操作 java.lang.StringBuilder 类型使用的时间为： 16 毫秒

    能看出差别了，但其中有多次的测试结果居然是 StringBuffer 比 StringBuilder 快，再加大一些到 1000000 看看（应该不会当机吧？）：
操作 java.lang.StringBuffer 类型使用的时间为： 265 毫秒
操作 java.lang.StringBuilder 类型使用的时间为： 219 毫秒

    有些少区别了，而且结果很稳定，再大点看看， ttime = 5000000 ：

······ Exception in thread "main" java.lang.OutOfMemoryError: Java heap space ······

    呵呵，算了，不去测试了，基本来说都是在性能上都是 StringBuilder > StringBuffer > String 的了。

胡鹏 2009-04-22 20:31 发表评论

for循环 while do while 中的一个小bug

胡鹏 — Sun, 19 Apr 2009 07:05:00 GMT

如下程序会输出什么?

public class Creator {
public static void main(String[] args) {
for(int i=0;i<100;i++)
Creature creature = new Creature();

System.out.println(Creature.numCreated());
}
}

class Creature{
private static long numCreated = 0;

public Creature(){
numCreated++;
}

public static long numCreated(){
return numCreated;
}
}

编译的时候发现：上面的程序在Creature creature = new Creature(); 发现语法错误，这个为什么呢？？？，觉得很奇怪啊，
原来java语言规范不允许一个额本地变量声明语句作为一条语句在for，while，或do循环中重复执行。 一个本地变量声明作为一条语句只能直接出现在一个语句块中。

针对上面的程序：可以有几种方式来修改，Creature creature = new Creature();改成 new Creature(); 也可以改成

{
Creature creature = new Creature();
}

等等。。。。。。。。。。。。。。。。。。。。。

胡鹏 2009-04-19 15:05 发表评论

又是一个hello world

胡鹏 — Sun, 19 Apr 2009 03:22:00 GMT

简单的hello world hoho：

public class Null {
    public static void greet(){
        System.out.println("hello world!");
    }
    public static void main(String[] args) {
        ((Null)null).greet();
    }
}

程序运行结果： hello world！

胡鹏 2009-04-19 11:22 发表评论

静态数据初始化你真的了解了吗？构造方法的初始之后。。我又做错了，太粗心了

胡鹏 — Wed, 15 Apr 2009 11:28:00 GMT

下面的程序输出什么呢? 考虑下哦。。。。

public class Test {
    public static final Test TEST = new Test();
    private final int belt;
    private static final int CURRENT_YEAR = Calendar.getInstance().get(Calendar.YEAR);

    public Test(){
        belt = CURRENT_YEAR - 1930;
    }
    public int getBelt(){
        return belt;
    }
    public static void main(String []args) throws Exception{
        System.out.println(TEST.getBelt());
    }
}

可能你觉得应该是当前年- 1930, 例如：今年是2009，2009-1930= 79，运行结果真的是这样吗？
你运行下，额，奇怪，居然是 -1930, 额，为什么呢？？

原来首先其静态域被设置为缺省值， TEST先设置为null， belt设置为0 ，然后TEST构造器计算出来，但我们已经初始化belt了，
belt被设置为final，所以忽略了。。。

再来看下下面一个简单的例子，刚开始做的时候不仔细，哎，，我错了。。哎~！~ 希望大家不要跟我一样啊。

1 class Point {
2     protected final int x, y;
3     private final String name;
4
5     Point(int x, int y) {
6         this.x = x;
7         this.y = y;
8         name = makeName();
9     }
10
11     protected String makeName() {
12         return "[" + x + "," + y + "]";
13     }
14
15     public final String toString(){
16         return name;
17     }
18
19 }
20
21 public class ColorPoint extends Point {
22     private final String color;
23
24     ColorPoint(int x, int y, String color){
25         super(x,y);
26         this.color = color;
27     }
28     protected String makeName() {
29         return super.makeName()+":"+color;
30     }
31
32     public static void main(String[] args) {
33         System.out.println(new ColorPoint(1,2,"abc"));
34     }
35
36 }

运行结果： [1,2]:null

程序从main启动，然后到 25行，super(x,y); 之后到第 8行 name = makeName(); 再之后29行， return super.makeName()+":"+color;
这里，方法被子类重载了，运行到26行 this.color = color; 最后结束，当然输出： [1,2]:null

胡鹏 2009-04-15 19:28 发表评论

在继承中的静态方法调用注意

胡鹏 — Wed, 15 Apr 2009 11:15:00 GMT

    在继承中的使用静态方法的时候该注意。。。。。
   你觉得下面程序很简单吧，打印出什么呢? 没看仔细要错的哦~！~

class Dog{
    public static void bark(){
        System.out.println("Dog bark");
    }
}

class Basenji extends Dog{
    public static void bark(){

    }
}

public class Test {
    public static void main(String []args) throws Exception{
        Dog dog = new Dog();
        Dog basenji = new Basenji();
        dog.bark();
        basenji.bark();

    }
}

程序运行结果：
Dog bark
Dog bark

打印出2个Dog bark，额，原来对静态方法的调用不存在任何动态的分派机制。这个没有注意很容易搞错的哦~！！~

胡鹏 2009-04-15 19:15 发表评论

求：2个数的最小公倍数和最大公约数

胡鹏 — Sun, 12 Apr 2009 07:03:00 GMT

简单程序：求2个数的最小公倍数和最大公约数

public class T {
    public static void main(String[] args) {

        int m, n;
        m= 32 ;
        n = 48;
        System.out.println(m+"和"+n+"的");
        System.out.println("最大公约数是：" + getGongYue(m,n));
        System.out.println("最小公倍数是：" + getGongBei(m,n));
    }

    /**
     * 得到 m,n 的最大公约数
     * @param m
     * @param n
     * @return
     */
    public static int getGongYue(int m, int n){
        int  r;
        do {
            if (m < n) {
                int t = m;
                m = n;
                n = t;
            }

            r = m % n;
            m = n;
            n = r;
        } while (r != 0);
        return m;
    }

    /**
     * 得到 m,n 的最小公倍数
     * @param m
     * @param n
     * @return
     */
    public static long getGongBei(int m,int n){
        return m*n/getGongYue(m,n);
    }
}

胡鹏 2009-04-12 15:03 发表评论

数据结构—算法介绍(转)

胡鹏 — Sun, 12 Apr 2009 06:37:00 GMT

算法(Algorithm)是一系列解决问题的清晰指令，也就是说，能够对一定规范的输入，在有限时间内获得所要求的输出。如果一个算法有缺陷，或不适合于某个问题，执行这个算法将不会解决这个问题。不同的算法可能用不同的时间、空间或效率来完成同样的任务。一个算法的优劣可以用空间复杂度与时间复杂度来衡量。

　　算法可以理解为有基本运算及规定的运算顺序所构成的完整的解题步骤。或者看成按照要求设计好的有限的确切的计算序列，并且这样的步
骤和序列可以解决一类问题。

一个算法应该具有以下五个重要的特征：
1、有穷性：一个算法必须保证执行有限步之后结束;

　　2、确切性：算法的每一步骤必须有确切的定义;

　　3、输入：一个算法有0个或多个输入，以刻画运算对象的初始情况，所谓0个输入是指算法本身定除了初始条件;

　　4、输出：一个算法有一个或多个输出，以反映对输入数据加工后的结果。没有输出的算法是毫无意义的;

　　5、可行性：算法原则上能够精确地运行，而且人们用笔和纸做有限次运算后即可完成。

计算机科学家尼克劳斯-沃思曾著过一本著名的书《数据结构+算法=程序》，可见算法在计算机科学界与计算机应用界的地位。

算法的复杂度

　　同一问题可用不同算法解决，而一个算法的质量优劣将影响到算法乃至程序的效率。算法分析的目的在于选择合适算法和改进算法。一个算法的评价主要从时间复杂度和空间复杂度来考虑。

　　时间复杂度

　　算法的时间复杂度是指算法需要消耗的时间资源。一般来说，计算机算法是问题规模n 的函数f(n)，算法的时间复杂度也因此记做

　　T(n)=Ο(f(n))

　　因此，问题的规模n 越大，算法执行的时间的增长率与f(n) 的增长率正相关，称作渐进时间复杂度(Asymptotic Time Complexity)。

　　空间复杂度

　　算法的空间复杂度是指算法需要消耗的空间资源。其计算和表示方法与时间复杂度类似，一般都用复杂度的渐近性来表示。同时间复杂度相比，空间复杂度的分析要简单得多。

算法设计与分析的基本方法

　　1.递推法

　　递推法是利用问题本身所具有的一种递推关系求问题解的一种方法。它把问题分成若干步，找出相邻几步的关系，从而达到目的，此方法称为递推法。

　　2.递归

　　递归指的是一个过程：函数不断引用自身，直到引用的对象已知

　　3.穷举搜索法

　　穷举搜索法是对可能是解的众多候选解按某种顺序进行逐一枚举和检验，并从众找出那些符合要求的候选解作为问题的解。

　　4.贪婪法

　　贪婪法是一种不追求最优解，只希望得到较为满意解的方法。贪婪法一般可以快速得到满意的解，因为它省去了为找最优解要穷尽所有可能而必须耗费的大量时间。贪婪法常以当前情况为基础作最优选择，而不考虑各种可能的整体情况，所以贪婪法不要回溯。

　　5.分治法

　　把一个复杂的问题分成两个或更多的相同或相似的子问题，再把子问题分成更小的子问题……直到最后子问题可以简单的直接求解，原问题的解即子问题的解的合并。

　　6.动态规划法

　　动态规划是一种在数学和计算机科学中使用的，用于求解包含重叠子问题的最优化问题的方法。其基本思想是，将原问题分解为相似的子问题，在求解的过程中通过子问题的解求出原问题的解。动态规划的思想是多种算法的基础，被广泛应用于计算机科学和工程领域。

　　7.迭代法

　　迭代是数值分析中通过从一个初始估计出发寻找一系列近似解来解决问题(一般是解方程或者方程组)的过程，为实现这一过程所使用的方法统称为迭代法。

算法分类

　　算法可大致分为基本算法、数据结构的算法、数论与代数算法、计算几何的算法、图论的算法、动态规划以及数值分析、加密算法、排序算法、检索算法、随机化算法、并行算法。

胡鹏 2009-04-12 14:37 发表评论

java数据结构学习—数据结构的基本概念(转)

胡鹏 — Sun, 12 Apr 2009 06:22:00 GMT

数据结构的基本概念

数据：

数据（data）是描述客观事物的数字、字符以及所有能够输入到计算机中并能被计算机接受的各种符号集合的统称。数据是信息的符号表示，是计算机程序的处理对象。除了数值数据，计算机能够处理的数据还可以是各种非数值数据，如字符串、图形、音频、视频等多媒体数据。

表示一个事物的一组数据称为一个数据元素（data element）：数据元素是数据的基本单位。一个数据元素可以是一个不可分割的原子项，也可以由多个数据项组成。

数据项（data item）是数据元素中有独立含义的、不可分割的最小标识单位。例如，一个整数、一个字符都是原子项；一个学生数据元素包含学号、姓名、性别和出生日期等多个数据项组成。

数据类型：

类型（type）是具有相同逻辑意义的一组值的集合。数据类型（data type）是指一个类型和定义在这个类型上的操作集合。数据类型定义了数据的性质、取值范围以及对数据所能进行的各种操作。例如，Java语言的整数类型int，除了数值集合[-231，...，-2，-1，0，1，2，...，231-1]之外，还包括在这个值集合上的操作集合[+，-，*，/，%，=]。

程序中的每一个数据都属于一个数据类型，决定了数据的类型也就决定了数据的性质以及对数据进行的运算和操作，同时数据也受到类型的保护，确保数据不能进行非法操作。

高级程序涉及语言通常预定一些基本数据类型和构造数据类型。基本数据类型的值是不可分解的，它可直接参与该类型所允许的运算。构造数据类型是使用已有的简单数据类型和已定义的构造数据类型按照一定的语法规则组织起来的较复杂的数据类型。构造数据类型的变量包含多个数据项。

java语言的基本数据类型有整数类型、浮点数类型、字符类型、布尔类型，构造数据类型（引用类型）有数组、类和接口。

数据结构

计算机处理的数据不是杂乱无章的，而是有着内在联系的。只有分析清楚它们的内在联系，对大量的、复杂的数据才能进行复核的组织和有效处理。

数据结构是指元素之间存在的关系。一个数据结构（data structure）是由n（n≥0）个数据元素组成的有限集合，数据元素之间具有某种特定的关系。

数据结构概念包括三方向：数据的逻辑结构

数据的存储结构

数据的操作

数据结构与数据类型两个概念的侧重点不同。数据类型研究的是每种数据所具有的特性，以及对这种特性的数据能够进行哪些操作；数据结构研究的是数据元素之间具有的相互关系，数据结构与数据元素的数据类型无关，也不随数据元素值的变化而变化。

抽象数据类型

程序设计语言使用数据类型描述数据特性，采取“表示与实现分离”的策略。语言本身仅提供数据类型的语法规则，并没有说明这些数据类型是如何实现的；程序员按照这些规则使用数据类型，而不必知道这些数据类型是如何实现的。

抽象数据类型（Abstract Data type，ADT）指一个数学模型以及定义在该模型上的一组操作。抽象数据类型和数据类型本质上是一个概念，它的最重要特征是将一个类型上的数据及操作的逻辑含义与具体实现分离

与使用数据类型描述数据特性一样，通常使用抽象数据类型描述数据结构，将线性表、树、图等数据结构分别定义为抽象数据类型，每种抽象数据类型描述一种数据结构的逻辑特性和操作，与该数据结构在计算机内的存储及实现无关。

抽象数据类型是软件模块化设计思想的重要手段。一个抽象数据类型是描述一种特定功能软件的基本模块，由各种基本模块可组织和构造起来一个庞大的软件系统。

胡鹏 2009-04-12 14:22 发表评论

java解惑——循环，你真的会吗？？

胡鹏 — Tue, 07 Apr 2009 14:49:00 GMT

使用StringBuffer时应该注意的：
StringBuffer sb = new StringBuffer('M');
sb.append("abc");
System.out.println(sb.toString());

该程序会输出什么呢？不是 mabc 输入结果为： abc
为什么m没有输出来呢？奇怪了？其实也不是很奇怪，StringBuffer没有字符为参数的构造方法，只有int作为缓冲区初始容量的构造器。
在本例子中， new StringBuffer('M') 返回的是一个具有初始容量77的空字符串缓冲区。

**2******************************************************************************************************************

下面的程序循环遍历byte数值，以查找某个特定值。这个程序会打印出什么？

public class BigDelight {
public static void main(String[] args) {
  for (byte b = Byte.MIN_VALUE; b < Byte.MAX_VALUE; b++) {
   if (b == 0x90)
    System.out.println("hello");
  }
}
}

结果什么都没有打印。
0x90是一个两位数的十六进制字面常量，每一个十六进制位都占据4个比特的位置，
所以整个数值也只占8个比特，即1个byte。问题在于byte是有符号类型，常量0x90是
一个正的最高位被置为8位int数值。合法的byte数值是从-128到+127，但是常量0x90等于+144

上面这个程序大家应该都能理解，但是下面整个判断是true还是false呢？
( (byte)0x90 == 0x90 ) ，当然是false啦，有点java基础知识的人都知道会转化成int比较的，
但转化后值是多少呢？这个这个。。。。。hoho (byte)0x90 提升为int数值-122，而0x90为144

如果要实现比较，其实也很简单。

方法一：只要我们相同的类型比较就可以啦，苹果跟苹果比较，桔子跟桔子比较。
最上面的程序改成：
if (b == (byte)0x90)
System.out.println("hello");
这就可以打印出来了。

方法二：
可以用一个屏蔽码来消除符号扩展的影响，从而将byte转化为int，之后就可以拿到一个int与另一个int进行比较了。
if ( (b & 0xff) == 0x90)
System.out.println("hello");

虽然上面的两种方法都可以，但是避免这类问题的最佳方法还是将常量值移到循环的外面，并在一个常量种定义它。

1public class BigDelight {
2 private static final byte TARGET = (byte)0x90;
3 public static void main(String[] args) {
4  for (byte b = Byte.MIN_VALUE; b < Byte.MAX_VALUE; b++) {
5   if ( b == TARGET )
6    System.out.println("hello");
7  }
8 }
9}

****3**************************************************************************************
下面的程序输入结果是什么呢？

public class Incremet {
public static void main(String[] args) {
  int j = 0;
  for(int i=0;i<100;i++){
   j = j++;
  }
  System.out.println(j);
}

}

乍一看应该慧是100吧。毕竟做了100次循环增量。结果确是0

j = j++; 整个操作细分开来大家都知道：
int temp = j;
j = j+1 ;
j = temp;

那如果是这样那么结果就不用怀疑了，j=0

****4***************************************************************************

下面的程序输出什么呢?

1public class InTheLoop {
2 public static final int END = Integer.MAX_VALUE;
3 public static final int START = Integer.MIN_VALUE;
4 public static void main(String[] args) {
5  int count = 0;
6  for(int i=START;i<=END;i++){
7   count ++;
8  }
9  System.out.println(count);
10 }
11}

应该是101吧，应该，那就是错啦，实际上是：在for循环中，出现了无限循环。
当i达到Integer.MAX_VALUE时，并且再次执行增量操作时，它就又绕回到了Integer.MIN_VALUE。所以就出现无限循环。

求：寻找一种定义，使得下面的循环一直无限，
   (1). for(int i=start;i<=start+1;i++){}
   (2). while(i== i+1){}
   (3). while(i !=i ){}
   (4). while(i!= i + 0 ){}，附加要求，不能使用浮点数类型
   (5). while(i<=j && i>=j && i!=j ){}
   (6). while(i!=0 && i== -i ){}

解答(1)：int start = Integer.MAX_VALUE-1; //不信你可以试一试
解答(2)：可以用任何计算位无穷大的浮点算术表达式来实现：
double i = 1.0/0.0; 一般都使用浮点数常量：double i = Double.POSITIVE_INFINITY;事实上，不必将i初始化为无穷大，
任何足够大的浮点数都可以实现这一目的。例如：double i = 1.0e40;
解答(3)：double i=0.0/0.0; 即：double i = Double.NaN;
解答(4)：把i定义成string类型就可以实现啦
解答(5)：Integer i = new Integer(0); Integer j = new Integer(0);
解答(6)：int i = Integer.MIN_VALUE; 或 long i = Long.MIN_VALUE;

寻找i一种定义，使得 if( i-i == 0 ){} if中的条件永远为false?
解答：double i=0.0/0.0; 即：double i = Double.NaN;

胡鹏 2009-04-07 22:49 发表评论

java解惑中的—异常，简单程序，但容易错

胡鹏 — Tue, 07 Apr 2009 12:51:00 GMT

下面三个程序每一个都会打印些什么？不要假设他们都可以编译通过：

第一个程序：

import java.io.IOException;

public class Arcane1 {
    public static void main(String[] args) {
        try{
            System.out.println("hello lsbwahaha");
        }catch(IOException e){
            System.out.println("I've never seen println fail!");
        }
    }
}

第二个程序：

1public class Arcane2 {
2    public static void main(String[] args) {
3        try{
4            //you have noting nice to say
5        }catch(Exception e){
6            System.out.println("this can't happen");
7        }
8    }
9}

第三个程序：

interface Type1{
    void f() throws CloneNotSupportedException;
}

interface Type2{
    void f() throws InterruptedException;
}

interface Type3 extends Type2,Type1{}

public class Arcane3 implements Type3 {
    public void f(){
        System.out.println("hello lsbwahaha");
    }
    public static void main(String[] args) {
        Type3 t3 = new Arcane3();
        t3.f();
    }
}

分析第一个程序：
        看起来应该会打印出hello lsbwahaha，这个程序不能编译，因为pringln犯法没有会抛出任何受检查异常，
而IOException 却正是一个受检查异常。
语言规范中描述：如果一个catch子句要捕获一个类型为E的受检查异常，而其相对应的try子句不能抛出E的某种子类型的异常，
那么这就是一个编译期错误。

分析第二个程序：
    基于第一个程序，那么第二个程序应该不可以编译，但是它却可以。它之所以可以编译，是因为它唯一的catch子句检查了Exception
   捕获Exception或Throwable的catch子句是合法的，不管于其相对应的try子句的内容为何。这个程序什么都不会打印。

分析第三个程序：
   看起来它也不能编译。如果它能编译，那是为什么呢？
结果居然能编译通过。。。。这个到底是为什么呢？、、、、、、、
     Type3 中因为每一个接口都限制了方法f可以抛出的受检查异常集合。一个方法可以抛出的受检查异常集合是它所适用的所有类型声明
要抛出的受检查异常交集，而不是并集。

胡鹏 2009-04-07 20:51 发表评论

BlogJava-lsbwahaha-随笔分类-java基础

java的4种Reference探讨

理解java中的ThreadLocal

Concurrent学习—Executor框架

TrueZIP使用过程中遇到的问题记录

antlr简介

责任链中：但个中的处理

用linkList实现LRU算法

java collection framework 的一些比较使用的记录

读《effective java》第二版，实用一，遇到多个构造器参数时要考虑用构造器

java中关键字volatile的含义(转)

Java 理论与实践: 正确使用 Volatile 变量

关于 java.util.ConcurrentModificationException 异常

看《java优化编程》一些细节上的东东

java如何进阶(转)

读《effective java》学习笔记一

关于eclipse和javac编译结果不一致的问题的分析与解决 (转)

Unicode简介(转)

常用的匹配正则表达式和实例(转)

java获取qq邮箱中的好友列表

CSVReader的下载地址

servlet中获取（其他网站的）验证码，显示在自己页面上

String,StringBuffer,StringBuilder之间的区别，以及使用中该注意什么(转)

for循环 while do while 中的一个小bug

又是一个hello world

静态数据初始化 你 真的了解了吗？构造方法的初始之后。。我又做错了，太粗心了

在继承中的 静态方法调用注意

求：2个数的最小公倍数和 最大公约数

数据结构—算法介绍(转)

java数据结构学习—数据结构的基本概念(转)

java解惑——循环，你真的会吗？？

java解惑中的—异常，简单程序，但容易错

静态数据初始化你真的了解了吗？构造方法的初始之后。。我又做错了，太粗心了

在继承中的静态方法调用注意

求：2个数的最小公倍数和最大公约数