[简易]中英文混合排序

package utils;

import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
*
* 【简易】中英文混合列表，首字母排序<br>
* 〈支持GBK中文编码范围 45217 - 55289 (十进制)〉
*/
public class StringSortUtils {

public static void main(String[] args) {
StringSortUtils sort = new StringSortUtils();
List<String> list = new ArrayList<String>();
list.add("adisen-A");
list.add("bulsi-B");
list.add("Kobe-K");
list.add("布丁-B");
list.add("杜甫-D");
list.add("宝马-B");
list.add("奔词-B");
list.add("比尔-B");
list.add("嚓的撒-C");// 多音字，不在该范围内
list.add("换手机-H");
list.add("天明-T");
list.add("吧马-B");
list.add("元方-Y");
list.add("芭吧-B");
list.add("分割-F");
list.add("割列-G");
list.add("啊-A");
list.add("#-0");
list.add("京东-J");
list.add("亚马逊-Y");
list.add("撒旦-S");
List<String> newList = sort.sort(list);
for (String string : newList) {
System.out.println(string);
}

System.out.println("-----------------------分割线-----------------------");

Map<String, List<String>> map = sort.sortAsMap(newList, TYPE_UPPERCASE);
String[] uppercaseTable = {
"A", "B", "C", "D", "E", "F", "G", "H", "I",
"J", "K", "L", "M", "N", "O", "P", "Q", "R",
"S", "T", "U", "V", "W", "X", "Y", "Z", "0"
};
for (String string : uppercaseTable) {
System.out.println(string + " : " + map.get(string));
}

// 例举：不在范围内的中文字符
System.out.println(sort.getGBValue('嚓'));
System.out.println(sort.getAlpha('嚓', 0));
System.out.println(sort.getGBValue('僮'));
System.out.println(sort.getAlpha('僮', 0));
System.out.println(sort.getGBValue('咗'));
System.out.println(sort.getAlpha('咗', 0));
}

public static final int TYPE_UPPERCASE = 0;

public static final int TYPE_LOWERCASE = 1;

// 默认匹配字符串数组
// 大写字符串数组
// 未匹配任何字母的，匹配0，排在最后
private String[] uppercaseTable = {
"A", "B", "C", "D", "E", "F", "G", "H", "I",
"J", "K", "L", "M", "N", "O", "P", "Q", "R",
"S", "T", "U", "V", "W", "X", "Y", "Z", "0"
};

// 小写字符串数组
// 未匹配任何字母的，匹配0，排在最后
private String[] lowercaseTable = {
"a", "b", "c", "d", "e", "f", "g", "h", "i",
"j", "k", "l", "m", "n", "o", "p", "q", "r",
"s", "t", "u", "v", "w", "x", "y", "z", "0"
};

/*
* 1. 字母Z使用了两个标签，这里有27个值
* 2. i, u, v都不做声母, 跟随前面的字母
* 3. 中文定义根据GBK编码规律，选取对应26个字母发音的第一个中文，第27个为Z字母的最后一个中文，
* 例： 阿-45218，在 A-啊-45217和B-芭-45253内
*
* 注意：还有很多字不在按照此规律，不在改范围内，例如：多音字-嚓 ca cha -57578
*
* 对应GBK的值：
* 啊 : 45217 芭 : 45253 擦 : 45761 搭 : 46318 蛾 : 46826 发 : 47010 噶 : 47297 哈 : 47614 哈 : 47614
* 击 : 48119 喀 : 49062 垃 : 49324 妈 : 49896 拿 : 50371 哦 : 50614 啪 : 50622 期 : 50906 然 : 51387
* 撒 : 51446 塌 : 52218 塌 : 52218 塌 : 52218 挖 : 52698 昔 : 52980 压 : 53689 匝 : 54481 座 : 55289
* }
*/
private char[] chartable = {
'啊', '芭', '擦', '搭', '蛾', '发', '噶', '哈', '哈',
'击', '喀', '垃', '妈', '拿', '哦', '啪', '期', '然',
'撒', '塌', '塌', '塌', '挖', '昔', '压', '匝', '座'
};

/* 初始化数组
* 明白了原理，可以去除 chartable 和代码块，简化为 ：
* private int[] table = {
*      45217,45253,45761,46318,46826,47010,47297,47614,47614,
*      48119,49062,49324,49896,50371,50614,50622,50906,51387,
*      51446,52218,52218,52218,52698,52980,53689,54481,55289
* };
*/
private int[] table = new int[27];

{
// 普通代码块
for (int i = 0; i < 27; ++i) {
table[i] = getGBValue(chartable[i]);
}
}

public StringSortUtils() {

}

/**
* 获取GBK(或gb2312)的汉字编码 <br>
* 〈gbk中文占两个字节，英文占一个字节，当得到一个字节时，返回0〉
* <pre>
*  getGBValue("吧") = 45257
* </pre>
*/
private int getGBValue(char ch){
String str = ch + "";
try{
byte[] bytes = str.getBytes("GBK");
if(bytes.length < 2)
return 0;
// 0xff00 = 65280, 0xff = 255
return (bytes[0] << 8 & 0xff00) + (bytes[1] & 0xff);
}catch(UnsupportedEncodingException e) {
return 0;
}
}

/**
* 中英文混合列表排序 <br>
* 〈对中英文混合列表按照首字母排序〉
*/
public List<String> sort(List<String> list) {
List<String> result = new ArrayList<String>();
for(String str : uppercaseTable) {
for (int i = 0; i < list.size(); i++) {
if(str.equals(getAlpha(list.get(i).toString().charAt(0), TYPE_UPPERCASE))) {
result.add(list.get(i).toString());
list.remove(i);
i--;
}
}
}
return result;
}

/**
* 排序,返回Map<br>
* 〈字符串列表，按照首字符的首字母进行排序，返回按照英文字母归类的Map,Map的value值是对应英文字母下的字符串列表〉
*
* @param list
* @param type 类型 -- 大/小写(TYPE_UPCASE / TYPE_LOWERCASE)(0/1)
* @return Map<String, List<String>>
*/
public Map<String, List<String>> sortAsMap(List<String> list, int type){
Map<String, List<String>> resultMap = new HashMap<String, List<String>>();
List<String> arr = new ArrayList<String>();
String [] table = (type == TYPE_UPPERCASE) ? uppercaseTable : lowercaseTable;
for(String str : table) {
for (int i = 0; i < list.size(); i++) {
if(str.equals(getAlpha(list.get(i).toString().charAt(0), type))) {
arr.add(list.get(i).toString());
list.remove(i);
i--;
}
}
resultMap.put(str, arr);
arr = new ArrayList<String>();
}
return resultMap;
}

/**
* 得到字符串的第一个字符的首字母<br>
* <pre>
*  英文字母返回对应的大小写字母，中文按照大小对比，判断该字的首字母.
*  例: 啊(45217) < 阿(45218) < 芭(45253)
*      getAlpha('阿',TYPE_UPPERCASE) == A
* </pre>
*/
public String getAlpha(char ch, int type) {
// 英文字母返回对应的大小写字母
if(ch >= 'a' && ch <= 'z') {
return TYPE_UPPERCASE == type ? (char)(ch - 'a' + 'A') + "" : ch + "";
}
if(ch >= 'A' && ch <= 'Z'){
return TYPE_UPPERCASE == type ? ch + "" : (char)(ch - 'A' + 'a') + "";
}
// 如果该字符不在支持的中文字符编码范围内，又不为英文字母
int gb = getGBValue(ch);
if(gb < table[0] || gb > table[26])
return "0";
// 遍历得到字符首字母对应 table 数组的位置
int i;
for(i = 0; i < 26; ++i) {
if(match(i, gb))
break;
}
if(i >= 26) {
return "0";
} else {
return TYPE_UPPERCASE == type ? uppercaseTable[i] + "" : lowercaseTable[i] + "";
}
}

private boolean match(int i, int gb) {
if(gb < table[i])
return false;
int j = i + 1;
// 遇到不发声的首字母
while(j < 26 && (table[j] == table[i]))
++j;
// 字母Z使用了两个标签
return j == 26 ? gb <= table[j] : gb < table[j];
}
}

adisen-A
啊-A
bulsi-B
布丁-B
宝马-B
奔词-B
比尔-B
吧马-B
芭吧-B
杜甫-D
分割-F
割列-G
换手机-H
京东-J
Kobe-K
撒旦-S
天明-T
元方-Y
亚马逊-Y
嚓的撒-C
#-0
-----------------------分割线-----------------------
A : [adisen-A, 啊-A]
B : [bulsi-B, 布丁-B, 宝马-B, 奔词-B, 比尔-B, 吧马-B, 芭吧-B]
C : []
D : [杜甫-D]
E : []
F : [分割-F]
G : [割列-G]
H : [换手机-H]
I : []
J : [京东-J]
K : [Kobe-K]
L : []
M : []
N : []
O : []
P : []
Q : []
R : []
S : [撒旦-S]
T : [天明-T]
U : []
V : []
W : []
X : []
Y : [元方-Y, 亚马逊-Y]
Z : []
0 : [嚓的撒-C, #-0]
57578
0
55767
0
34296
0