strutil.java

自己编写的几个类

package com.zte.cdma.autotest.mulautotest.buildxml;
//package buildxml;

/**
 *<p>版权所有(C)2002，深圳市中兴通讯股份有限公司</p>
 *
 *<p>文件名称：StrUtil.java</p>
 *<p>文件标识：</p>
 *<p>内容摘要：</p>
 *<p>当前版本：//输入当前版本</p>
 *<p>作    者：鄢彪</p>
 *<p>完成日期：输入完成日期，例如：2002-10-11</p>
 *
 *<p>修改记录1：修改历史记录，包括修改日期、修改者及修改内容</p>
 *<pre>
 *	修改日期：
 *	版 本 号：
 *	修 改 人：
 *	修改内容：
 *</pre>
 */

public class StrUtil {
    private static StrUtil strHandler =  null;
    private StrUtil() {
    }

    public static StrUtil getStrInstance() {
        if(strHandler == null)
            strHandler = new StrUtil();
        return strHandler;
    }
    /**
     * 将java指定的特殊字符换成通常熟知的类型,如当为*时为通用匹配,当为?时为一个任何字符
     * @param filterStr String java中的rex(其中.?[{]}()^$@!+等都是其保留字符)
     * @return String 返回一个可以被正确解析的
     */
    public static String replaceRex(String filterStr) {
        String rltStr = filterStr;
        String[] metaChars = new String[] {
            ".", "[", "]", "{", "}", "^", "$", "|", "(", ")", "?", "+", "@"};
        rltStr = rltStr.replaceAll("\\\\", "\\\\\\\\");
        System.out.println("get rltStr is:" + rltStr);
        for (int i = 0; i < metaChars.length; i++) {
            rltStr = rltStr.replaceAll("\\" + metaChars[i],
                                       "\\\\\\" + metaChars[i]);
        }
        rltStr = rltStr.replaceAll("[*]", ".*");
        return rltStr;
    }

    /**
     * 替换字符串，如果其中存在java保留字符串，则需要替换为\Meta的方式
     * @param replaceStr String 替换字符串
     * @return String 如果存在保留字符串需要替换
     */
    public static String replaceReplace(String replaceStr) {
        String rltStr = replaceStr;
        String[] metaChars = new String[] {
            ".", "[", "]", "{", "}", "^", "$", "|", "(", ")", "?", "+", "@",
            "*"};
        rltStr = rltStr.replaceAll("\\\\", "\\\\\\\\");
        System.out.println("get rltStr is:" + rltStr);
        for (int i = 0; i < metaChars.length; i++) {
            rltStr = rltStr.replaceAll("\\" + metaChars[i],
                                       "\\\\\\" + metaChars[i]);
        }
        return rltStr;
    }

    /**
     * 替换某一个字符串中的字符
     * @param text String 需要被替换的字符串母体
     * @param filters String[] 存放匹配字符组,其中字符是"*"为通配,"?"为任何一个字符
     * @param replaceStrs String[] 需要替换的字符串组,对应匹配字符数组
     * @return String 替换后的字符串
     */
    public static String replaceStr(String text, String[] filters,
                                    String[] replaceStrs) {
        String replaceText = text;
        for (int i = 0; i < filters.length; i++) {
            if (filters[i] == null || filters[i].trim().equals("")) {
                continue;
            }
            if(filters == null || replaceStrs == null || filters.length != replaceStrs.length)
                return text;
            String replaceStr = replaceStrs[i] != null ? replaceStrs[i] : "";
            //将需要替换的字符中java的保留字符转换为通用字符
            String rexStr = replaceRex(filters[i]);
            replaceStr = replaceReplace(replaceStr);
            replaceText = replaceText.replaceAll(rexStr, replaceStr);
        }
        return replaceText;
    }

    /**
     * 替换某一个字符串中的字符
     * @param text String 需要被替换的字符串母体
     * @param filters String[] 存放匹配字符组,其中字符是"*"为通配,"?"为任何一个字符
     * @param replaceStrs String[] 需要替换的字符串组,对应匹配字符数组
     * @return String 替换后的字符串
     */
    public static String replaceStr(String text, String filter,
                                    String replaceStr) {
        if(text == null || text.trim().equals(""))
            return text;
        String replaceText = text;
        String temp_replaceStr = replaceStr != null ? replaceStr : "";
        //将需要替换的字符中java的保留字符转换为通用字符
        String rexStr = replaceRex(filter);
//        System.out.println("get rexStr is:" + rexStr);
        temp_replaceStr = replaceReplace(temp_replaceStr);
        replaceText = replaceText.replaceAll(rexStr, temp_replaceStr);
        return replaceText;
    }

    /**
     * 字符串比较函数
     * @param originalStr 被比较的字符串
     * @param desc 要求匹配的字符串
     * 如 isInStr("test string","*st??tring") = true;在字符串中不能有":"存在
     * @return
     */
    public static boolean isMatchStr(String originalStr, String desc) {
        boolean isBelong = true;
        if ( (originalStr == null && desc != null)) {
            return false;
        }
        else if (desc == null || (originalStr.trim().equals(desc.trim()))) {
            return true;
        }
        String source = originalStr;
        String oldStr = new String(desc);
        //把通配符之间的字符串取出来,分别进行比较
        String[] wildcards = oldStr.split("\\*", -1);
        int wildcardNum = wildcards.length;
        boolean canStep = false;
        for (int i = 0; i < wildcardNum; i++) {
            //如果存在多余的通配符,则返回到下一个
            if (wildcards[i] == null || wildcards[i].equals("")) {
                continue;
            }
            //经过了一次通配符"*"的标志.
            if (i > 0) {
                canStep = true;
                //把通配符"*"之间的单个字符串取出来,并把其中的通配符"?"替换为":"
//            wildcards[i] = wildcards[i].replace('?', ':');
                //把"?"之间的字符串分开为单个的字符串,依次进行比较.
            }
            String[] sglWildcards = wildcards[i].split("\\?", -1);
            int sglWildcardNum = sglWildcards.length;
            for (int j = 0; j < sglWildcardNum; j++) {
//                System.out.println("get sglwildcards is" + sglWildcards[j]);
                if (sglWildcards[j].equals("")) {
                    if ( (j < sglWildcardNum - 1) && source != null) {
                        source = source.substring(1, source.length());
                    }
                    continue;
                }
                //假如source已经被匹配完,但是要匹配的字符串还没有结束,则说明此匹配未成功
                if (source == null) {
                    return false;
                }
                //如果存在通配符并且当前的字符串匹配成功,如果不存在通配符且当前字符串是要匹配的字符串开头
                if ( (canStep && source.indexOf(sglWildcards[j]) >= 0) ||
                    (!canStep && source.indexOf(sglWildcards[j]) == 0)) {
                    int startPos = source.indexOf(sglWildcards[j]) +
                        sglWildcards[j].length();
                    if ( (j < sglWildcardNum - 1) && source != null) {
                        startPos += 1;
                        //如果已经到达source的末尾则把source置为null;
                    }
                    if (startPos >= source.length()) {
                        source = null;
                    }
                    else {

                        //取出这段字符串的位置,把source后面的字符串重新赋给source
                        source = source.substring(startPos);
                    }
                    canStep = false;
                }
                else {
                    return false;
                }
            }
            //如果匹配的字符已经完结,而被匹配的串还有则返回空.
            if (source != null && i + 1 >= wildcards.length) {
                return false;
            }
        }
        originalStr = oldStr;
        return isBelong;
    }

    /**
     * 对作为路径的字符串作预处理，去掉其首尾的/和\
     * @param path String
     * @return String
     */
    public static String processPath(String path) {
      if (path == null || path.trim().equals("")) {
        return null;
      }
      path = path.trim();
      while (path.endsWith("/") || path.endsWith("\\")) {
        path = path.substring(0, path.length() - 1);
      }
      while (path.startsWith("/") || path.startsWith("\\")) {
        path = path.substring(1, path.length());
      }
      return path;
    }


//    public static
    public static void main(String[] args) {
//        System.out.println("replaceStr is:" + replaceStr("ffea\\\\10dfe;","\\\\*;","$1034*"));
//        try {
//            ReadWriteFile file =  new ReadWriteFile("D:\\ZXCOMC2.5_4-27\\ums\\ums-svr\\platform\\uep-system.properties");
//            String content = file.readFileContent();
//            String[] lines = content.split("\n");
//            for (int i = 0; i < lines.length; i++) {
//                System.out.println("lines["+i+"]=" + lines[i]);
//            }
//        }
//        catch (Exception ex) {
//
//        }
        System.out.println(StrUtil.isMatchStr("com.zte.ums.install.gui.frame.WelcomeFrame","com.zte.ums.install.gui.frame.WelcomeFrame"));
    }
}