java使用Unicode碼對中文進行排序

最近老師叫我們完成一個RAS的加密/解密過程，雖然不是很難，但是也遇到了很多以前沒有遇到的情況。其中unicode就讓我吃盡了苦頭，咳鬱悶啦，浪費了一天的時間。偶然看到了一篇介紹有關unicode的文章，覺得不錯，帖出來大家分享，也就當幫幫那作者了[呵呵 ！~~~~]

這個是鏈接地址：http://hi.baidu.com/1zebra/blog/item/e7f55a0fc6a6e62d6159f344.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);       
    }
}