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資源