stringutility.java

采用JAVA开发

/**
 * $RCSfile: StringUtility.java,v $
 * $Revision: 1.3 $
 * $Date: 2004/01/17 14:23:26 $
 *
 * Copyright (C) 2003 ICSS, Inc. All rights reserved.
 *
 * This software is the proprietary information of ICSS, Inc.
 * Use is subject to license terms.
 */
package com.gctech.misc.util;

import java.util.ArrayList;
import java.util.StringTokenizer;
import java.util.Vector;

/**
 * <p>Title: OA系统</p>
 * <p>Description: 字符串操作常用的方法</p>
 * <p>Copyright: Copyright (c) 2002-12-5</p>
 * <p>Company: 中软远东国际</p>
 *
 * @version 1.0
 * @author Andy
 */
public class StringUtility {

    /**
     * 如果是null字符串, 则返回""字符串
     *
     * @param str String
     * @return String
     */
    public static String filterNull(String str) {
        if (str == null) {
            return new String();
        }
        else {
            return str;
        }
    }

    /**
     * 如果是null对象, 则返回""字符串
     *
     * @param obj Object
     * @return String
     */
    public static String filterNullObject(Object obj) {
        if (obj == null) {
            return new String();
        }
        else {
            return obj.toString();
        }
    }

    /**
     * 将字符串str中出现的oldStr字符串替换为newStr字符串
     *
     * @param str 要进行替换操作的字符串
     * @param oldStr 原字符串
     * @param newStr 替换字符串
     * @return 替换以后的字符串
     */
    public static String replace(String str, String oldStr, String newStr) {
        String string = str;
        StringBuffer buf = new StringBuffer();
        int index = 0;
        int idx = string.indexOf(oldStr);
        if (idx == -1)
            buf.append(string);
        while (idx != -1) {
            buf.append(string.substring(index, idx)).append(newStr);
            index = idx + oldStr.length();
            idx = string.indexOf(oldStr, index);
            if (idx == -1)
                buf.append(string.substring(index, string.length()));
        }

        return buf.toString();
    }

    /**
     * 过滤字符串中的非法字符
     *
     * @param in
     * @return String
     */
    public static String escapeHTMLTags(String in) {
        if (in == null || in.length() <= 0) {
            return "";
        }
        // 注意，可以向_temp1末尾添加转义字符，同时也要向_temp2末尾添加替换字符串，并且要以"|"分隔
        // 对于ASCII码大于127的字符，在添加到_temp中时需要以escape方式表示，如：\u00FF表示ASCII码为255的字符
        String _temp1 = "\u0026\u00A9\u00AE\u2122\"\u003C\u003E";
        String _temp2 = "&amp;|&copy;|&reg;|&trade;|&quot;|&lt;|&gt;";

        // Init vars.
        StringBuffer ret = new StringBuffer();
        String _new = "";

        // 先将in中含有的转义后的字符串转换成一般的转义前字符，这样就会正确转换一般字符，
        // 但是会将用户输入的包含在_temp2中的转义后的字符理解成相应的原字符，
        // 比如，用户输入" "，会转换成"&nbsp;"输出，但是用户输入"&nbsp;"就会被认为是" ".
        int i;
        StringTokenizer st1 = new StringTokenizer(_temp2, "|");
        ArrayList escapeArray = new ArrayList();
        while (st1.hasMoreTokens()) {
            String strToken = st1.nextToken();
            escapeArray.add(strToken);
        }
        /*
        for (i = 0; st1.hasMoreTokens(); i++) {
          in = replace(in, st1.nextToken(), _temp1.substring(i, i + 1));
        }
        */
        // 进行字符转义
        int _length = in.length();
        for (i = 0; i < _length; i++) {
            char t_char = in.charAt(i);
            int _index = _temp1.indexOf(t_char);
            if (_index < 0) {
                // 不存在待转义字符
                ret.append(t_char);
            }
            else {
                // 存在待转义字符，到_temp2中去查找相应的替换字符串
                _new = (String)escapeArray.get(_index);
                ret.append(_new);
            }
        }
        return ret.toString();
    }

    public static String filterHtml(Object oIn) {
        //如果是空对象，返回空字符串
        if (oIn == null) {
            return "";
        }
        String strIn = oIn.toString();
        return escapeHTMLTags(strIn);
    }
    /**
     * 加密 解密
     *
     * @param toBeProcessed String
     * @param mode 0 - 加密；其它 - 解密
     * @return String
     */
    public static String encrypt(String toBeProcessed, int mode) {
        String ret = new String();
        // 如果是空直接返回
        if (toBeProcessed == null || toBeProcessed.length() <= 0) {
            return ret;
        }
        // 处理
        int len = toBeProcessed.length();
        int i, j, k, l;
        if (mode == 0) { // 加密
            j = (int) (16 * Math.random() - 16);
            for (i = 1; i <= len; i++) {
                k = j + i % 4;
                ret = String.valueOf((char) (toBeProcessed.charAt(i - 1) + k)) + ret;
            }
            ret += String.valueOf((char) (j + 70));
        }
        else { // 解密
            l = len - 1;
            j = toBeProcessed.charAt(len - 1) - 70;
            for (i = 1; i <= l; i++) {
                k = j + i % 4;
                ret += String.valueOf((char) (toBeProcessed.charAt(l - i) - k));
            }
        }
        return ret;
    }

    /**
     * 处理字符串中的单引号
     * 一个单引号变为两个单引号
     * Liang Yong, Feb 28, 2003
     *
     * @return java.lang.String
     * @param oldValue java.lang.String
     */
    public static String processSingleQuote(String oldValue) {
        // Process single quotes
        String newValue = new String();
        if (oldValue != null) {
            char c;
            for (int i = 0; i < oldValue.length(); i++) {
                c = oldValue.charAt(i);
                if (c == '\'') {
                    newValue += c;
                }
                newValue += c;
            }
        }
        return newValue;
    }

    // 需要处理的特殊js字符，以免输出到html页面时出现js错误
    // 注意，“\\”必须放在最前端，因为要处理后面的特殊字符时还要用到它
    private final static String[] jsSpecialChars = { "\\", "\'", "\"" };

    /**
     * 对输出到js中的特殊字符进行转义处理
     * 如，将\'转换成\\\'
     *
     * @param in
     * @return
     */
    public static String escapeJSSpecialChar(String in) {
        String ret = new String();
        if (in == null || in.length() <= 0) {
            return ret;
        }

        // 把in中的js specail char全部加上\
        ret = in;
        for (int i = 0; i < jsSpecialChars.length; i++) {
            ret = replace(ret, jsSpecialChars[i], "\\" + jsSpecialChars[i]);
        }
        return ret;
    }

    // 单位字符，
    public static final char[] ascchars =
        {
            'a',
            'b',
            'c',
            'd',
            'e',
            'f',
            'g',
            'h',
            'i',
            'j',
            'k',
            'l',
            'm',
            'n',
            'o',
            'p',
            'q',
            'r',
            's',
            't',
            'u',
            'v',
            'w',
            'x',
            'y',
            'z',
            'A',
            'B',
            'C',
            'D',
            'E',
            'F',
            'G',
            'H',
            'I',
            'J',
            'K',
            'L',
            'M',
            'N',
            'O',
            'P',
            'Q',
            'R',
            'S',
            'T',
            'U',
            'V',
            'W',
            'X',
            'Y',
            'Z',
            '1',
            '2',
            '3',
            '4',
            '5',
            '6',
            '7',
            '8',
            '9',