BlogJava-Jeff on Java Development-随笔分类-跟老刘学Java http://www.blogjava.net/jeff-lau/category/28232.html我的小宇宙要爆发了--尿急啊zh-cnSat, 22 Dec 2007 00:28:25 GMTSat, 22 Dec 2007 00:28:25 GMT60中文数字http://www.blogjava.net/jeff-lau/archive/2007/12/21/169466.htmlJeff LauJeff LauFri, 21 Dec 2007 15:09:00 GMThttp://www.blogjava.net/jeff-lau/archive/2007/12/21/169466.htmlhttp://www.blogjava.net/jeff-lau/comments/169466.htmlhttp://www.blogjava.net/jeff-lau/archive/2007/12/21/169466.html#Feedback0http://www.blogjava.net/jeff-lau/comments/commentRss/169466.htmlhttp://www.blogjava.net/jeff-lau/services/trackbacks/169466.html摘要：以中文的形式表示数字，在开具发票、收据的时候经常用到，尤其在金融领域。但数字的中文表示和其它语言有很大的不同，如中文以每4个数字(万)为一个小的分隔。 本文以测试驱动开发的方法，开发该功能。本程序只是用表示整数的中文形式，很容易扩展到long形式和表示人民币货币的表示形式。

作者：Jeff 发表于：2006-12-02 08:12 最后更新于： 2007年12月21日 23:10
版权声明：可以任意转载，转载时请务必以超链接形式标明文章原始出处和作者信息及本版权声明。
http://www.blogjava.net/jeff-lau/archive/2007/12/21/169466.html

/**
  * @author Jeff
  *
  * Copyright (c) 复制或转载本文，请保留该注释。
  */
package chinese.utility.test;

import org.junit.Assert;
import org.junit.Test;

import chinese.utility.ChineseNumber;

public class ChinesNumberFormatter {

    /**
     * 单个数字 0--9
     */
    @Test
    public void testSingleLower() {
        Assert.assertEquals("零", new ChineseNumber(0).lower());
        Assert.assertEquals("五", new ChineseNumber(5).lower());
    }
    /**
     * 10--99
     */
    @Test
    public void test2BitLower() {
        Assert.assertEquals("六十八", new ChineseNumber(68).lower());
        Assert.assertEquals("八十", new ChineseNumber(80).lower());
    }

    /**
     * 100--999
     */
    @Test
    public void test3BitLower() {
        Assert.assertEquals("五百零八", new ChineseNumber(508).lower());
        Assert.assertEquals("八百", new ChineseNumber(800).lower());       
    }

    /**
     * 1000--9999
     */
    @Test
    public void test4BitLower() {
        Assert.assertEquals("一千零八", new ChineseNumber(1008).lower());
        Assert.assertEquals("一千零八十", new ChineseNumber(1080).lower());

    }
    /**
     * > 9999
     */
    @Test
    public void test5BitLower() {
        Assert.assertEquals("三十万零八千", new ChineseNumber(308000).lower());
        Assert.assertEquals("三十万零八百", new ChineseNumber(300800).lower());
    }
    /**
     * 缩写和大写一起测
     */
    @Test
    public void testAbbriation() {
        Assert.assertEquals("拾捌", new ChineseNumber(18, true).upper());
    }

}

测试

/**
  * @author Jeff
  *
  * Copyright (c) 复制或转载本文，请保留该注释。
  */
package chinese.utility;

public class ChineseNumber {

    private static final int RADIX = 10;

    private static final String[] LOWER_UNIT = { "", "十", "百", "千", "万", "十",
            "百", "千", "亿", "十", "百", "千", "万", "十", "百", "千", "万" };
    private String[] LOWER = { "零", "一", "二", "三", "四", "五", "六", "七", "八", "九" };

    private static final String[] UPPER_UNIT = { "", "拾", "佰", "仟", "万", "拾",
            "佰", "仟", "亿", "拾", "佰", "仟", "万", "拾", "佰", "仟", "万" };
    private String[] UPPER = { "零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖" };

    private int number;
    private boolean abbreviation;

    public ChineseNumber(int number, boolean isShort) {
        this.number = number;
        this.abbreviation = isShort;
    }

    public ChineseNumber(int number) {
        this(number, false);
    }

    public String lower() {
        return format(LOWER, LOWER_UNIT);
    }
    public String upper() {   
        return format(UPPER, UPPER_UNIT);
    }
    private String format(final String[] chinese, final String[] unit) {
        if (number == 0) {
            return chinese[number];
        }

        if (abbreviation == true && canAbbreviate(number)) {
            return formatShort(chinese, unit);
        }
        String result = "";

        int leftNumber = number;
        int rightNumber = 0;
        int currentNumber = 0;
        int bit = 0;
        while (leftNumber > 0) {
            rightNumber = currentNumber;
            currentNumber = leftNumber % RADIX;
            leftNumber = leftNumber / RADIX;

            if (currentNumber > 0) {
                result = chinese[currentNumber] + unit[bit] + result;
            } else if (rightNumber > 0) {
                result = chinese[currentNumber] + result;
            }

            if (bit % 4 == 0 && currentNumber == 0) {
                result = unit[bit] + result;
            }

            bit++;
        }

        return result;

    }

    /**
     * 缩写 18 为 十八 或 拾捌
     */
    private String formatShort(String[] chinese, String[] unit) {       
        return unit[1] + chinese[number % RADIX];
    }

    /**
     * 能否缩写
     */
    private boolean canAbbreviate(int number2) {
        if (number2 >= 9 && number2 <= 19) {
            return true;
        }
        return false;
    }

}



Jeff Lau 2007-12-21 23:09 发表评论
]]>中文排序http://www.blogjava.net/jeff-lau/archive/2007/12/21/169257.htmlJeff LauJeff LauFri, 21 Dec 2007 03:29:00 GMThttp://www.blogjava.net/jeff-lau/archive/2007/12/21/169257.htmlhttp://www.blogjava.net/jeff-lau/comments/169257.htmlhttp://www.blogjava.net/jeff-lau/archive/2007/12/21/169257.html#Feedback1http://www.blogjava.net/jeff-lau/comments/commentRss/169257.htmlhttp://www.blogjava.net/jeff-lau/services/trackbacks/169257.html摘要：在Java中，对一个数组或列表(在本文中统称为集合)中的元素排序，是一个很经常的事情。好在Sun公司在Java库中实现了大部分功能。如果集合中的元素实现了Comparable接口，调用Array或Collections的静态(static)方法sort，就可以直接对集合排序。程序员用不同的方式实现了Comparator接口，就可以用各自不同的方式排序。对于包含汉字的字符串来说，排序的方式主要有两种：一种是拼音，一种是笔画。本文就讲述如何实现这两种不同的比较器(Comparator)。

作者：Jeff 发表于：2007年12月21日 11:27 最后更新于： 2007年12月21日 12:38
版权声明：可以任意转载，转载时请务必以超链接形式标明文章原始出处和作者信息及本版权声明。
http://www.blogjava.net/jeff-lau/archive/2007/12/21/169257.html

排序概述

在Java中，对一个数组或列表(在本文中统称为集合)中的元素排序，是一个很经常的事情。好在Sun公司在Java库中实现了大部分功能。如果集合中的元素实现了Comparable接口，调用以下的静态(static)方法，就可以直接对集合排序。

// 数组排序方法
// 数组中的元素可以是像int这样的原生类型(primitive type), 也可以是像String这样实现了Comparable接口的类型，这里用type表示。
java.util.Arrays.sort(type[] a);

// 列表
public static <T> void sort(List<T> list)

以上的这些排序方式能满足大部分应用。但集合中的元素没有实现Comparable接口，或者集合中的元素要按一种特别的方式排序，这要怎么办？Sun公司早就想到了，并在Java库中提供上面两个方法的重载。

// 数组排序方法。
// 数组中的元素可以是像int这样的原生类型(primitive type), 也可以是像String这样实现了Comparable接口的类型，这里用type表示。
public static <T> void sort(T[] a, Comparator<? super T> c)

// 列表
public static <T> void sort(List<T> list, Comparator<? super T> c)

只要实现了Comparator接口，就可以按程序员自己的意思去排序了。对于包含汉字的字符串来说，排序的方式主要有两种：一种是拼音，一种是笔画。汉字是通过一定的编码方式存储在计算机上的，主要的编码有：Unicdoe、GB2312和GBK等。

Unicode 编码中的汉字

Unicode中编码表分为两块，一个是基本的，一个是辅助的。现在的大多数操作系统还不支持Unicode中辅助区域中的文字，如WinXp。

在Java中的字符就是Unicode码表示的。对于Unicode基本区域中的文字，用两个字节的内存存储，用一个char表示，而辅助区域中的文字用4个字节存储，因此辅助区域中的就要用两个char来表示了(表一种蓝色底就是辅助区域中的文字)。一个文字的unicode编码，在Java中统一用codePoint(代码点)这个概念。

中文和日文、韩文一样是表意文字，在Unicode中，中日韩三国(东亚地区)的文字是统一编码的。CJK代表的就是中日韩。在这里，我把这3中文字，都作为汉字处理了。(日语和韩语可能就是从汉语中衍生的吧！)

汉字在Unicode中的分布大致如下表：

  首字编码 尾字编码 个数
基本汉字 U4E00 U9FBF 20928
异性字 UF900 UFAFF 512
扩展A U3400 U4D8F 512
扩展B U20000 U2A6DF 42720
补充 U2F800 U2FA1F 544
其他     ...
表一

在这些编码区间，有些编码是保留的。

GB2312编码

GB2312是中华人民共和国最早的计算机汉字编码方式。大概有6000多个汉字，这些汉字是按拼音顺序编码的。这6000多个汉字都是简体中文字。

GBK编码

GB2312的扩展，并兼容GB2312。扩展后的汉字大概有2万多个，其中有简体汉字也有繁体汉字。

拼音排序

拼音有好几种方式，其中最主要的是中华人民共和国的汉语拼音 Chinese Phonetic。对汉字的排序有两种：一种是宽松的，能够按拼音排序最常用的汉字，另一种是严格的，能够按拼音排序绝大部分大部分汉字。

宽松的拼音排序法

原理：汉字最早是GB2312编码，收录了六千多个汉字，是按拼音排序的，编码是连续的。 后来出现了GBK编码，对GB2312进行了扩展，到了两万多汉字，并且兼容GB2312，也就是说GB2312中的汉字编码是原封不动搬到GBK中的(在GBK编码中[B0-D7]区中)。

如果我们只关心这6000多个汉字的顺序，就可以用下面的方法实现汉字宽松排序。

/**
* @author Jeff
*
* Copyright (c) 复制或转载本文，请保留该注释。
*/

package chinese.utility;

import java.text.Collator;
import java.util.Comparator;
import java.util.Locale;

public class PinyinSimpleComparator implements Comparator<String> {
    public int compare(String o1, String o2) {
        return Collator.getInstance(Locale.CHINESE).compare(o1, o2);
    }
}

在对[孙, 孟, 宋, 尹, 廖, 张, 徐, 昆, 曹, 曾,怡]这几个汉字排序，结果是：[曹, 昆, 廖, 孟, 宋, 孙, 徐, 尹, 曾, 张, 怡]。最后一个 怡 有问题，不该排在最后的。

注意：这个程序有两个不足

  • 由于gb2312中的汉字编码是连续的，因此新增加的汉字不可能再按照拼音顺序插入到已有的gb2312编码中，所以新增加的汉字不是按拼音顺序排的。
  • 同音字比较的结果不等于0 。

下面的测试代码可以证明

/**
* @author Jeff
*
* Copyright (c) 复制或转载本文，请保留该注释。
*/

/**
* 非常用字(怡)
*/
@Test
public void testNoneCommon() {
    Assert.assertTrue(comparator.compare("怡", "张") > 0);
}

/**
* 同音字
*/
@Test
public void testSameSound() {
    Assert.assertTrue(comparator.compare("怕", "帕") != 0);
}

严格的拼音排序法

为了解决宽松的拼音的两点不足，可以通过实现汉语拼音的函数来解决。goolge下看到sf上有个pinyin4j的项目，可以解决这个问题，pinyin4j的项目地址是：http://pinyin4j.sourceforge.net/。

实现代码：

/**
  * @author Jeff
  *
  * Copyright (c) 复制或转载本文，请保留该注释。
  */
package chinese.utility;

import java.util.Comparator;
import net.sourceforge.pinyin4j.PinyinHelper;

public class PinyinComparator implements Comparator<String> {

    public int compare(String o1, String o2) {

        for (int i = 0; i < o1.length() && i < o2.length(); i++) {

            int codePoint1 = o1.charAt(i);
            int codePoint2 = o2.charAt(i);

            if (Character.isSupplementaryCodePoint(codePoint1)
                    || Character.isSupplementaryCodePoint(codePoint2)) {
                i++;
            }

            if (codePoint1 != codePoint2) {
                if (Character.isSupplementaryCodePoint(codePoint1)
                        || Character.isSupplementaryCodePoint(codePoint2)) {
                    return codePoint1 - codePoint2;
                }

                String pinyin1 = pinyin((char) codePoint1);
                String pinyin2 = pinyin((char) codePoint2);

                if (pinyin1 != null && pinyin2 != null) { // 两个字符都是汉字
                    if (!pinyin1.equals(pinyin2)) {
                        return pinyin1.compareTo(pinyin2);
                    }
                } else {
                    return codePoint1 - codePoint2;
                }
            }
        }
        return o1.length() - o2.length();
    }

    /**
     * 字符的拼音，多音字就得到第一个拼音。不是汉字，就return null。
     */
    private String pinyin(char c) {
        String[] pinyins = PinyinHelper.toHanyuPinyinStringArray(c);
        if (pinyins == null) {
            return null;
        }
        return pinyins[0];
    }
}

测试：

/**
  * @author Jeff
  *
  * Copyright (c) 复制或转载本文，请保留该注释。
  */
package chinese.utility.test;

import java.util.Comparator;

import org.junit.Assert;
import org.junit.Test;

import chinese.utility.PinyinComparator;

public class PinyinComparatorTest {

    private Comparator<String> comparator = new PinyinComparator();

    /**
     * 常用字
     */
    @Test
    public void testCommon() {
        Assert.assertTrue(comparator.compare("孟", "宋") < 0);
    }

    /**
     * 不同长度
     */
    @Test
    public void testDifferentLength() {
        Assert.assertTrue(comparator.compare("他奶奶的", "他奶奶的熊") < 0);
    }

    /**
     * 和非汉字比较
     */
    @Test
    public void testNoneChinese() {
        Assert.assertTrue(comparator.compare("a", "阿") < 0);
        Assert.assertTrue(comparator.compare("1", "阿") < 0);
    }

    /**
     * 非常用字(怡)
     */
    @Test
    public void testNoneCommon() {
        Assert.assertTrue(comparator.compare("怡", "张") < 0);
    }

    /**
     * 同音字
     */
    @Test
    public void testSameSound() {
        Assert.assertTrue(comparator.compare("怕", "帕") == 0);
    }

    /**
     * 多音字(曾)
     */
    @Test
    public void testMultiSound() {
        Assert.assertTrue(comparator.compare("曾经", "曾迪") > 0);
    }

}

我的这样严格的拼音排序还是有有待改进的地方，看上面测试代码的最后一个测试，就会发现：程序不会根据语境来判断多音字的拼音，仅仅是简单的取多音字的第一个拼音。

笔画排序

要按笔画排序，就要实现笔画比较器。

class StokeComparator implements Comparator<String>

如果有个方法可以求得汉字的笔画数，上面的功能就很容易实现。如何求一个汉字的笔画数？最容易想到的就是查表法。建一个汉字笔画数表，如：

汉字 Unicode编码 笔画数
一 U4E00 1
二 U4E8C 2
龍 U9F8D 16
... ... ...
表二

如果是连续的、按unicode编码排好顺序的表，实际存储在笔画数表中的只需最后一列就够了。

那如何建这个表呢？这个表存储在哪里？

建汉字笔画数表

现在大多数系统还只能支持Unicode中的基本汉字那部分汉字，编码从U9FA6-U9FBF。所以我们只建这部分汉字的笔画表。汉字笔画数表，我们可以按照下面的方法生成：

  1. 用java程序生成一个文本文件(Chinese.csv)。包括所有的从U9FA6-U9FBF的字符的编码和文字。利用excel的按笔画排序功能，对Chinese.csv文件中的内容排序。
  2. 编写Java程序分析Chinese.csv文件，求得笔画数, 生成ChineseStroke.csv。矫正笔画数，重新按汉字的Unicode编码对ChineseStroke.csv文件排序。
  3. 只保留ChineseStroke.csv文件的最后一列，生成Stroke.csv。

在这里下载上面3个步骤生成的3个文件。

生成Chinese.csv的Java程序

/**
  * @author Jeff
  *
  * Copyright (c) 复制或转载本文，请保留该注释。
  */
package chinese.utility.preface;

import java.io.IOException;
import java.io.PrintWriter;

public class ChineseCoder {

    public static void main(String[] args) throws IOException {
        PrintWriter out = new PrintWriter("Chinese.csv");
        // 基本汉字
        for(char c = 0x4E00; c <= 0x9FA5; c++) {
            out.println((int)c + "," + c);
        }
        out.flush();
        out.close();

    }

}

初始化笔画数

从Excel排序过后的Chinese.csv文件来看，排好序的文件还是有一定规律的。在文件的第9行-12行可以看出：逐行扫描的时候，当unicode会变小了，笔画数也就加1。

20059,乛
20101,亅
19969,丁
19970,丂

用下面的Java程序分析吧。

/**
  * @author Jeff
  *
  * Copyright (c) 复制或转载本文，请保留该注释。
  */
package chinese.utility.preface;

import java.io.File;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Scanner;

public class Stroke {

    /**
     * @param args
     * @throws IOException
     */
    public static void main(String[] args) throws IOException {
        Scanner in = new Scanner(new File("Chinese.csv"));       
        PrintWriter out = new PrintWriter("ChineseStroke.csv");
        String oldLine = "999999";
        int stroke = 0;
        while (in.hasNextLine()) {
            String line = in.nextLine();
            if (line.compareTo(oldLine) < 0) {
                stroke++;               
            }
            oldLine = line;
            out.println(line + "," + stroke);           
        }
        out.flush();
        out.close();
        in.close();
    }

}

上面用的这个规律有问题吗？有问题，从ChineseStroke.csv文件抽取最后几个汉字就发现，笔画数不对。为什么呢？

  • 笔画数可能不是连续的。
  • n+1笔画数的最小Unicode码可能比n笔画数的最大Unicode码要大

我们要人工核对ChineseStroke文件，但只要核对在笔画变化的那几个汉字的笔画数。最后，我发现，只有笔画数多于30的少数几个汉字的笔画数不对。核对并矫正笔画数后，用Excel按Unicode重新排序，去掉汉字和Unicode两列，只保留笔画数那列，得到Stroke.csv文件。

求得笔画数的方法和笔画比较器方法

求得笔画数的方法测试代码：

/**
  * @author Jeff
  *
  * Copyright (c) 复制或转载本文，请保留该注释。
  */
package chinese.utility.test;

import static org.junit.Assert.assertEquals;

import org.junit.Before;
import org.junit.Test;
import chinese.utility.Chinese;

public class StrokeTest {

    Chinese chinese;

    @Before
    public void setUp() {
        chinese = new Chinese();
    }

    @Test
    public void testStroke() {
        assertEquals(1, chinese.stroke('一'));
    }

    @Test
    public void testStroke2() {
        assertEquals(2, chinese.stroke('二'));
    }

    @Test
    public void testStroke16() {
        assertEquals(16, chinese.stroke('龍'));
    }

    @Test
    public void testStrokeABC() {
        assertEquals(-1, chinese.stroke('a'));
    }

}

求得笔画数的方法代码

/**
  * @author Jeff
  *
  * Copyright (c) 复制或转载本文，请保留该注释。
  */
package chinese.utility;

import java.util.Comparator;

public class StrokeComparator implements Comparator<String> {

    public int compare(String o1, String o2) {

        Chinese chinese = new Chinese();

        for (int i = 0; i < o1.length() && i < o2.length(); i++) {
            int codePoint1 = o1.codePointAt(i);
            int codePoint2 = o2.codePointAt(i);
            if (codePoint1 == codePoint2)
                continue;

            int stroke1 = chinese.stroke(codePoint1);
            int stroke2 = chinese.stroke(codePoint2);

            if (stroke1 < 0 || stroke2 < 0) {
                return codePoint1 - codePoint2;
            }

            if (stroke1 != stroke2) {
                return stroke1 - stroke2;
            }
        }

        return o1.length() - o2.length();
    }
}

笔画比较器测试

/**
  * @author Jeff
  *
  * Copyright (c) 复制或转载本文，请保留该注释。
  */
package chinese.utility.test;

import java.util.Comparator;

import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;

import chinese.utility.StrokeComparator;

public class StrokeComparatorTest {

    private Comparator<String> comparator;
    @Before
    public void setUp() {
        comparator = new StrokeComparator();
    }

    /**
     * 相同笔画数
     */
    @Test
    public void testCompareEquals() {
        Assert.assertTrue(comparator.compare("一", "丨") == 0);
    }
    /**
     * 不同笔画数
     */
    @Test
    public void testCompare() {
        Assert.assertTrue(comparator.compare("一", "二") < 0);
        Assert.assertTrue(comparator.compare("唔", "马") > 0);
    }
    /**
     * 长度不同
     */
    @Test
    public void testCompareDefficultLength() {
        Assert.assertTrue(comparator.compare("二", "二一") < 0);
    }
    /**
     * 非汉字的比较
     */
    @Test
    public void testABC() {
        Assert.assertTrue(comparator.compare("一", "a") > 0);
        Assert.assertTrue(comparator.compare("a", "b") < 0);       
    }
}

笔画比较器

/**
  * @author Jeff
  *
  * Copyright (c) 复制或转载本文，请保留该注释。
  */
package chinese.utility.test;

import java.util.Comparator;

import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;

import chinese.utility.StrokeComparator;

public class StrokeComparatorTest {

    private Comparator<String> comparator;
    @Before
    public void setUp() {
        comparator = new StrokeComparator();
    }

    /**
     * 相同笔画数
     */
    @Test
    public void testCompareEquals() {
        Assert.assertTrue(comparator.compare("一", "丨") == 0);
    }
    /**
     * 不同笔画数
     */
    @Test
    public void testCompare() {
        Assert.assertTrue(comparator.compare("一", "二") < 0);
        Assert.assertTrue(comparator.compare("唔", "马") > 0);
    }
    /**
     * 长度不同
     */
    @Test
    public void testCompareDefficultLength() {
        Assert.assertTrue(comparator.compare("二", "二一") < 0);
    }
    /**
     * 非汉字的比较
     */
    @Test
    public void testABC() {
        Assert.assertTrue(comparator.compare("一", "a") > 0);
        Assert.assertTrue(comparator.compare("a", "b") < 0);       
    }
}

其他程序的汉字排序

Microsoft在这方面做得比较好。如Sql server 2000，Word和Excel都能按拼音和笔画排序。而Oracle只能是采取宽松拼音排序法。



Jeff Lau 2007-12-21 11:29 发表评论
]]>中文排序 － 笔画http://www.blogjava.net/jeff-lau/archive/2007/12/20/169147.htmlJeff LauJeff LauThu, 20 Dec 2007 12:39:00 GMThttp://www.blogjava.net/jeff-lau/archive/2007/12/20/169147.htmlhttp://www.blogjava.net/jeff-lau/comments/169147.htmlhttp://www.blogjava.net/jeff-lau/archive/2007/12/20/169147.html#Feedback0http://www.blogjava.net/jeff-lau/comments/commentRss/169147.htmlhttp://www.blogjava.net/jeff-lau/services/trackbacks/169147.html摘要：在很多中文书籍的作者页中，有很多作者的话，很多时候，是按作者姓名的笔画顺序排序的。Microsoft的Excel和Sql Server实现了按笔画排序的功能。那按笔画顺序排序，在Java中究竟怎样实现呢？

作者：Jeff 发表于：2007-12-20 20:39 最后更新于： 2007年12月21日 12:17
版权声明：可以任意转载，转载时请务必以超链接形式标明文章原始出处和作者信息及本版权声明。
http://www.blogjava.net/jeff-lau/archive/2007/12/20/169147.html

合并了

已经将《中文排序--笔画》和《中文排序--汉语拼音》修改并合并《中文排序》中。这里只保留最后的代码。实现的原理和方法请见中文排序

/**
  * @author Jeff
  *
  * Copyright (c) 复制或转载本文，请保留该注释。
  */
package chinese.utility;

import java.util.Comparator;

public class StrokeComparator implements Comparator<String> {

    public int compare(String o1, String o2) {

        Chinese chinese = new Chinese();

        for (int i = 0; i < o1.length() && i < o2.length(); i++) {
            int codePoint1 = o1.codePointAt(i);
            int codePoint2 = o2.codePointAt(i);
            if (codePoint1 == codePoint2)
                continue;

            int stroke1 = chinese.stroke(codePoint1);
            int stroke2 = chinese.stroke(codePoint2);

            if (stroke1 < 0 || stroke2 < 0) {
                return codePoint1 - codePoint2;
            }

            if (stroke1 != stroke2) {
                return stroke1 - stroke2;
            }
        }

        return o1.length() - o2.length();
    }
}



Jeff Lau 2007-12-20 20:39 发表评论
]]>中文排序 － 汉语拼音http://www.blogjava.net/jeff-lau/archive/2007/12/19/168637.htmlJeff LauJeff LauWed, 19 Dec 2007 00:30:00 GMThttp://www.blogjava.net/jeff-lau/archive/2007/12/19/168637.htmlhttp://www.blogjava.net/jeff-lau/comments/168637.htmlhttp://www.blogjava.net/jeff-lau/archive/2007/12/19/168637.html#Feedback2http://www.blogjava.net/jeff-lau/comments/commentRss/168637.htmlhttp://www.blogjava.net/jeff-lau/services/trackbacks/168637.html摘要：中文一般都是按拼音来排序的。但Java中的String类是按Unicode编码存储数据的，因此，String类也是按Unicode编码的大小来排序的。Sun公司提供一个Collator类来重新按不同的规则对字符串排序，但Collator对中文的排序方式只是不严格的拼音排序法。Microsoft的Excel和Sql Server实现了按拼音排序的功能，就比Collator实现的好多了。那如何在Java中实现类似Microsoft的拼音排序的方式呢？

作者：Jeff 发表于：2007-12-19 08:30 最后更新于： 2007年12月21日 12:33
版权声明：可以任意转载，转载时请务必以超链接形式标明文章原始出处和作者信息及本版权声明。
http://www.blogjava.net/jeff-lau/archive/2007/12/19/168637.html

合并了

已经将《中文排序--笔画》和《中文排序--汉语拼音》修改并合并《中文排序》中。这里只保留最后的代码。实现的原理和方法请见中文排序。

/**
  * @author Jeff
  *
  * Copyright (c) 复制或转载本文，请保留该注释。
  */
package chinese.utility;

import java.util.Comparator;
import net.sourceforge.pinyin4j.PinyinHelper;

public class PinyinComparator implements Comparator<String> {

    public int compare(String o1, String o2) {

        for (int i = 0; i < o1.length() && i < o2.length(); i++) {

            int codePoint1 = o1.charAt(i);
            int codePoint2 = o2.charAt(i);

            if (Character.isSupplementaryCodePoint(codePoint1)
                    || Character.isSupplementaryCodePoint(codePoint2)) {
                i++;
            }

            if (codePoint1 != codePoint2) {
                if (Character.isSupplementaryCodePoint(codePoint1)
                        || Character.isSupplementaryCodePoint(codePoint2)) {
                    return codePoint1 - codePoint2;
                }

                String pinyin1 = pinyin((char) codePoint1);
                String pinyin2 = pinyin((char) codePoint2);

                if (pinyin1 != null && pinyin2 != null) { // 两个字符都是汉字
                    if (!pinyin1.equals(pinyin2)) {
                        return pinyin1.compareTo(pinyin2);
                    }
                } else {
                    return codePoint1 - codePoint2;
                }
            }
        }
        return o1.length() - o2.length();
    }

    /**
     * 字符的拼音，多音字就得到第一个拼音。不是汉字，就return null。
     */
    private String pinyin(char c) {
        String[] pinyins = PinyinHelper.toHanyuPinyinStringArray(c);
        if (pinyins == null) {
            return null;
        }
        return pinyins[0];
    }
}



Jeff Lau 2007-12-19 08:30 发表评论
]]>跟老刘学Java (一)http://www.blogjava.net/jeff-lau/archive/2007/12/19/168636.htmlJeff LauJeff LauTue, 18 Dec 2007 20:48:00 GMThttp://www.blogjava.net/jeff-lau/archive/2007/12/19/168636.htmlhttp://www.blogjava.net/jeff-lau/comments/168636.htmlhttp://www.blogjava.net/jeff-lau/archive/2007/12/19/168636.html#Feedback7http://www.blogjava.net/jeff-lau/comments/commentRss/168636.htmlhttp://www.blogjava.net/jeff-lau/services/trackbacks/168636.html老刘是个Java高手了，小刘是个Java菜鸟，最近小刘跟着老刘开始学Java。你问我，小刘和老刘什么关系？也许他们是兄妹吧。小刘是个MM啊，她漂亮吗，QQ号是多少，MSN呢……闲话少说，言归正传。

(小刘走向正在玩电脑的老刘身边)

小刘：老刘！(小刘一直都是这么称呼老刘的)。教我学Java吧！

老刘：好！(对于小刘的要求，老刘从没拒绝过)

小刘：可我对Java什么都不会！

老刘：有我在，一切都没问题！(在小刘面前，老刘总喜欢吹嘘。)我们先装个Java开发运行环境吧。

小刘：好呢！

老刘：我们先到Sun公司的网站下载一个JDK。JDK就是用来开发Java的工具。

小刘：Sun？就是天上的那个太阳啊！原来Java是太阳公司的啊！

老刘：基本上可以这么说。其他公司也有JDK产品。比如：IBM。

小刘：IBM我知道。被我国的联想公司收购了嘛！

老刘：(轻轻笑了一下)，就是那个IBM。不过联想只收购了IBM的一个部门而已。

 

(小刘在老刘的指导下，从SUN网站下载一个最新的JDK，现在正在下载中……)

小刘：刚才在SUN网站，我看到有个Java SE, Java EE,还有个……

老刘：还有Java ME。这是Java为不同的运行环境准备的3种不同版本，他们用的都是Java语言，学好Java语言就能开发3种不同应用程序了(Java在这3种版本除了使用的Java的语法相同外，还有很多很多不同的东西要掌握，才能不同完成开发工作，为了不打击小刘学习的积极性，把SUN蒙人的那套也用上了)。Java SE是Java的标准版，Java ME是用于手机软件开发的，Java EE是用于企业应用开发，比如网站啊。

小刘：Java还能建网站。我学会Java，就能用Java建一个自己漂亮的个人网站了。(托着下巴，仰着头开始遐想了……)

老刘：(晕*******，路途遥远着了)那就先学好Java吧。

(小刘回到现实，老刘继续解释)

老刘：Java SE可以说其他版本的基础。我们就学Java SE。现在最新的Java SE是6.0，下载页面在http://java.sun.com/javase/downloads/index.jsp。

 

(电脑提示：下载成功了)

老刘：现在安装吧。注意：Java的默认目录是C:\Program Files\..., 最好不要把Java带有空格的路径中。我们安装在D:\java目录中吧。Java SE安装包中，除了JDK，还有JRE。装好JDK后，会提示你是否安装JRE，我们一起安装了吧。

小刘：什么是JRE？

老刘：JRE就是Java运行环境。如果你只想运行Java程序，就不用安装JDK，只需要安装一个JRE就够了。现在安装好了。我们来写第一个全世界最有名的程序：HelloWorld。

(老刘用记事本创建下面一个文件：HelloWorld.java)

public class HelloWorld {

    public static void main(String[] args) {
        System.out.println("Hello World!");
    }

}

 

(老刘打开命令窗口，输入：javac HelloWorld.java。电脑显示：'javac' 不是内部或外部命令，也不是可运行的程序或批处理文件。)

老刘：我们的电脑是WinXP系统，和Win2000一样，都是WinNT系统的。设置一下环境变量，就能正常编译了。

老刘通过点击 我的电脑 --> 属性 --> 高级 --> 环境变量 打开了环境变量设置对话框。在系统变量中加入

JAVA_HOME=D:\java   (新建的)

path=%JAVA_HOME%\bin; (追加在path变量最前面)

 

(老刘再次打开命令窗口，输入：javac HelloWorld.java。正常了。输入：java HelloWorld。电脑显示Hello World!)

老刘：先休息一下。等会儿你自己照我刚才那样，写一个HelloWorld.java文件，并编译和运行它。

小刘：好的。

(小刘是个好学的菜鸟，不休息就开始她的第一个Java程序了……)

 

(HelloWorld.java虽然简单短小，粗心的小刘也输错了。在编译的时候出来了一堆错误，在老刘的帮助下，一一改正了这些错误。运行成功的时候，小刘高兴的跳了起来。觉得自己已经是Java高手了。高兴过后，小刘满心疑问……)

小刘：老刘！这些代码中的单词都什么意思？

老刘：这么，明天再讲吧！



Jeff Lau 2007-12-19 04:48 发表评论
]]>