java简繁转换（区分港台）

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<String> conflictingSets = new HashSet<String>();
	
	/** 繁体_台湾 */
	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<String, Integer> stringPossibilities = new HashMap<String, Integer>();
		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;
	}
}

参考文档

properties资源