Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright 1&1 Internet AG, http://www.1and1.org
   *
   * This program is free software; you can redistribute it and/or modify
   * it under the terms of the GNU Lesser General Public License as published by
   * the Free Software Foundation; either version 2 of the License,
   * or (at your option) any later version.
   *
   * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  * See the GNU Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 package net.sf.beezle.sushi.util;
 
 
 public class Strings {
     //
     //-- one string
     //
 
     public static String toHex(byte ... bytes) {
         StringBuilder result;
 
         result = new StringBuilder();
         toHex(resultbytes);
         return result.toString();
     }
 
     public static void toHex(StringBuilder resultbyte ... bytes) {
         for (byte b : bytes) {
             result.append(Integer.toString(b >> 4 & 0xf, 16));
             result.append(Integer.toString(b & 0xf, 16));
         }
     }
 
     //--
     
     public static String removeLeft(String strString left) {
         String result;
 
         result = removeLeftOpt(strleft);
         if (result != str) {
             return result;
         } else {
             throw new IllegalArgumentException("'" + str + "' does not start with '" + left + "'");
         }
     }
 
     public static String removeLeftOpt(String strString left) {
         if (str.startsWith(left)) {
             return str.substring(left.length());
         } else {
             return str;
         }
     }
 
     public static String removeRight(String strString right) {
         String result;
 
         result = removeRightOpt(strright);
         if (result != str) {
             return result;
         } else {
             throw new IllegalArgumentException("'" + str + "' does not end with '" + right + "'");
         }
     }
 
     public static String removeRightOpt(String strString right) {
         if (str.endsWith(right)) {
             return str.substring(0, str.length() - right.length());
         } else {
             return str;
         }
     }
 
     //-- padding
 
     public static String padLeft(String strint count) {
         return padLeft(strcount' ');
     }
 
     public static String padLeft(String strint countchar ch) {
         for (count -= str.length(); count > 0; count--) {
             str = ch + str;
         }
         return str;
     }
 
     public static String padRight(String strint count) {
         return padRight(strcount' ');
     }
    public static String padRight(String strint countchar ch) {
        for (count -= str.length(); count > 0; count--) {
            str = str + ch;
        }
        return str;
    }
    //--
    public static String indent(String strString space) {
        StringBuilder builder;
        builder = new StringBuilder();
        for (String line : ..split(str)) {
            builder.append(space);
            builder.append(line);
        }
        return builder.toString();
    }
    //--
    public static String times(char chint count) {
        StringBuilder buffer;
        buffer = new StringBuilder();
        while (count-- > 0) {
            buffer.append(ch);
        }
        return buffer.toString();
    }
    public static String replace(String strString inString out) {
        StringBuilder buffer;
        int inLen;
        int idx;
        int prev;
        inLen = in.length();
        if (inLen == 0) {
            throw new IllegalArgumentException();
        }
        buffer = new StringBuilder();
        idx = str.indexOf(in);
        prev = 0;
        while (idx != -1) {
            buffer.append(str.substring(previdx));
            buffer.append(out);
            prev = idx + inLen;
            idx = str.indexOf(inprev);
        }
        buffer.append(str.substring(prev));
        return buffer.toString();
    }
    public static String getCommon(String leftString right) {
        int i;
        int max;
        max = Math.min(left.length(), right.length());
        for (i = 0; i < maxi++) {
            if (left.charAt(i) != right.charAt(i)) {
                break;
            }
        }
        return left.substring(0, i);
    }
    public static int count(String strString part) {
        int count;
        int idx;
        int len;
        len = part.length();
        idx = 0;
        for (count = 0; truecount++) {
            idx = str.indexOf(partidx);
            if (idx == -1) {
                return count;
            }
            idx += len;
        }
    }
    public static String block(String prefixString bodyint widthString suffix) {
        return block(prefixprefixbodywidthsuffixsuffix);
    }
    public static String block(String firstString prefixString bodyint widthString suffixString last) {
        String currentPrefix;
        StringBuilder buffer;
        int space;
        int word;
        int line;
        boolean empty;  // false if at least one word was added to the line
        buffer = new StringBuilder();
        word = skip(body, 0, true);
        currentPrefix = first;
        while (true) {
            buffer.append(currentPrefix);
            line = 0;
            empty = true;
            while (true) {
                space = skip(bodywordfalse);
                if (space == word) {
                    buffer.append(last);
                    return buffer.toString();
                }
                line += space - word;
                if (empty) {
                    empty = false;
                } else {
                    line++;
                    if (line > width) {
                        break;
                    }
                    buffer.append(' ');
                }
                buffer.append(body.substring(wordspace));
                word = skip(bodyspacetrue);
            }
            buffer.append(suffix);
            currentPrefix = prefix;
        }
    }
    public static int skip(String strint startboolean ws) {
        int i;
        int max;
        max = str.length();
        for (i = starti < maxi++) {
            if (Character.isWhitespace(str.charAt(i)) != ws) {
                break;
            }
        }
        return i;
    }
    public static String capitalize(String str) {
        if (str.length() == 0) {
            return str;
        }
        return Character.toUpperCase(str.charAt(0)) + str.substring(1);
    }
    public static String decapitalize(String str) {
        if (str.length() == 0) {
            return str;
        }
        return Character.toLowerCase(str.charAt(0)) + str.substring(1);
    }
    //-- string collections or arrays
    public static final String[] NONE = new String[] {};

    
Turns a list of Strings into an array.

Parameters:
coll collection of Strings
Returns:
never null
    public static String[] toArray(Collection<Stringcoll) {
        String[] ar;
        ar = new String[coll.size()];
        coll.toArray(ar);
        return ar;
    }
    public static ArrayList<StringtoList(String ... elements) {
        return new ArrayList<String>(Arrays.asList(elements));
    }
    public static String[] cons(String carString[] cdr) {
        String[] result;
        result = new String[1 + cdr.length];
        result[0] = car;
        System.arraycopy(cdr, 0, result, 1, cdr.length);
        return result;
    }
    public static String[] cdr(String[] args) {
        String[] result;
        if (args.length == 0) {
            throw new RuntimeException();
        }
        result = new String[args.length - 1];
        System.arraycopy(args, 1, result, 0, result.length);
        return result;
    }
    public static String[] append(String[] ...args) {
        String[] result;
        int length;
        int ofs;
        length = 0;
        for (String[] current : args) {
            length += current.length;
        }
        result = new String[length];
        ofs = 0;
        for (String[] current : args) {
            System.arraycopy(current, 0, resultofscurrent.length);
            ofs += current.length;
        }
        return result;
    }

    
escape Strings as in Java String literals
    public static String escape(String str) {
        int imax;
        StringBuilder result;
        char c;
        max = str.length();
        for (i = 0; i < maxi++) {
            if (str.charAt(i) < 32) {
                break;
            }
        }
        if (i == max) {
            return str;
        }
        result = new StringBuilder(max + 10);
        for (i = 0; i < maxi++) {
            c = str.charAt(i);
            switch (c) {
                case '\n':
                    result.append("\\n");
                    break;
                case '\r':
                    result.append("\\r");
                    break;
                case '\t':
                    result.append("\\t");
                    break;
                case '\\':
                    result.append("\\\\");
                    break;
                default:
                    if (c < 32) {
                        result.append("\\u").append(Strings.padLeft(Integer.toHexString(c), '0'));
                    } else {
                        result.append(c);
                    }
            }
        }
        return result.toString();
    }
New to GrepCode? Check out our FAQ X