Java封装简体繁体(香港&台湾)转换工具

阳光穿透心脏的1/2处 2022-12-01 15:43 180阅读 0赞

> **简体繁体转换**

##### 新建工具类:HKTWwordVO #####

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 漫路h * Created by 2020-08-24 18:52 */
    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文件地址–百度网盘 #####

链接：https://pan.baidu.com/s/1eBzorApG77pJzGSknfxo8w 
    提取码：g9nr