zoukankan      html  css  js  c++  java
  • Liferay7 BPM门户开发之30: 通用帮助类Validator、ArrayUtil、StringUtil等使用

    废话不多说,直接上代码。

    验证类Validator


    主要是空验证、数字、格式验证

    调用的例子:

    protected void validateEmailFrom(ActionRequest actionRequest){
    
        String emailFromName = getParameter(actionRequest, "emailFromName");
        String emailFromAddress = getParameter(
            actionRequest, "emailFromAddress");
    
        if (Validator.isNull(emailFromName)) {
            SessionErrors.add(actionRequest, "emailFromName");
        }
        else if (!Validator.isEmailAddress(emailFromAddress) &&
                 !Validator.isVariableTerm(emailFromAddress)) {
    
            SessionErrors.add(actionRequest, "emailFromAddress");
        }
    }

    数组工具类,ArrayUtil


    主要的操作是:

    源代码实现分析1、去除重复值,如

        public static String[] distinct(String[] array) {
             return distinct(array, null);
         }
     
         public static String[] distinct(
             String[] array, Comparator<String> comparator) {
     
             if ((array == null) || (array.length == 0)) {
                 return array;
             }
     
             Set<String> set = null;
     
             if (comparator == null) {
                 set = new TreeSet<String>();
             }
             else {
                 set = new TreeSet<String>(comparator);
             }
     
             for (int i = 0; i < array.length; i++) {
                 String s = array[i];
     
                 if (!set.contains(s)) {
                     set.add(s);
                 }
             }
     
             return set.toArray(new String[set.size()]);
         }
         


    源代码实现分析2、尾部增加项,比如:

    public static Float[] append(Float[] array, Float obj) {
      Float[] newArray = new Float[array.length + 1];
    
      System.arraycopy(array, 0, newArray, 0, array.length);
    
      newArray[newArray.length - 1] = obj;
    
      return newArray;
    }


    3、JSONArray、Object和Array转换,如:

    static String[]    toStringArray(JSONArray array) 
    
    static String[]    toStringArray(Object[] array)

    字符串工具StringUtil


    一个例子,用于字符替换,同时也使用了StringPool

    protected Map<String, String> getJSONValues(
        JSONArray data, String namespace, String id) {
    
        Map<String, String> values = new HashMap<String, String>(data.length());
    
        for (int i = 0; i < data.length(); i++) {
            JSONObject jsonObject = data.getJSONObject(i);
    
            String name = jsonObject.getString("name");
    
            name = StringUtil.replace(
                name, new String[] {namespace, id},
                new String[] {StringPool.BLANK, StringPool.BLANK});
    
            values.put(name, jsonObject.getString("value"));
        }
    
        return values;
    }

    StringUtil源代码,有兴趣可以研究

    package com.liferay.portal.kernel.util;
    
    import com.liferay.portal.kernel.log.Log;
    import com.liferay.portal.kernel.log.LogFactoryUtil;
    
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.InputStreamReader;
    import java.io.StringReader;
    
    import java.net.URL;
    
    import java.util.ArrayList;
    import java.util.Collection;
    import java.util.Enumeration;
    import java.util.List;
    import java.util.Map;
    import java.util.StringTokenizer;
    
    public class StringUtil {
    
        public static String add(String s, String add) {
            return add(s, add, StringPool.COMMA);
        }
    
        public static String add(String s, String add, String delimiter) {
            return add(s, add, delimiter, false);
        }
    
        public static String add(
            String s, String add, String delimiter, boolean allowDuplicates) {
    
            if ((add == null) || (delimiter == null)) {
                return null;
            }
    
            if (s == null) {
                s = StringPool.BLANK;
            }
    
            if (allowDuplicates || !contains(s, add, delimiter)) {
                StringBuilder sb = new StringBuilder();
    
                sb.append(s);
    
                if (Validator.isNull(s) || s.endsWith(delimiter)) {
                    sb.append(add);
                    sb.append(delimiter);
                }
                else {
                    sb.append(delimiter);
                    sb.append(add);
                    sb.append(delimiter);
                }
    
                s = sb.toString();
            }
    
            return s;
        }
    
        public static String bytesToHexString(byte[] bytes) {
            StringBuilder sb = new StringBuilder(bytes.length * 2);
    
            for (int i = 0; i < bytes.length; i++) {
                String hex = Integer.toHexString(
                    0x0100 + (bytes[i] & 0x00FF)).substring(1);
    
                if (hex.length() < 2) {
                    sb.append("0");
                }
    
                sb.append(hex);
            }
    
            return sb.toString();
        }
    
        public static boolean contains(String s, String text) {
            return contains(s, text, StringPool.COMMA);
        }
    
        public static boolean contains(String s, String text, String delimiter) {
            if ((s == null) || (text == null) || (delimiter == null)) {
                return false;
            }
    
            StringBuilder sb = null;
    
            if (!s.endsWith(delimiter)) {
                sb = new StringBuilder();
    
                sb.append(s);
                sb.append(delimiter);
    
                s = sb.toString();
            }
    
            sb = new StringBuilder();
    
            sb.append(delimiter);
            sb.append(text);
            sb.append(delimiter);
    
            String dtd = sb.toString();
    
            int pos = s.indexOf(dtd);
    
            if (pos == -1) {
                sb = new StringBuilder();
    
                sb.append(text);
                sb.append(delimiter);
    
                String td = sb.toString();
    
                if (s.startsWith(td)) {
                    return true;
                }
    
                return false;
            }
    
            return true;
        }
    
        public static int count(String s, String text) {
            if ((s == null) || (text == null)) {
                return 0;
            }
    
            int count = 0;
    
            int pos = s.indexOf(text);
    
            while (pos != -1) {
                pos = s.indexOf(text, pos + text.length());
    
                count++;
            }
    
            return count;
        }
    
        public static boolean endsWith(String s, char end) {
            return endsWith(s, (new Character(end)).toString());
        }
    
        public static boolean endsWith(String s, String end) {
            if ((s == null) || (end == null)) {
                return false;
            }
    
            if (end.length() > s.length()) {
                return false;
            }
    
            String temp = s.substring(s.length() - end.length(), s.length());
    
            if (temp.equalsIgnoreCase(end)) {
                return true;
            }
            else {
                return false;
            }
        }
    
        public static String extractChars(String s) {
            if (s == null) {
                return StringPool.BLANK;
            }
    
            StringBuilder sb = new StringBuilder();
    
            char[] c = s.toCharArray();
    
            for (int i = 0; i < c.length; i++) {
                if (Validator.isChar(c[i])) {
                    sb.append(c[i]);
                }
            }
    
            return sb.toString();
        }
    
        public static String extractDigits(String s) {
            if (s == null) {
                return StringPool.BLANK;
            }
    
            StringBuilder sb = new StringBuilder();
    
            char[] c = s.toCharArray();
    
            for (int i = 0; i < c.length; i++) {
                if (Validator.isDigit(c[i])) {
                    sb.append(c[i]);
                }
            }
    
            return sb.toString();
        }
    
        public static String extractFirst(String s, String delimiter) {
            if (s == null) {
                return null;
            }
            else {
                String[] array = split(s, delimiter);
    
                if (array.length > 0) {
                    return array[0];
                }
                else {
                    return null;
                }
            }
        }
    
        public static String extractLast(String s, String delimiter) {
            if (s == null) {
                return null;
            }
            else {
                String[] array = split(s, delimiter);
    
                if (array.length > 0) {
                    return array[array.length - 1];
                }
                else {
                    return null;
                }
            }
        }
    
        public static String highlight(String s, String keywords) {
            return highlight(s, keywords, "<span class="highlight">", "</span>");
        }
    
        public static String highlight(
            String s, String keywords, String highlight1, String highlight2) {
    
            if (s == null) {
                return null;
            }
    
            // The problem with using a regexp is that it searches the text in a
            // case insenstive manner but doens't replace the text in a case
            // insenstive manner. So the search results actually get messed up. The
            // best way is to actually parse the results.
    
            //return s.replaceAll(
            //  "(?i)" + keywords, highlight1 + keywords + highlight2);
    
            StringBuilder sb = new StringBuilder(StringPool.SPACE);
    
            StringTokenizer st = new StringTokenizer(s);
    
            while (st.hasMoreTokens()) {
                String token = st.nextToken();
    
                if (token.equalsIgnoreCase(keywords)) {
                    sb.append(highlight1);
                    sb.append(token);
                    sb.append(highlight2);
                }
                else {
                    sb.append(token);
                }
    
                if (st.hasMoreTokens()) {
                    sb.append(StringPool.SPACE);
                }
            }
    
            return sb.toString();
        }
    
        public static String lowerCase(String s) {
            if (s == null) {
                return null;
            }
            else {
                return s.toLowerCase();
            }
        }
    
        public static String merge(boolean[] array) {
            return merge(array, StringPool.COMMA);
        }
    
        public static String merge(boolean[] array, String delimiter) {
            if (array == null) {
                return null;
            }
    
            StringBuilder sb = new StringBuilder();
    
            for (int i = 0; i < array.length; i++) {
                sb.append(String.valueOf(array[i]).trim());
    
                if ((i + 1) != array.length) {
                    sb.append(delimiter);
                }
            }
    
            return sb.toString();
        }
    
        public static String merge(double[] array) {
            return merge(array, StringPool.COMMA);
        }
    
        public static String merge(double[] array, String delimiter) {
            if (array == null) {
                return null;
            }
    
            StringBuilder sb = new StringBuilder();
    
            for (int i = 0; i < array.length; i++) {
                sb.append(String.valueOf(array[i]).trim());
    
                if ((i + 1) != array.length) {
                    sb.append(delimiter);
                }
            }
    
            return sb.toString();
        }
    
        public static String merge(float[] array) {
            return merge(array, StringPool.COMMA);
        }
    
        public static String merge(float[] array, String delimiter) {
            if (array == null) {
                return null;
            }
    
            StringBuilder sb = new StringBuilder();
    
            for (int i = 0; i < array.length; i++) {
                sb.append(String.valueOf(array[i]).trim());
    
                if ((i + 1) != array.length) {
                    sb.append(delimiter);
                }
            }
    
            return sb.toString();
        }
    
        public static String merge(int[] array) {
            return merge(array, StringPool.COMMA);
        }
    
        public static String merge(int[] array, String delimiter) {
            if (array == null) {
                return null;
            }
    
            StringBuilder sb = new StringBuilder();
    
            for (int i = 0; i < array.length; i++) {
                sb.append(String.valueOf(array[i]).trim());
    
                if ((i + 1) != array.length) {
                    sb.append(delimiter);
                }
            }
    
            return sb.toString();
        }
    
        public static String merge(long[] array) {
            return merge(array, StringPool.COMMA);
        }
    
        public static String merge(long[] array, String delimiter) {
            if (array == null) {
                return null;
            }
    
            StringBuilder sb = new StringBuilder();
    
            for (int i = 0; i < array.length; i++) {
                sb.append(String.valueOf(array[i]).trim());
    
                if ((i + 1) != array.length) {
                    sb.append(delimiter);
                }
            }
    
            return sb.toString();
        }
    
        public static String merge(short[] array) {
            return merge(array, StringPool.COMMA);
        }
    
        public static String merge(short[] array, String delimiter) {
            if (array == null) {
                return null;
            }
    
            StringBuilder sb = new StringBuilder();
    
            for (int i = 0; i < array.length; i++) {
                sb.append(String.valueOf(array[i]).trim());
    
                if ((i + 1) != array.length) {
                    sb.append(delimiter);
                }
            }
    
            return sb.toString();
        }
    
        public static String merge(Collection<?> col) {
            return merge(col, StringPool.COMMA);
        }
    
        public static String merge(Collection<?> col, String delimiter) {
            return merge(col.toArray(new Object[col.size()]), delimiter);
        }
    
        public static String merge(Object[] array) {
            return merge(array, StringPool.COMMA);
        }
    
        public static String merge(Object[] array, String delimiter) {
            if (array == null) {
                return null;
            }
    
            StringBuilder sb = new StringBuilder();
    
            for (int i = 0; i < array.length; i++) {
                sb.append(String.valueOf(array[i]).trim());
    
                if ((i + 1) != array.length) {
                    sb.append(delimiter);
                }
            }
    
            return sb.toString();
        }
    
        public static String randomize(String s) {
            return Randomizer.getInstance().randomize(s);
        }
    
        public static String read(ClassLoader classLoader, String name)
            throws IOException {
    
            return read(classLoader, name, false);
        }
    
        public static String read(ClassLoader classLoader, String name, boolean all)
            throws IOException {
    
            if (all) {
                StringBuilder sb = new StringBuilder();
    
                Enumeration<URL> enu = classLoader.getResources(name);
    
                while (enu.hasMoreElements()) {
                    URL url = enu.nextElement();
    
                    InputStream is = url.openStream();
    
                    String s = read(is);
    
                    if (s != null) {
                        sb.append(s);
                        sb.append(StringPool.NEW_LINE);
                    }
    
                    is.close();
                }
    
                return sb.toString().trim();
            }
            else {
                InputStream is = classLoader.getResourceAsStream(name);
    
                String s = read(is);
    
                is.close();
    
                return s;
            }
        }
    
        public static String read(InputStream is) throws IOException {
            StringBuilder sb = new StringBuilder();
    
            BufferedReader br = new BufferedReader(new InputStreamReader(is));
    
            String line = null;
    
            while ((line = br.readLine()) != null) {
                sb.append(line).append('
    ');
            }
    
            br.close();
    
            return sb.toString().trim();
        }
    
        public static String remove(String s, String remove) {
            return remove(s, remove, StringPool.COMMA);
        }
    
        public static String remove(String s, String remove, String delimiter) {
            if ((s == null) || (remove == null) || (delimiter == null)) {
                return null;
            }
    
            if (Validator.isNotNull(s) && !s.endsWith(delimiter)) {
                s += delimiter;
            }
    
            StringBuilder sb = new StringBuilder();
    
            sb.append(delimiter);
            sb.append(remove);
            sb.append(delimiter);
    
            String drd = sb.toString();
    
            sb = new StringBuilder();
    
            sb.append(remove);
            sb.append(delimiter);
    
            String rd = sb.toString();
    
            while (contains(s, remove, delimiter)) {
                int pos = s.indexOf(drd);
    
                if (pos == -1) {
                    if (s.startsWith(rd)) {
                        int x = remove.length() + delimiter.length();
                        int y = s.length();
    
                        s = s.substring(x, y);
                    }
                }
                else {
                    int x = pos + remove.length() + delimiter.length();
                    int y = s.length();
    
                    sb = new StringBuilder();
    
                    sb.append(s.substring(0, pos));
                    sb.append(s.substring(x, y));
    
                    s =  sb.toString();
                }
            }
    
            return s;
        }
    
        public static String replace(String s, char oldSub, char newSub) {
            if (s == null) {
                return null;
            }
    
            return s.replace(oldSub, newSub);
        }
    
        public static String replace(String s, char oldSub, String newSub) {
            if ((s == null) || (newSub == null)) {
                return null;
            }
    
            // The number 5 is arbitrary and is used as extra padding to reduce
            // buffer expansion
    
            StringBuilder sb = new StringBuilder(s.length() + 5 * newSub.length());
    
            char[] charArray = s.toCharArray();
    
            for (char c : charArray) {
                if (c == oldSub) {
                    sb.append(newSub);
                }
                else {
                    sb.append(c);
                }
            }
    
            return sb.toString();
        }
    
        public static String replace(String s, String oldSub, String newSub) {
            if ((s == null) || (oldSub == null) || (newSub == null)) {
                return null;
            }
    
            int y = s.indexOf(oldSub);
    
            if (y >= 0) {
    
                // The number 5 is arbitrary and is used as extra padding to reduce
                // buffer expansion
    
                StringBuilder sb = new StringBuilder(
                    s.length() + 5 * newSub.length());
    
                int length = oldSub.length();
                int x = 0;
    
                while (x <= y) {
                    sb.append(s.substring(x, y));
                    sb.append(newSub);
    
                    x = y + length;
                    y = s.indexOf(oldSub, x);
                }
    
                sb.append(s.substring(x));
    
                return sb.toString();
            }
            else {
                return s;
            }
        }
    
        public static String replace(String s, String[] oldSubs, String[] newSubs) {
            if ((s == null) || (oldSubs == null) || (newSubs == null)) {
                return null;
            }
    
            if (oldSubs.length != newSubs.length) {
                return s;
            }
    
            for (int i = 0; i < oldSubs.length; i++) {
                s = replace(s, oldSubs[i], newSubs[i]);
            }
    
            return s;
        }
    
        public static String replace(
            String s, String[] oldSubs, String[] newSubs, boolean exactMatch) {
    
            if ((s == null) || (oldSubs == null) || (newSubs == null)) {
                return null;
            }
    
            if (oldSubs.length != newSubs.length) {
                return s;
            }
    
            if (!exactMatch) {
                replace(s, oldSubs, newSubs);
            }
            else {
                for (int i = 0; i < oldSubs.length; i++) {
                    s = s.replaceAll("\b" + oldSubs[i] + "\b" , newSubs[i]);
                }
            }
    
            return s;
        }
    
        /**
         * Returns a string with replaced values. This method will replace all text
         * in the given string, between the beginning and ending delimiter, with new
         * values found in the given map. For example, if the string contained the
         * text <code>[$HELLO$]</code>, and the beginning delimiter was
         * <code>[$]</code>, and the ending delimiter was <code>$]</code>, and the
         * values map had a key of <code>HELLO</code> that mapped to
         * <code>WORLD</code>, then the replaced string will contain the text
         * <code>[$WORLD$]</code>.
         *
         * @param       s the original string
         * @param       begin the beginning delimiter
         * @param       end the ending delimiter
         * @param       values a map of old and new values
         * @return      a string with replaced values
         */
        public static String replaceValues(
            String s, String begin, String end, Map<String, String> values) {
    
            if ((s == null) || (begin == null) || (end == null) ||
                (values == null) || (values.size() == 0)) {
    
                return s;
            }
    
            StringBuilder sb = new StringBuilder(s.length());
    
            int pos = 0;
    
            while (true) {
                int x = s.indexOf(begin, pos);
                int y = s.indexOf(end, x + begin.length());
    
                if ((x == -1) || (y == -1)) {
                    sb.append(s.substring(pos, s.length()));
    
                    break;
                }
                else {
                    sb.append(s.substring(pos, x + begin.length()));
    
                    String oldValue = s.substring(x + begin.length(), y);
    
                    String newValue = values.get(oldValue);
    
                    if (newValue == null) {
                        newValue = oldValue;
                    }
    
                    sb.append(newValue);
    
                    pos = y;
                }
            }
    
            return sb.toString();
        }
    
        public static String reverse(String s) {
            if (s == null) {
                return null;
            }
    
            char[] c = s.toCharArray();
            char[] reverse = new char[c.length];
    
            for (int i = 0; i < c.length; i++) {
                reverse[i] = c[c.length - i - 1];
            }
    
            return new String(reverse);
        }
    
        public static String safePath(String path) {
            return replace(path, StringPool.DOUBLE_SLASH, StringPool.SLASH);
        }
    
        public static String shorten(String s) {
            return shorten(s, 20);
        }
    
        public static String shorten(String s, int length) {
            return shorten(s, length, "...");
        }
    
        public static String shorten(String s, String suffix) {
            return shorten(s, 20, suffix);
        }
    
        public static String shorten(String s, int length, String suffix) {
            if ((s == null) || (suffix == null)) {
                return null;
            }
    
            if (s.length() > length) {
                for (int j = length; j >= 0; j--) {
                    if (Character.isWhitespace(s.charAt(j))) {
                        length = j;
    
                        break;
                    }
                }
    
                StringBuilder sb = new StringBuilder();
    
                sb.append(s.substring(0, length));
                sb.append(suffix);
    
                s =  sb.toString();
            }
    
            return s;
        }
    
        public static String[] split(String s) {
            return split(s, StringPool.COMMA);
        }
    
        public static String[] split(String s, String delimiter) {
            if (s == null || delimiter == null) {
                return new String[0];
            }
    
            s = s.trim();
    
            if (!s.endsWith(delimiter)) {
                StringBuilder sb = new StringBuilder();
    
                sb.append(s);
                sb.append(delimiter);
    
                s = sb.toString();
            }
    
            if (s.equals(delimiter)) {
                return new String[0];
            }
    
            List<String> nodeValues = new ArrayList<String>();
    
            if (delimiter.equals("
    ") || delimiter.equals("
    ")) {
                try {
                    BufferedReader br = new BufferedReader(new StringReader(s));
    
                    String line = null;
    
                    while ((line = br.readLine()) != null) {
                        nodeValues.add(line);
                    }
    
                    br.close();
                }
                catch (IOException ioe) {
                    _log.error(ioe.getMessage());
                }
            }
            else {
                int offset = 0;
                int pos = s.indexOf(delimiter, offset);
    
                while (pos != -1) {
                    nodeValues.add(new String(s.substring(offset, pos)));
    
                    offset = pos + delimiter.length();
                    pos = s.indexOf(delimiter, offset);
                }
            }
    
            return nodeValues.toArray(new String[nodeValues.size()]);
        }
    
        public static boolean[] split(String s, boolean x) {
            return split(s, StringPool.COMMA, x);
        }
    
        public static boolean[] split(String s, String delimiter, boolean x) {
            String[] array = split(s, delimiter);
            boolean[] newArray = new boolean[array.length];
    
            for (int i = 0; i < array.length; i++) {
                boolean value = x;
    
                try {
                    value = Boolean.valueOf(array[i]).booleanValue();
                }
                catch (Exception e) {
                }
    
                newArray[i] = value;
            }
    
            return newArray;
        }
    
        public static double[] split(String s, double x) {
            return split(s, StringPool.COMMA, x);
        }
    
        public static double[] split(String s, String delimiter, double x) {
            String[] array = split(s, delimiter);
            double[] newArray = new double[array.length];
    
            for (int i = 0; i < array.length; i++) {
                double value = x;
    
                try {
                    value = Double.parseDouble(array[i]);
                }
                catch (Exception e) {
                }
    
                newArray[i] = value;
            }
    
            return newArray;
        }
    
        public static float[] split(String s, float x) {
            return split(s, StringPool.COMMA, x);
        }
    
        public static float[] split(String s, String delimiter, float x) {
            String[] array = split(s, delimiter);
            float[] newArray = new float[array.length];
    
            for (int i = 0; i < array.length; i++) {
                float value = x;
    
                try {
                    value = Float.parseFloat(array[i]);
                }
                catch (Exception e) {
                }
    
                newArray[i] = value;
            }
    
            return newArray;
        }
    
        public static int[] split(String s, int x) {
            return split(s, StringPool.COMMA, x);
        }
    
        public static int[] split(String s, String delimiter, int x) {
            String[] array = split(s, delimiter);
            int[] newArray = new int[array.length];
    
            for (int i = 0; i < array.length; i++) {
                int value = x;
    
                try {
                    value = Integer.parseInt(array[i]);
                }
                catch (Exception e) {
                }
    
                newArray[i] = value;
            }
    
            return newArray;
        }
    
        public static long[] split(String s, long x) {
            return split(s, StringPool.COMMA, x);
        }
    
        public static long[] split(String s, String delimiter, long x) {
            String[] array = split(s, delimiter);
            long[] newArray = new long[array.length];
    
            for (int i = 0; i < array.length; i++) {
                long value = x;
    
                try {
                    value = Long.parseLong(array[i]);
                }
                catch (Exception e) {
                }
    
                newArray[i] = value;
            }
    
            return newArray;
        }
    
        public static short[] split(String s, short x) {
            return split(s, StringPool.COMMA, x);
        }
    
        public static short[] split(String s, String delimiter, short x) {
            String[] array = split(s, delimiter);
            short[] newArray = new short[array.length];
    
            for (int i = 0; i < array.length; i++) {
                short value = x;
    
                try {
                    value = Short.parseShort(array[i]);
                }
                catch (Exception e) {
                }
    
                newArray[i] = value;
            }
    
            return newArray;
        }
    
        public static boolean startsWith(String s, char begin) {
            return startsWith(s, (new Character(begin)).toString());
        }
    
        public static boolean startsWith(String s, String start) {
            if ((s == null) || (start == null)) {
                return false;
            }
    
            if (start.length() > s.length()) {
                return false;
            }
    
            String temp = s.substring(0, start.length());
    
            if (temp.equalsIgnoreCase(start)) {
                return true;
            }
            else {
                return false;
            }
        }
    
        /**
         * Return the number of starting letters that s1 and s2 have in common
         * before they deviate.
         *
         * @param       s1 the first string
         * @param       s2 the second string
         *
         * @return      the number of starting letters that s1 and s2 have in common
         *              before they deviate
         */
        public static int startsWithWeight(String s1, String s2) {
            if ((s1 == null) || (s2 == null)) {
                return 0;
            }
    
            char[] charArray1 = s1.toCharArray();
            char[] charArray2 = s2.toCharArray();
    
            int i = 0;
    
            for (; (i < charArray1.length) && (i < charArray2.length); i++) {
                if (charArray1[i] != charArray2[i]) {
                    break;
                }
            }
    
            return i;
        }
    
        public static String stripBetween(String s, String begin, String end) {
            if ((s == null) || (begin == null) || (end == null)) {
                return s;
            }
    
            StringBuilder sb = new StringBuilder(s.length());
    
            int pos = 0;
    
            while (true) {
                int x = s.indexOf(begin, pos);
                int y = s.indexOf(end, x + begin.length());
    
                if ((x == -1) || (y == -1)) {
                    sb.append(s.substring(pos, s.length()));
    
                    break;
                }
                else {
                    sb.append(s.substring(pos, x));
    
                    pos = y + end.length();
                }
            }
    
            return sb.toString();
        }
    
        public static String trim(String s) {
            return trim(s, null);
        }
    
        public static String trim(String s, char c) {
            return trim(s, new char[] {c});
        }
    
        public static String trim(String s, char[] exceptions) {
            if (s == null) {
                return null;
            }
    
            char[] charArray = s.toCharArray();
    
            int len = charArray.length;
    
            int x = 0;
            int y = charArray.length;
    
            for (int i = 0; i < len; i++) {
                char c = charArray[i];
    
                if (_isTrimable(c, exceptions)) {
                    x = i + 1;
                }
                else {
                    break;
                }
            }
    
            for (int i = len - 1; i >= 0; i--) {
                char c = charArray[i];
    
                if (_isTrimable(c, exceptions)) {
                    y = i;
                }
                else {
                    break;
                }
            }
    
            if ((x != 0) || (y != len)) {
                return s.substring(x, y);
            }
            else {
                return s;
            }
        }
    
        public static String trimLeading(String s) {
            return trimLeading(s, null);
        }
    
        public static String trimLeading(String s, char c) {
            return trimLeading(s, new char[] {c});
        }
    
        public static String trimLeading(String s, char[] exceptions) {
            if (s == null) {
                return null;
            }
    
            char[] charArray = s.toCharArray();
    
            int len = charArray.length;
    
            int x = 0;
            int y = charArray.length;
    
            for (int i = 0; i < len; i++) {
                char c = charArray[i];
    
                if (_isTrimable(c, exceptions)) {
                    x = i + 1;
                }
                else {
                    break;
                }
            }
    
            if ((x != 0) || (y != len)) {
                return s.substring(x, y);
            }
            else {
                return s;
            }
        }
    
        public static String trimTrailing(String s) {
            return trimTrailing(s, null);
        }
    
        public static String trimTrailing(String s, char c) {
            return trimTrailing(s, new char[] {c});
        }
    
        public static String trimTrailing(String s, char[] exceptions) {
            if (s == null) {
                return null;
            }
    
            char[] charArray = s.toCharArray();
    
            int len = charArray.length;
    
            int x = 0;
            int y = charArray.length;
    
            for (int i = len - 1; i >= 0; i--) {
                char c = charArray[i];
    
                if (_isTrimable(c, exceptions)) {
                    y = i;
                }
                else {
                    break;
                }
            }
    
            if ((x != 0) || (y != len)) {
                return s.substring(x, y);
            }
            else {
                return s;
            }
        }
    
        public static String upperCase(String s) {
            if (s == null) {
                return null;
            }
            else {
                return s.toUpperCase();
            }
        }
    
        public static String upperCaseFirstLetter(String s) {
            char[] chars = s.toCharArray();
    
            if ((chars[0] >= 97) && (chars[0] <= 122)) {
                chars[0] = (char)(chars[0] - 32);
            }
    
            return new String(chars);
        }
    
        public static String wrap(String text) {
            return wrap(text, 80, StringPool.NEW_LINE);
        }
    
        public static String wrap(String text, int width, String lineSeparator) {
            if (text == null) {
                return null;
            }
    
            StringBuilder sb = new StringBuilder();
    
            try {
                BufferedReader br = new BufferedReader(new StringReader(text));
    
                String s = StringPool.BLANK;
    
                while ((s = br.readLine()) != null) {
                    if (s.length() == 0) {
                        sb.append(lineSeparator);
                    }
                    else {
                        String[] tokens = s.split(StringPool.SPACE);
                        boolean firstWord = true;
                        int curLineLength = 0;
    
                        for (int i = 0; i < tokens.length; i++) {
                            if (!firstWord) {
                                sb.append(StringPool.SPACE);
                                curLineLength++;
                            }
    
                            if (firstWord) {
                                sb.append(lineSeparator);
                            }
    
                            sb.append(tokens[i]);
    
                            curLineLength += tokens[i].length();
    
                            if (curLineLength >= width) {
                                firstWord = true;
                                curLineLength = 0;
                            }
                            else {
                                firstWord = false;
                            }
                        }
                    }
                }
            }
            catch (IOException ioe) {
                _log.error(ioe.getMessage());
            }
    
            return sb.toString();
        }
    
        private static boolean _isTrimable(char c, char[] exceptions) {
            if ((exceptions != null) && (exceptions.length > 0)) {
                for (int i = 0; i < exceptions.length; i++) {
                    if (c == exceptions[i]) {
                        return false;
                    }
                }
            }
    
            return Character.isWhitespace(c);
        }
    
        private static Log _log = LogFactoryUtil.getLog(StringUtil.class);
    
    }
    View Code

    其他工具类

     

    • 集合的泛型帮助类:MapUtil、ListUtil
    • Base64的转换:Base64
    • http参数帮助,编解码工具:HttpUtil
    • 文件操作:FileUtil
    • 类型工具:ClassUtil:
    • 常用字符串静态类:StringPool

    其中StringPool定义了一些final值,可以利用起来:

    package com.liferay.portal.kernel.util;
    
    public class StringPool {
    
    public static final String AMPERSAND = "&";
    
    public static final String AMPERSAND_ENCODED = "&amp;";
    
    public static final String APOSTROPHE = "'";
    
    public static final String AT = "@";
    
    public static final String BACK_SLASH = "\";
    
    public static final String BETWEEN = "BETWEEN";
    
    public static final String BLANK = "";
    
    public static final String CDATA_OPEN = "<![CDATA[";
    
    public static final String CDATA_CLOSE = "]]>";
    
    public static final String CLOSE_BRACKET = "]";
    
    public static final String CLOSE_CURLY_BRACE = "}";
    
    public static final String CLOSE_PARENTHESIS = ")";
    
    public static final String COLON = ":";
    
    public static final String COMMA = ",";
    
    public static final String COMMA_AND_SPACE = ", ";
    
    public static final String DASH = "-";
    
    public static final String DOUBLE_APOSTROPHE = "''";
    
    public static final String DOUBLE_CLOSE_BRACKET = "]]";
    
    public static final String DOUBLE_OPEN_BRACKET = "[[";
    
    public static final String DOUBLE_SLASH = "//";
    
    public static final String EQUAL = "=";
    
    public static final String GREATER_THAN = ">";
    
    public static final String GREATER_THAN_OR_EQUAL = ">=";
    
    public static final String FALSE = "false";
    
    public static final String FORWARD_SLASH = "/";
    
    public static final String FOUR_SPACES = " ";
    
    public static final String IS_NOT_NULL = "IS NOT NULL";
    
    public static final String IS_NULL = "IS NULL";
    
    public static final String LESS_THAN = "<";
    
    public static final String LESS_THAN_OR_EQUAL = "<=";
    
    public static final String LIKE = "LIKE";
    
    public static final String MINUS = "-";
    
    public static final String NBSP = "&nbsp;";
    
    public static final String NEW_LINE = "
    ";
    
    public static final String NOT_EQUAL = "!=";
    
    public static final String NOT_LIKE = "NOT LIKE";
    
    public static final String NULL = "null";
    
    public static final String OPEN_BRACKET = "[";
    
    public static final String OPEN_CURLY_BRACE = "{";
    
    public static final String OPEN_PARENTHESIS = "(";
    
    public static final String PERCENT = "%";
    
    public static final String PERIOD = ".";
    
    public static final String PIPE = "|";
    
    public static final String PLUS = "+";
    
    public static final String POUND = "#";
    
    public static final String QUESTION = "?";
    
    public static final String QUOTE = """;
    
    public static final String RETURN = "
    ";
    
    public static final String RETURN_NEW_LINE = "
    ";
    
    public static final String SEMICOLON = ";";
    
    public static final String SLASH = FORWARD_SLASH;
    
    public static final String SPACE = " ";
    
    public static final String STAR = "*";
    
    public static final String TILDE = "~";
    
    public static final String TRUE = "true";
    
    public static final String UNDERLINE = "_";
    
    public static final String UTF8 = "UTF-8";
    
    }
    View Code

     简单、优雅、有序才是真的美。

  • 相关阅读:
    fzuoj Problem 2177 ytaaa
    zoj The 12th Zhejiang Provincial Collegiate Programming Contest Capture the Flag
    zoj The 12th Zhejiang Provincial Collegiate Programming Contest Team Formation
    zoj The 12th Zhejiang Provincial Collegiate Programming Contest Beauty of Array
    zoj The 12th Zhejiang Provincial Collegiate Programming Contest Lunch Time
    zoj The 12th Zhejiang Provincial Collegiate Programming Contest Convert QWERTY to Dvorak
    zoj The 12th Zhejiang Provincial Collegiate Programming Contest May Day Holiday
    zoj The 12th Zhejiang Provincial Collegiate Programming Contest Demacia of the Ancients
    zjuoj The 12th Zhejiang Provincial Collegiate Programming Contest Ace of Aces
    csuoj 1335: 高桥和低桥
  • 原文地址:https://www.cnblogs.com/starcrm/p/6053958.html
Copyright © 2011-2022 走看看