java工具类，支持中文简体转香港繁体、台湾繁体，繁体转简体；

代码如下：

package translate;

import java.io.BufferedReader;

import java.io.FileNotFoundException;

import java.io.IOException;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Iterator;

import java.util.Map;

import java.util.Properties;

import java.util.Set;

/**

* 类名称：HKTWwordVO

* 类描述：香港、台湾字体库

*

* @author wangsen

* 创建时间：2018年5月15日 下午4:12:39

*

*/

public class HKTWwordVO {

/** 所有词汇 */

private Properties charMap = new Properties();

/** 高频词汇 */

private Set conflictingSets = new HashSet();

/** 繁体_台湾 */

public static final int TAIWAN = 0;

/** 繁体_香港 */

public static final int HONGKONG = 1;

/** 简体 */

public static final int SIMPLE = 2;

private static final int NUM_OF_CONVERTERS = 3;

private static final HKTWwordVO[] converters = new HKTWwordVO[NUM_OF_CONVERTERS];

private static final String[] propertyFiles = new String[NUM_OF_CONVERTERS];

static {

propertyFiles[TAIWAN] = "taiwan.properties"; // 台湾

propertyFiles[HONGKONG] = "hongkong.properties"; // 香港

propertyFiles[SIMPLE] = "simple.properties"; // 简体

}

public static void main(String[] args) {

String str = "钩子里面是关注";

// 转台湾繁体

String convert = HKTWwordVO.convert(str, HKTWwordVO.TAIWAN);

System.out.println(convert);

// 转香港繁体

convert = HKTWwordVO.convert(str, HKTWwordVO.HONGKONG);

System.out.println(convert);

// 繁体转简体

String convert2 = HKTWwordVO.convert("鉤子裡面是關注、鈎子裏面是關注", HKTWwordVO.SIMPLE);

System.out.println(convert2);

}

/**

*

* @param converterType

* 0 for traditional and 1 for simplified

* @return

*/

public static HKTWwordVO getInstance(int converterType) {

if (converterType >= 0 && converterType < NUM_OF_CONVERTERS) {

if (converters[converterType] == null) {

synchronized (HKTWwordVO.class) {

if (converters[converterType] == null) {

converters[converterType] = new HKTWwordVO(

propertyFiles[converterType]);

}

}

}

return converters[converterType];

} else {

return null;

}

}

public static String convert(String text, int converterType) {

HKTWwordVO instance = getInstance(converterType);

return instance.convert(text);

}

private HKTWwordVO(String propertyFile) {

InputStream is = null;

is = getClass().getResourceAsStream(propertyFile);

// File propertyFile = new

// File("C:/Temp/testMDB/TestTranslator/abc.txt");

if (is != null) {

BufferedReader reader = null;

try {

reader = new BufferedReader(new InputStreamReader(is));

charMap.load(reader);

} catch (FileNotFoundException e) {

} catch (IOException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} finally {

try {

if (reader != null)

reader.close();

if (is != null)

is.close();

} catch (IOException e) {

}

}

}

initializeHelper();

}

@SuppressWarnings("rawtypes")

private void initializeHelper() {

Map stringPossibilities = new HashMap();

Iterator iter = charMap.keySet().iterator();

while (iter.hasNext()) {

String key = (String) iter.next();

if (key.length() >= 1) {

for (int i = 0; i < (key.length()); i++) {

String keySubstring = key.substring(0, i + 1);

if (stringPossibilities.containsKey(keySubstring)) {

Integer integer = (Integer) (stringPossibilities

.get(keySubstring));

stringPossibilities.put(keySubstring, new Integer(

integer.intValue() + 1));

} else {

stringPossibilities.put(keySubstring, new Integer(1));

}

}

}

}

iter = stringPossibilities.keySet().iterator();

while (iter.hasNext()) {

String key = (String) iter.next();

if (((Integer) (stringPossibilities.get(key))).intValue() > 1) {

conflictingSets.add(key);

}

}

}

public String convert(String in) {

StringBuilder outString = new StringBuilder();

StringBuilder stackString = new StringBuilder();

for (int i = 0; i < in.length(); i++) {

char c = in.charAt(i);

String key = "" + c;

stackString.append(key);

if (conflictingSets.contains(stackString.toString())) {

} else if (charMap.containsKey(stackString.toString())) {

outString.append(charMap.get(stackString.toString()));

stackString.setLength(0);

} else {

CharSequence sequence = stackString.subSequence(0,

stackString.length() - 1);

stackString.delete(0, stackString.length() - 1);

flushStack(outString, new StringBuilder(sequence));

}

}

flushStack(outString, stackString);

return outString.toString();

}

private void flushStack(StringBuilder outString, StringBuilder stackString) {

while (stackString.length() > 0) {

if (charMap.containsKey(stackString.toString())) {

outString.append(charMap.get(stackString.toString()));

stackString.setLength(0);

} else {

outString.append("" + stackString.charAt(0));

stackString.delete(0, 1);

}

}

}

String parseOneChar(String c) {

if (charMap.containsKey(c)) {

return (String) charMap.get(c);

}

return c;

}

}