java中文排序问题(转)

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。所以我们只建这部分汉字的笔画表。汉字笔画数表,我们可以照下面的方法生成:

用java程序生成一个文本文件(Chinese.csv)。包括所有的从U9FA6-U9FBF的字符的编码和文字。利用excel的笔画排序功能,对Chinese.csv文件中的内容排序。 编写Java程序分析Chinese.csv文件,求得笔画数, 生成ChineseStroke.csv。矫正笔画数,重新汉字的Unicode编码对ChineseStroke.csv文件排序。 只保留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的少数几个汉字的笔画数不对。核对并矫正笔画数后,用ExcelUnicode重新排序,去掉汉字和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);        
    }
}

http://blog.csdn.net/hsliwei/article/details/7020628

时间: 2024-10-10 16:52:36

java中文排序问题(转)的相关文章

Java 中文乱码问题总结

开发java应用出现乱码是很常见的,毕竟现在unicode的使用还不是很广泛,在使用gb2312(包含了gbk简体,big5繁体)的系统中要正确 实现中文的display和数据库的存储是最基本的要求. 1,首先developer要明确自己为什么会遇到乱码,遇到什么样的乱码(无意义的符号还是一串问号或者其它什么东西). 新手遇到一堆很乱的字符时通常不知所措,最直接的反映就是打开google搜索“java中文”(这个字符串在搜索引擎上的查询频率非常高), 然后一个一个的去看别人的解决方法.这样做没有

java集合排序问题

List: 元素是有序的,元素可以重复,因为该集合体系有索引(脚标) 常用的子类对象: 1----ArrayList 底层的数据结构是使用的数组结构特点:查询速度快,但是增删比较慢 2----LinkedList底层的数据结构使用的是链表结构特点:增删速度快,但是查询比较慢 Vector 底层是数组数据结构. 线程同步,ArrayList线程不同步,替代了vector ArrayList 是可变长度数组,默认长度是10,当添加的元素大于10时,系统自动new一个新的数组且增长原数组的一半长度,并

关于c++与java中文乱码问题分析与解决

关于c++与java中文乱码问题分析与解决 DionysosLai([email protected])  2014/8/1 问题分析: 之所以会出现中文乱码问题,归根结底在于中文的编码与英文的编码方式存在差异. 在java内部是使用16bit的unicode编码(即utf-16)来表示字符串,无论英文还是中文都是2字节. C/C++使用的是原始数据,ascii是一个字节,中文一般是GB2312编码,用2个字节表示一个汉字. Jni内部是使用utf-8编码表示字符串的,utf-8是扁长的unic

java 中文转拼音之pinyin4j

一.简单介绍 有时候,需要将汉字编程对应的拼音,以方便数据的处理.比如在Android手机应用的开发上,要查询联系人的姓名,通常都是用拼音进行查询的. 比如要查询"曹孟德",就可以输入"cmd",即"曹孟德"三个汉字的拼音"caomengde"各字的首字母.但是怎样才能将"曹孟德"翻译成"caomengde"呢? 很简单的办法就是建立一个大的对照表(比如用关联容器Map),比如<&

文《关于c++与java中文乱码问题分析与解决》中一个bug分析

文<关于c++与java中文乱码问题分析与解决>中一个bug分析 DionysosLai([email protected]) 2014/10/21 在前几篇一博客<关于c++与java中文乱码问题分析与解决>,地址如下:http://blog.csdn.net/dionysos_lai/article/details/38389765.文中详细介绍了c++与java数据传递时,为何会出现中文乱码的原因,并提出了适当的解决方法.方法如下: int CCDirector::GBKTo

java中文乱码解决方法汇总

publicstaticvoidmain(String[]argv){ try{ System.out.println("中文");//1 System.out.println("中文".getBytes());//2 System.out.println("中文".getBytes("GB2312″));//3 System.out.println("中文".getBytes("ISO8859_1″));

java hashtable 排序问题

? 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 Hashtable<String, String> h = new Hashtable<String, String>(); h.put("6", "666"); h.put("8", "888"); h.put("2", "222"); <br>for (Stri

java中文乱码解决之道(一)-----认识字符集

沉寂了许久(大概有三个多月了吧),LZ"按捺不住"开始写博了! java编码中的中文问题是一个老生常谈的问题了,每次遇到中文乱码LZ要么是按照以前的经验修改,要么则是baidu.com来解决问题.阅读许多关于中文乱码的解决办法的博文后,发现对于该问题我们都(更加包括我自己)没有一个清晰明了的认识,于是LZ想通过这系列博文(估计只有几篇)来彻底分析.解决java中文乱码问题,如有错误之处望各位同仁指出!当然,此系列博文并非LZ完全原创,都是在前辈基础上总结,归纳,如果雷同纯属借鉴-- 问

Java中文乱码处理

一.处理get方法中文乱码 方法1   String name = new String(request.getParameter("userName").getBytes("iso-8859-1")); 方法2   在tomcat的conf文件下server.xml中redirectPort="8443"位置后添加: URIencoding="GBK" 二.处理post方法中文乱码 request.setCharacte