StringUtils工具类

/*** Eclipse Class Decompiler plugin, copyright (c) 2012 Chao Chen (cnfree2000@hotmail.com) ***/
package org.apache.commons.lang;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;

public class StringUtils {

    public static final String EMPTY = "";
    public static final int INDEX_NOT_FOUND = -1;
    private static final int PAD_LIMIT = 8192;

    public static boolean isEmpty(String str) {
        return ( ( str==null )||( str.length()==0 ) );
    }

    public static boolean isNotEmpty(String str) {
        return ( !( isEmpty(str) ) );
    }

    public static boolean isBlank(String str) {
        int strLen;
        if(( str==null )||( ( strLen = str.length() )==0 )) return true;
        int strLen;
        for(int i = 0; i<strLen; ++i){
            if( !( Character.isWhitespace(str.charAt(i)) )){
                return false;
            }
        }
        return true;
    }

    public static boolean isNotBlank(String str) {
        return ( !( isBlank(str) ) );
    }

    /** @deprecated */
    public static String clean(String str) {
        return ( ( str==null ) ? "" : str.trim() );
    }

    public static String trim(String str) {
        return ( ( str==null ) ? null : str.trim() );
    }

    public static String trimToNull(String str) {
        String ts = trim(str);
        return ( ( isEmpty(ts) ) ? null : ts );
    }

    public static String trimToEmpty(String str) {
        return ( ( str==null ) ? "" : str.trim() );
    }

    public static String strip(String str) {
        return strip(str,null);
    }

    public static String stripToNull(String str) {
        if(str==null){
            return null;
        }
        str = strip(str,null);
        return ( ( str.length()==0 ) ? null : str );
    }

    public static String stripToEmpty(String str) {
        return ( ( str==null ) ? "" : strip(str,null) );
    }

    public static String strip(String str,String stripChars) {
        if(isEmpty(str)){
            return str;
        }
        str = stripStart(str,stripChars);
        return stripEnd(str,stripChars);
    }

    public static String stripStart(String str,String stripChars) {
        int strLen;
        if(( str==null )||( ( strLen = str.length() )==0 )) return str;
        int strLen;
        int start = 0;
        if(stripChars==null) while(true){
            if(( start==strLen )||( !( Character.isWhitespace(str.charAt(start)) ) )) break label76;
            ++start;
        }
        if(stripChars.length()==0){
            return str;
        }
        while(( start!=strLen )&&( stripChars.indexOf(str.charAt(start))!= -1 )){
            ++start;
        }

        label76: return str.substring(start);
    }

    public static String stripEnd(String str,String stripChars) {
        int end;
        if(( str==null )||( ( end = str.length() )==0 )) return str;
        int end;
        if(stripChars==null) while(true){
            if(( end==0 )||( !( Character.isWhitespace(str.charAt(end-1)) ) )) break label76;
            --end;
        }
        if(stripChars.length()==0){
            return str;
        }
        while(( end!=0 )&&( stripChars.indexOf(str.charAt(end-1))!= -1 )){
            --end;
        }

        label76: return str.substring(0,end);
    }

    public static String[] stripAll(String[] strs) {
        return stripAll(strs,null);
    }

    public static String[] stripAll(String[] strs,String stripChars) {
        int strsLen;
        if(( strs==null )||( ( strsLen = strs.length )==0 )) return strs;
        int strsLen;
        String[] newArr = new String[strsLen];
        for(int i = 0; i<strsLen; ++i){
            newArr[i] = strip(strs[i],stripChars);
        }
        return newArr;
    }

    public static boolean equals(String str1,String str2) {
        return ( ( str1==null ) ? false : ( str2==null ) ? true : str1.equals(str2) );
    }

    public static boolean equalsIgnoreCase(String str1,String str2) {
        return ( ( str1==null ) ? false : ( str2==null ) ? true : str1.equalsIgnoreCase(str2) );
    }

    public static int indexOf(String str,char searchChar) {
        if(isEmpty(str)){
            return -1;
        }
        return str.indexOf(searchChar);
    }

    public static int indexOf(String str,char searchChar,int startPos) {
        if(isEmpty(str)){
            return -1;
        }
        return str.indexOf(searchChar,startPos);
    }

    public static int indexOf(String str,String searchStr) {
        if(( str==null )||( searchStr==null )){
            return -1;
        }
        return str.indexOf(searchStr);
    }

    public static int ordinalIndexOf(String str,String searchStr,int ordinal) {
        return ordinalIndexOf(str,searchStr,ordinal,false);
    }

    private static int ordinalIndexOf(String str,String searchStr,int ordinal,boolean lastIndex) {
        if(( str==null )||( searchStr==null )||( ordinal<=0 )){
            return -1;
        }
        if(searchStr.length()==0){
            return ( ( lastIndex ) ? str.length() : 0 );
        }
        int found = 0;
        int index = ( lastIndex ) ? str.length() : -1;
        do{
            if(lastIndex)
                index = str.lastIndexOf(searchStr,index-1);
            else{
                index = str.indexOf(searchStr,index+1);
            }
            if(index<0){
                return index;
            }
            ++found;
        }while(found<ordinal);
        return index;
    }

    public static int indexOf(String str,String searchStr,int startPos) {
        if(( str==null )||( searchStr==null )){
            return -1;
        }

        if(( searchStr.length()==0 )&&( startPos>=str.length() )){
            return str.length();
        }
        return str.indexOf(searchStr,startPos);
    }

    public static int indexOfIgnoreCase(String str,String searchStr) {
        return indexOfIgnoreCase(str,searchStr,0);
    }

    public static int indexOfIgnoreCase(String str,String searchStr,int startPos) {
        if(( str==null )||( searchStr==null )){
            return -1;
        }
        if(startPos<0){
            startPos = 0;
        }
        int endLimit = str.length()-searchStr.length()+1;
        if(startPos>endLimit){
            return -1;
        }
        if(searchStr.length()==0){
            return startPos;
        }
        for(int i = startPos; i<endLimit; ++i){
            if(str.regionMatches(true,i,searchStr,0,searchStr.length())){
                return i;
            }
        }
        return -1;
    }

    public static int lastIndexOf(String str,char searchChar) {
        if(isEmpty(str)){
            return -1;
        }
        return str.lastIndexOf(searchChar);
    }

    public static int lastIndexOf(String str,char searchChar,int startPos) {
        if(isEmpty(str)){
            return -1;
        }
        return str.lastIndexOf(searchChar,startPos);
    }

    public static int lastIndexOf(String str,String searchStr) {
        if(( str==null )||( searchStr==null )){
            return -1;
        }
        return str.lastIndexOf(searchStr);
    }

    public static int lastOrdinalIndexOf(String str,String searchStr,int ordinal) {
        return ordinalIndexOf(str,searchStr,ordinal,true);
    }

    public static int lastIndexOf(String str,String searchStr,int startPos) {
        if(( str==null )||( searchStr==null )){
            return -1;
        }
        return str.lastIndexOf(searchStr,startPos);
    }

    public static int lastIndexOfIgnoreCase(String str,String searchStr) {
        if(( str==null )||( searchStr==null )){
            return -1;
        }
        return lastIndexOfIgnoreCase(str,searchStr,str.length());
    }

    public static int lastIndexOfIgnoreCase(String str,String searchStr,int startPos) {
        if(( str==null )||( searchStr==null )){
            return -1;
        }
        if(startPos>str.length()-searchStr.length()){
            startPos = str.length()-searchStr.length();
        }
        if(startPos<0){
            return -1;
        }
        if(searchStr.length()==0){
            return startPos;
        }

        for(int i = startPos; i>=0; --i){
            if(str.regionMatches(true,i,searchStr,0,searchStr.length())){
                return i;
            }
        }
        return -1;
    }

    public static boolean contains(String str,char searchChar) {
        if(isEmpty(str)){
            return false;
        }
        return ( str.indexOf(searchChar)>=0 );
    }

    public static boolean contains(String str,String searchStr) {
        if(( str==null )||( searchStr==null )){
            return false;
        }
        return ( str.indexOf(searchStr)>=0 );
    }

    public static boolean containsIgnoreCase(String str,String searchStr) {
        if(( str==null )||( searchStr==null )){
            return false;
        }
        int len = searchStr.length();
        int max = str.length()-len;
        for(int i = 0; i<=max; ++i){
            if(str.regionMatches(true,i,searchStr,0,len)){
                return true;
            }
        }
        return false;
    }

    public static int indexOfAny(String str,char[] searchChars) {
        if(( isEmpty(str) )||( ArrayUtils.isEmpty(searchChars) )){
            return -1;
        }
        for(int i = 0; i<str.length(); ++i){
            char ch = str.charAt(i);
            for(int j = 0; j<searchChars.length; ++j){
                if(searchChars[j]==ch){
                    return i;
                }
            }
        }
        return -1;
    }

    public static int indexOfAny(String str,String searchChars) {
        if(( isEmpty(str) )||( isEmpty(searchChars) )){
            return -1;
        }
        return indexOfAny(str,searchChars.toCharArray());
    }

    public static boolean containsAny(String str,char[] searchChars) {
        if(( str==null )||( str.length()==0 )||( searchChars==null )||( searchChars.length==0 )){
            return false;
        }
        for(int i = 0; i<str.length(); ++i){
            char ch = str.charAt(i);
            for(int j = 0; j<searchChars.length; ++j){
                if(searchChars[j]==ch){
                    return true;
                }
            }
        }
        return false;
    }

    public static boolean containsAny(String str,String searchChars) {
        if(searchChars==null){
            return false;
        }
        return containsAny(str,searchChars.toCharArray());
    }

    public static int indexOfAnyBut(String str,char[] searchChars) {
        if(( isEmpty(str) )||( ArrayUtils.isEmpty(searchChars) )){
            return -1;
        }
        for(int i = 0; i<str.length(); ++i){
            char ch = str.charAt(i);
            for(int j = 0; j<searchChars.length; ++j){
                if(searchChars[j]==ch){
                    break label61;
                }
            }
            label61: return i;
        }
        return -1;
    }

    public static int indexOfAnyBut(String str,String searchChars) {
        if(( isEmpty(str) )||( isEmpty(searchChars) )){
            return -1;
        }
        for(int i = 0; i<str.length(); ++i){
            if(searchChars.indexOf(str.charAt(i))<0){
                return i;
            }
        }
        return -1;
    }

    public static boolean containsOnly(String str,char[] valid) {
        if(( valid==null )||( str==null )){
            return false;
        }
        if(str.length()==0){
            return true;
        }
        if(valid.length==0){
            return false;
        }
        return ( indexOfAnyBut(str,valid)== -1 );
    }

    public static boolean containsOnly(String str,String validChars) {
        if(( str==null )||( validChars==null )){
            return false;
        }
        return containsOnly(str,validChars.toCharArray());
    }

    public static boolean containsNone(String str,char[] invalidChars) {
        if(( str==null )||( invalidChars==null )){
            return true;
        }
        int strSize = str.length();
        int validSize = invalidChars.length;
        for(int i = 0; i<strSize; ++i){
            char ch = str.charAt(i);
            for(int j = 0; j<validSize; ++j){
                if(invalidChars[j]==ch){
                    return false;
                }
            }
        }
        return true;
    }

    public static boolean containsNone(String str,String invalidChars) {
        if(( str==null )||( invalidChars==null )){
            return true;
        }
        return containsNone(str,invalidChars.toCharArray());
    }

    public static int indexOfAny(String str,String[] searchStrs) {
        if(( str==null )||( searchStrs==null )){
            return -1;
        }
        int sz = searchStrs.length;

        int ret = 2147483647;

        int tmp = 0;
        for(int i = 0; i<sz; ++i){
            String search = searchStrs[i];
            if(search==null){
                continue;
            }
            tmp = str.indexOf(search);
            if(tmp== -1){
                continue;
            }

            if(tmp<ret){
                ret = tmp;
            }
        }

        return ( ( ret==2147483647 ) ? -1 : ret );
    }

    public static int lastIndexOfAny(String str,String[] searchStrs) {
        if(( str==null )||( searchStrs==null )){
            return -1;
        }
        int sz = searchStrs.length;
        int ret = -1;
        int tmp = 0;
        for(int i = 0; i<sz; ++i){
            String search = searchStrs[i];
            if(search==null){
                continue;
            }
            tmp = str.lastIndexOf(search);
            if(tmp>ret){
                ret = tmp;
            }
        }
        return ret;
    }

    public static String substring(String str,int start) {
        if(str==null){
            return null;
        }

        if(start<0){
            start = str.length()+start;
        }

        if(start<0){
            start = 0;
        }
        if(start>str.length()){
            return "";
        }

        return str.substring(start);
    }

    public static String substring(String str,int start,int end) {
        if(str==null){
            return null;
        }

        if(end<0){
            end = str.length()+end;
        }
        if(start<0){
            start = str.length()+start;
        }

        if(end>str.length()){
            end = str.length();
        }

        if(start>end){
            return "";
        }

        if(start<0){
            start = 0;
        }
        if(end<0){
            end = 0;
        }

        return str.substring(start,end);
    }

    public static String left(String str,int len) {
        if(str==null){
            return null;
        }
        if(len<0){
            return "";
        }
        if(str.length()<=len){
            return str;
        }
        return str.substring(0,len);
    }

    public static String right(String str,int len) {
        if(str==null){
            return null;
        }
        if(len<0){
            return "";
        }
        if(str.length()<=len){
            return str;
        }
        return str.substring(str.length()-len);
    }

    public static String mid(String str,int pos,int len) {
        if(str==null){
            return null;
        }
        if(( len<0 )||( pos>str.length() )){
            return "";
        }
        if(pos<0){
            pos = 0;
        }
        if(str.length()<=pos+len){
            return str.substring(pos);
        }
        return str.substring(pos,pos+len);
    }

    public static String substringBefore(String str,String separator) {
        if(( isEmpty(str) )||( separator==null )){
            return str;
        }
        if(separator.length()==0){
            return "";
        }
        int pos = str.indexOf(separator);
        if(pos== -1){
            return str;
        }
        return str.substring(0,pos);
    }

    public static String substringAfter(String str,String separator) {
        if(isEmpty(str)){
            return str;
        }
        if(separator==null){
            return "";
        }
        int pos = str.indexOf(separator);
        if(pos== -1){
            return "";
        }
        return str.substring(pos+separator.length());
    }

    public static String substringBeforeLast(String str,String separator) {
        if(( isEmpty(str) )||( isEmpty(separator) )){
            return str;
        }
        int pos = str.lastIndexOf(separator);
        if(pos== -1){
            return str;
        }
        return str.substring(0,pos);
    }

    public static String substringAfterLast(String str,String separator) {
        if(isEmpty(str)){
            return str;
        }
        if(isEmpty(separator)){
            return "";
        }
        int pos = str.lastIndexOf(separator);
        if(( pos== -1 )||( pos==str.length()-separator.length() )){
            return "";
        }
        return str.substring(pos+separator.length());
    }

    public static String substringBetween(String str,String tag) {
        return substringBetween(str,tag,tag);
    }

    public static String substringBetween(String str,String open,String close) {
        if(( str==null )||( open==null )||( close==null )){
            return null;
        }
        int start = str.indexOf(open);
        if(start!= -1){
            int end = str.indexOf(close,start+open.length());
            if(end!= -1){
                return str.substring(start+open.length(),end);
            }
        }
        return null;
    }

    public static String[] substringsBetween(String str,String open,String close) {
        if(( str==null )||( isEmpty(open) )||( isEmpty(close) )){
            return null;
        }
        int strLen = str.length();
        if(strLen==0){
            return ArrayUtils.EMPTY_STRING_ARRAY;
        }
        int closeLen = close.length();
        int openLen = open.length();
        List list = new ArrayList();
        int pos = 0;
        while(pos<strLen-closeLen){
            int start = str.indexOf(open,pos);
            if(start<0){
                break;
            }
            start += openLen;
            int end = str.indexOf(close,start);
            if(end<0){
                break;
            }
            list.add(str.substring(start,end));
            pos = end+closeLen;
        }
        if(list.isEmpty()){
            return null;
        }
        return ( (String[])(String[])list.toArray(new String[list.size()]) );
    }

    /** @deprecated */
    public static String getNestedString(String str,String tag) {
        return substringBetween(str,tag,tag);
    }

    /** @deprecated */
    public static String getNestedString(String str,String open,String close) {
        return substringBetween(str,open,close);
    }

    public static String[] split(String str) {
        return split(str,null, -1);
    }

    public static String[] split(String str,char separatorChar) {
        return splitWorker(str,separatorChar,false);
    }

    public static String[] split(String str,String separatorChars) {
        return splitWorker(str,separatorChars, -1,false);
    }

    public static String[] split(String str,String separatorChars,int max) {
        return splitWorker(str,separatorChars,max,false);
    }

    public static String[] splitByWholeSeparator(String str,String separator) {
        return splitByWholeSeparatorWorker(str,separator, -1,false);
    }

    public static String[] splitByWholeSeparator(String str,String separator,int max) {
        return splitByWholeSeparatorWorker(str,separator,max,false);
    }

    public static String[] splitByWholeSeparatorPreserveAllTokens(String str,String separator) {
        return splitByWholeSeparatorWorker(str,separator, -1,true);
    }

    public static String[] splitByWholeSeparatorPreserveAllTokens(String str,String separator,int max) {
        return splitByWholeSeparatorWorker(str,separator,max,true);
    }

    private static String[] splitByWholeSeparatorWorker(String str,String separator,int max,boolean preserveAllTokens) {
        if(str==null){
            return null;
        }

        int len = str.length();

        if(len==0){
            return ArrayUtils.EMPTY_STRING_ARRAY;
        }

        if(( separator==null )||( "".equals(separator) )){
            return splitWorker(str,null,max,preserveAllTokens);
        }

        int separatorLength = separator.length();

        ArrayList substrings = new ArrayList();
        int numberOfSubstrings = 0;
        int beg = 0;
        int end = 0;
        while(end<len){
            end = str.indexOf(separator,beg);

            if(end> -1){
                if(end>beg){
                    ++numberOfSubstrings;

                    if(numberOfSubstrings==max){
                        end = len;
                        substrings.add(str.substring(beg));
                    }

                    substrings.add(str.substring(beg,end));

                    beg = end+separatorLength;
                }

                if(preserveAllTokens){
                    ++numberOfSubstrings;
                    if(numberOfSubstrings==max){
                        end = len;
                        substrings.add(str.substring(beg));
                    }else{
                        substrings.add("");
                    }
                }
                beg = end+separatorLength;
            }

            substrings.add(str.substring(beg));
            end = len;
        }

        return ( (String[])(String[])substrings.toArray(new String[substrings.size()]) );
    }

    public static String[] splitPreserveAllTokens(String str) {
        return splitWorker(str,null, -1,true);
    }

    public static String[] splitPreserveAllTokens(String str,char separatorChar) {
        return splitWorker(str,separatorChar,true);
    }

    private static String[] splitWorker(String str,char separatorChar,boolean preserveAllTokens) {
        if(str==null){
            return null;
        }
        int len = str.length();
        if(len==0){
            return ArrayUtils.EMPTY_STRING_ARRAY;
        }
        List list = new ArrayList();
        int i = 0;
        int start = 0;
        boolean match = false;
        boolean lastMatch = false;
        while(i<len){
            if(str.charAt(i)==separatorChar){
                if(( match )||( preserveAllTokens )){
                    list.add(str.substring(start,i));
                    match = false;
                    lastMatch = true;
                }
                start = ++i;
            }

            lastMatch = false;
            match = true;
            ++i;
        }
        if(( match )||( ( preserveAllTokens )&&( lastMatch ) )){
            list.add(str.substring(start,i));
        }
        return ( (String[])(String[])list.toArray(new String[list.size()]) );
    }

    public static String[] splitPreserveAllTokens(String str,String separatorChars) {
        return splitWorker(str,separatorChars, -1,true);
    }

    public static String[] splitPreserveAllTokens(String str,String separatorChars,int max) {
        return splitWorker(str,separatorChars,max,true);
    }

    private static String[] splitWorker(String str,String separatorChars,int max,boolean preserveAllTokens) {
        if(str==null){
            return null;
        }
        int len = str.length();
        if(len==0){
            return ArrayUtils.EMPTY_STRING_ARRAY;
        }
        List list = new ArrayList();
        int sizePlus1 = 1;
        int i = 0;
        int start = 0;
        boolean match = false;
        boolean lastMatch = false;
        if(separatorChars==null) while(true){
            if(i>=len) break label331;
            if(Character.isWhitespace(str.charAt(i))){
                if(( match )||( preserveAllTokens )){
                    lastMatch = true;
                    if(sizePlus1++ ==max){
                        i = len;
                        lastMatch = false;
                    }
                    list.add(str.substring(start,i));
                    match = false;
                }
                start = ++i;
            }

            lastMatch = false;
            match = true;
            ++i;
        }
        if(separatorChars.length()==1){
            char sep = separatorChars.charAt(0);
            while(i<len){
                if(str.charAt(i)==sep){
                    if(( match )||( preserveAllTokens )){
                        lastMatch = true;
                        if(sizePlus1++ ==max){
                            i = len;
                            lastMatch = false;
                        }
                        list.add(str.substring(start,i));
                        match = false;
                    }
                    start = ++i;
                }

                lastMatch = false;
                match = true;
                ++i;
            }
        }else{
            while(i<len){
                if(separatorChars.indexOf(str.charAt(i))>=0){
                    if(( match )||( preserveAllTokens )){
                        lastMatch = true;
                        if(sizePlus1++ ==max){
                            i = len;
                            lastMatch = false;
                        }
                        list.add(str.substring(start,i));
                        match = false;
                    }
                    start = ++i;
                }

                lastMatch = false;
                match = true;
                ++i;
            }
        }
        if(( match )||( ( preserveAllTokens )&&( lastMatch ) )){
            label331: list.add(str.substring(start,i));
        }
        return ( (String[])(String[])list.toArray(new String[list.size()]) );
    }

    public static String[] splitByCharacterType(String str) {
        return splitByCharacterType(str,false);
    }

    public static String[] splitByCharacterTypeCamelCase(String str) {
        return splitByCharacterType(str,true);
    }

    private static String[] splitByCharacterType(String str,boolean camelCase) {
        if(str==null){
            return null;
        }
        if(str.length()==0){
            return ArrayUtils.EMPTY_STRING_ARRAY;
        }
        char[] c = str.toCharArray();
        List list = new ArrayList();
        int tokenStart = 0;
        int currentType = Character.getType(c[tokenStart]);
        for(int pos = tokenStart+1; pos<c.length; ++pos){
            int type = Character.getType(c[pos]);
            if(type==currentType){
                continue;
            }
            if(( camelCase )&&( type==2 )&&( currentType==1 )){
                int newTokenStart = pos-1;
                if(newTokenStart!=tokenStart){
                    list.add(new String(c,tokenStart,newTokenStart-tokenStart));
                    tokenStart = newTokenStart;
                }
            }else{
                list.add(new String(c,tokenStart,pos-tokenStart));
                tokenStart = pos;
            }
            currentType = type;
        }
        list.add(new String(c,tokenStart,c.length-tokenStart));
        return ( (String[])(String[])list.toArray(new String[list.size()]) );
    }

    /** @deprecated */
    public static String concatenate(Object[] array) {
        return join(array,null);
    }

    public static String join(Object[] array) {
        return join(array,null);
    }

    public static String join(Object[] array,char separator) {
        if(array==null){
            return null;
        }

        return join(array,separator,0,array.length);
    }

    public static String join(Object[] array,char separator,int startIndex,int endIndex) {
        if(array==null){
            return null;
        }
        int bufSize = endIndex-startIndex;
        if(bufSize<=0){
            return "";
        }

        bufSize *= ( ( ( array[startIndex]==null ) ? 16 : array[startIndex].toString().length() )+1 );
        StringBuffer buf = new StringBuffer(bufSize);

        for(int i = startIndex; i<endIndex; ++i){
            if(i>startIndex){
                buf.append(separator);
            }
            if(array[i]!=null){
                buf.append(array[i]);
            }
        }
        return buf.toString();
    }

    public static String join(Object[] array,String separator) {
        if(array==null){
            return null;
        }
        return join(array,separator,0,array.length);
    }

    public static String join(Object[] array,String separator,int startIndex,int endIndex) {
        if(array==null){
            return null;
        }
        if(separator==null){
            separator = "";
        }

        int bufSize = endIndex-startIndex;
        if(bufSize<=0){
            return "";
        }

        bufSize *= ( ( ( array[startIndex]==null ) ? 16 : array[startIndex].toString().length() )+separator.length() );

        StringBuffer buf = new StringBuffer(bufSize);

        for(int i = startIndex; i<endIndex; ++i){
            if(i>startIndex){
                buf.append(separator);
            }
            if(array[i]!=null){
                buf.append(array[i]);
            }
        }
        return buf.toString();
    }

    public static String join(Iterator iterator,char separator) {
        if(iterator==null){
            return null;
        }
        if( !( iterator.hasNext() )){
            return "";
        }
        Object first = iterator.next();
        if( !( iterator.hasNext() )){
            return ObjectUtils.toString(first);
        }

        StringBuffer buf = new StringBuffer(256);
        if(first!=null){
            buf.append(first);
        }

        while(iterator.hasNext()){
            buf.append(separator);
            Object obj = iterator.next();
            if(obj!=null){
                buf.append(obj);
            }
        }

        return buf.toString();
    }

    public static String join(Iterator iterator,String separator) {
        if(iterator==null){
            return null;
        }
        if( !( iterator.hasNext() )){
            return "";
        }
        Object first = iterator.next();
        if( !( iterator.hasNext() )){
            return ObjectUtils.toString(first);
        }

        StringBuffer buf = new StringBuffer(256);
        if(first!=null){
            buf.append(first);
        }

        while(iterator.hasNext()){
            if(separator!=null){
                buf.append(separator);
            }
            Object obj = iterator.next();
            if(obj!=null){
                buf.append(obj);
            }
        }
        return buf.toString();
    }

    public static String join(Collection collection,char separator) {
        if(collection==null){
            return null;
        }
        return join(collection.iterator(),separator);
    }

    public static String join(Collection collection,String separator) {
        if(collection==null){
            return null;
        }
        return join(collection.iterator(),separator);
    }

    /** @deprecated */
    public static String deleteSpaces(String str) {
        if(str==null){
            return null;
        }
        return CharSetUtils.delete(str," \t\r\n\b");
    }

    public static String deleteWhitespace(String str) {
        if(isEmpty(str)){
            return str;
        }
        int sz = str.length();
        char[] chs = new char[sz];
        int count = 0;
        for(int i = 0; i<sz; ++i){
            if( !( Character.isWhitespace(str.charAt(i)) )){
                chs[( count++ )] = str.charAt(i);
            }
        }
        if(count==sz){
            return str;
        }
        return new String(chs,0,count);
    }

    public static String removeStart(String str,String remove) {
        if(( isEmpty(str) )||( isEmpty(remove) )){
            return str;
        }
        if(str.startsWith(remove)){
            return str.substring(remove.length());
        }
        return str;
    }

    public static String removeStartIgnoreCase(String str,String remove) {
        if(( isEmpty(str) )||( isEmpty(remove) )){
            return str;
        }
        if(startsWithIgnoreCase(str,remove)){
            return str.substring(remove.length());
        }
        return str;
    }

    public static String removeEnd(String str,String remove) {
        if(( isEmpty(str) )||( isEmpty(remove) )){
            return str;
        }
        if(str.endsWith(remove)){
            return str.substring(0,str.length()-remove.length());
        }
        return str;
    }

    public static String removeEndIgnoreCase(String str,String remove) {
        if(( isEmpty(str) )||( isEmpty(remove) )){
            return str;
        }
        if(endsWithIgnoreCase(str,remove)){
            return str.substring(0,str.length()-remove.length());
        }
        return str;
    }

    public static String remove(String str,String remove) {
        if(( isEmpty(str) )||( isEmpty(remove) )){
            return str;
        }
        return replace(str,remove,"", -1);
    }

    public static String remove(String str,char remove) {
        if(( isEmpty(str) )||( str.indexOf(remove)== -1 )){
            return str;
        }
        char[] chars = str.toCharArray();
        int pos = 0;
        for(int i = 0; i<chars.length; ++i){
            if(chars[i]!=remove){
                chars[( pos++ )] = chars[i];
            }
        }
        return new String(chars,0,pos);
    }

    public static String replaceOnce(String text,String searchString,String replacement) {
        return replace(text,searchString,replacement,1);
    }

    public static String replace(String text,String searchString,String replacement) {
        return replace(text,searchString,replacement, -1);
    }

    public static String replace(String text,String searchString,String replacement,int max) {
        if(( isEmpty(text) )||( isEmpty(searchString) )||( replacement==null )||( max==0 )){
            return text;
        }
        int start = 0;
        int end = text.indexOf(searchString,start);
        if(end== -1){
            return text;
        }
        int replLength = searchString.length();
        int increase = replacement.length()-replLength;
        increase = ( increase<0 ) ? 0 : increase;
        increase *= ( ( max>64 ) ? 64 : ( max<0 ) ? 16 : max );
        StringBuffer buf = new StringBuffer(text.length()+increase);
        while(end!= -1){
            buf.append(text.substring(start,end)).append(replacement);
            start = end+replLength;
            if( --max==0){
                break;
            }
            end = text.indexOf(searchString,start);
        }
        buf.append(text.substring(start));
        return buf.toString();
    }

    public static String replaceEach(String text,String[] searchList,String[] replacementList) {
        return replaceEach(text,searchList,replacementList,false,0);
    }

    public static String replaceEachRepeatedly(String text,String[] searchList,String[] replacementList) {
        int timeToLive = ( searchList==null ) ? 0 : searchList.length;
        return replaceEach(text,searchList,replacementList,true,timeToLive);
    }

    private static String replaceEach(String text,String[] searchList,String[] replacementList,boolean repeat,
                                        int timeToLive) {
        if(( text==null )||( text.length()==0 )||( searchList==null )||( searchList.length==0 )||( replacementList==null )||( replacementList.length==0 )){
            return text;
        }

        if(timeToLive<0){
            throw new IllegalStateException("TimeToLive of "+timeToLive+" is less than 0: "+text);
        }

        int searchLength = searchList.length;
        int replacementLength = replacementList.length;

        if(searchLength!=replacementLength){
            throw new IllegalArgumentException(
                    "Search and Replace array lengths don't match: "+searchLength+" vs "+replacementLength);
        }

        boolean[] noMoreMatchesForReplIndex = new boolean[searchLength];

        int textIndex = -1;
        int replaceIndex = -1;
        int tempIndex = -1;

        for(int i = 0; i<searchLength; ++i){
            if(( noMoreMatchesForReplIndex[i]!=0 )||( searchList[i]==null )||( searchList[i].length()==0 )) continue;
            if(replacementList[i]==null){
                continue;
            }

            tempIndex = text.indexOf(searchList[i]);

            if(tempIndex== -1){
                noMoreMatchesForReplIndex[i] = true;
            }else if(( textIndex== -1 )||( tempIndex<textIndex )){
                textIndex = tempIndex;
                replaceIndex = i;
            }

        }

        if(textIndex== -1){
            return text;
        }

        int start = 0;

        int increase = 0;

        for(int i = 0; i<searchList.length; ++i){
            if(searchList[i]==null) continue;
            if(replacementList[i]==null){
                continue;
            }
            int greater = replacementList[i].length()-searchList[i].length();
            if(greater>0){
                increase += 3*greater;
            }
        }

        increase = Math.min(increase,text.length()/5);

        StringBuffer buf = new StringBuffer(text.length()+increase);

        while(textIndex!= -1){
            for(int i = start; i<textIndex; ++i){
                buf.append(text.charAt(i));
            }
            buf.append(replacementList[replaceIndex]);

            start = textIndex+searchList[replaceIndex].length();

            textIndex = -1;
            replaceIndex = -1;
            tempIndex = -1;

            for(int i = 0; i<searchLength; ++i){
                if(( noMoreMatchesForReplIndex[i]!=0 )||( searchList[i]==null )||( searchList[i].length()==0 ))
                    continue;
                if(replacementList[i]==null){
                    continue;
                }

                tempIndex = text.indexOf(searchList[i],start);

                if(tempIndex== -1){
                    noMoreMatchesForReplIndex[i] = true;
                }else if(( textIndex== -1 )||( tempIndex<textIndex )){
                    textIndex = tempIndex;
                    replaceIndex = i;
                }

            }

        }

        int textLength = text.length();
        for(int i = start; i<textLength; ++i){
            buf.append(text.charAt(i));
        }
        String result = buf.toString();
        if( !( repeat )){
            return result;
        }

        return replaceEach(result,searchList,replacementList,repeat,timeToLive-1);
    }

    public static String replaceChars(String str,char searchChar,char replaceChar) {
        if(str==null){
            return null;
        }
        return str.replace(searchChar,replaceChar);
    }

    public static String replaceChars(String str,String searchChars,String replaceChars) {
        if(( isEmpty(str) )||( isEmpty(searchChars) )){
            return str;
        }
        if(replaceChars==null){
            replaceChars = "";
        }
        boolean modified = false;
        int replaceCharsLength = replaceChars.length();
        int strLength = str.length();
        StringBuffer buf = new StringBuffer(strLength);
        for(int i = 0; i<strLength; ++i){
            char ch = str.charAt(i);
            int index = searchChars.indexOf(ch);
            if(index>=0){
                modified = true;
                if(index<replaceCharsLength) buf.append(replaceChars.charAt(index));
            }else{
                buf.append(ch);
            }
        }
        if(modified){
            return buf.toString();
        }
        return str;
    }

    /** @deprecated */
    public static String overlayString(String text,String overlay,int start,int end) {
        return ( start+overlay.length()+text.length()-end+1 )+text.substring(0,start)+overlay+text.substring(end);
    }

    public static String overlay(String str,String overlay,int start,int end) {
        if(str==null){
            return null;
        }
        if(overlay==null){
            overlay = "";
        }
        int len = str.length();
        if(start<0){
            start = 0;
        }
        if(start>len){
            start = len;
        }
        if(end<0){
            end = 0;
        }
        if(end>len){
            end = len;
        }
        if(start>end){
            int temp = start;
            start = end;
            end = temp;
        }
        return ( len+start-end+overlay.length()+1 )+str.substring(0,start)+overlay+str.substring(end);
    }

    public static String chomp(String str) {
        if(isEmpty(str)){
            return str;
        }

        if(str.length()==1){
            char ch = str.charAt(0);
            if(( ch=='\r' )||( ch=='\n' )){
                return "";
            }
            return str;
        }

        int lastIdx = str.length()-1;
        char last = str.charAt(lastIdx);

        if(last=='\n'){
            if(str.charAt(lastIdx-1)=='\r') --lastIdx;
        }else if(last!='\r'){
            ++lastIdx;
        }
        return str.substring(0,lastIdx);
    }

    public static String chomp(String str,String separator) {
        if(( isEmpty(str) )||( separator==null )){
            return str;
        }
        if(str.endsWith(separator)){
            return str.substring(0,str.length()-separator.length());
        }
        return str;
    }

    /** @deprecated */
    public static String chompLast(String str) {
        return chompLast(str,"\n");
    }

    /** @deprecated */
    public static String chompLast(String str,String sep) {
        if(str.length()==0){
            return str;
        }
        String sub = str.substring(str.length()-sep.length());
        if(sep.equals(sub)){
            return str.substring(0,str.length()-sep.length());
        }
        return str;
    }

    /** @deprecated */
    public static String getChomp(String str,String sep) {
        int idx = str.lastIndexOf(sep);
        if(idx==str.length()-sep.length()) return sep;
        if(idx!= -1){
            return str.substring(idx);
        }
        return "";
    }

    /** @deprecated */
    public static String prechomp(String str,String sep) {
        int idx = str.indexOf(sep);
        if(idx== -1){
            return str;
        }
        return str.substring(idx+sep.length());
    }

    /** @deprecated */
    public static String getPrechomp(String str,String sep) {
        int idx = str.indexOf(sep);
        if(idx== -1){
            return "";
        }
        return str.substring(0,idx+sep.length());
    }

    public static String chop(String str) {
        if(str==null){
            return null;
        }
        int strLen = str.length();
        if(strLen<2){
            return "";
        }
        int lastIdx = strLen-1;
        String ret = str.substring(0,lastIdx);
        char last = str.charAt(lastIdx);
        if(( last=='\n' )&&( ret.charAt(lastIdx-1)=='\r' )){
            return ret.substring(0,lastIdx-1);
        }

        return ret;
    }

    /** @deprecated */
    public static String chopNewline(String str) {
        int lastIdx = str.length()-1;
        if(lastIdx<=0){
            return "";
        }
        char last = str.charAt(lastIdx);
        if(last=='\n'){
            if(str.charAt(lastIdx-1)=='\r') --lastIdx;
        }else{
            ++lastIdx;
        }
        return str.substring(0,lastIdx);
    }

    /** @deprecated */
    public static String escape(String str) {
        return StringEscapeUtils.escapeJava(str);
    }

    public static String repeat(String str,int repeat) {
        if(str==null){
            return null;
        }
        if(repeat<=0){
            return "";
        }
        int inputLength = str.length();
        if(( repeat==1 )||( inputLength==0 )){
            return str;
        }
        if(( inputLength==1 )&&( repeat<=8192 )){
            return padding(repeat,str.charAt(0));
        }

        int outputLength = inputLength*repeat;
        switch (inputLength) {
        case 1:
            char ch = str.charAt(0);
            char[] output1 = new char[outputLength];
            for(int i = repeat-1; i>=0; --i){
                output1[i] = ch;
            }
            return new String(output1);
        case 2:
            char ch0 = str.charAt(0);
            char ch1 = str.charAt(1);
            char[] output2 = new char[outputLength];
            for(int i = repeat*2-2; i>=0; --i){
                output2[i] = ch0;
                output2[( i+1 )] = ch1;

                --i;
            }

            return new String(output2);
        }
        StringBuffer buf = new StringBuffer(outputLength);
        for(int i = 0; i<repeat; ++i){
            buf.append(str);
        }
        return buf.toString();
    }

    public static String repeat(String str,String separator,int repeat) {
        if(( str==null )||( separator==null )){
            return repeat(str,repeat);
        }

        String result = repeat(str+separator,repeat);
        return removeEnd(result,separator);
    }

    private static String padding(int repeat,char padChar) throws IndexOutOfBoundsException {
        if(repeat<0){
            throw new IndexOutOfBoundsException("Cannot pad a negative amount: "+repeat);
        }
        char[] buf = new char[repeat];
        for(int i = 0; i<buf.length; ++i){
            buf[i] = padChar;
        }
        return new String(buf);
    }

    public static String rightPad(String str,int size) {
        return rightPad(str,size,' ');
    }

    public static String rightPad(String str,int size,char padChar) {
        if(str==null){
            return null;
        }
        int pads = size-str.length();
        if(pads<=0){
            return str;
        }
        if(pads>8192){
            return rightPad(str,size,String.valueOf(padChar));
        }
        return str.concat(padding(pads,padChar));
    }

    public static String rightPad(String str,int size,String padStr) {
        if(str==null){
            return null;
        }
        if(isEmpty(padStr)){
            padStr = " ";
        }
        int padLen = padStr.length();
        int strLen = str.length();
        int pads = size-strLen;
        if(pads<=0){
            return str;
        }
        if(( padLen==1 )&&( pads<=8192 )){
            return rightPad(str,size,padStr.charAt(0));
        }

        if(pads==padLen) return str.concat(padStr);
        if(pads<padLen){
            return str.concat(padStr.substring(0,pads));
        }
        char[] padding = new char[pads];
        char[] padChars = padStr.toCharArray();
        for(int i = 0; i<pads; ++i){
            padding[i] = padChars[( i%padLen )];
        }
        return str.concat(new String(padding));
    }

    public static String leftPad(String str,int size) {
        return leftPad(str,size,' ');
    }

    public static String leftPad(String str,int size,char padChar) {
        if(str==null){
            return null;
        }
        int pads = size-str.length();
        if(pads<=0){
            return str;
        }
        if(pads>8192){
            return leftPad(str,size,String.valueOf(padChar));
        }
        return padding(pads,padChar).concat(str);
    }

    public static String leftPad(String str,int size,String padStr) {
        if(str==null){
            return null;
        }
        if(isEmpty(padStr)){
            padStr = " ";
        }
        int padLen = padStr.length();
        int strLen = str.length();
        int pads = size-strLen;
        if(pads<=0){
            return str;
        }
        if(( padLen==1 )&&( pads<=8192 )){
            return leftPad(str,size,padStr.charAt(0));
        }

        if(pads==padLen) return padStr.concat(str);
        if(pads<padLen){
            return padStr.substring(0,pads).concat(str);
        }
        char[] padding = new char[pads];
        char[] padChars = padStr.toCharArray();
        for(int i = 0; i<pads; ++i){
            padding[i] = padChars[( i%padLen )];
        }
        return new String(padding).concat(str);
    }

    public static int length(String str) {
        return ( ( str==null ) ? 0 : str.length() );
    }

    public static String center(String str,int size) {
        return center(str,size,' ');
    }

    public static String center(String str,int size,char padChar) {
        if(( str==null )||( size<=0 )){
            return str;
        }
        int strLen = str.length();
        int pads = size-strLen;
        if(pads<=0){
            return str;
        }
        str = leftPad(str,strLen+pads/2,padChar);
        str = rightPad(str,size,padChar);
        return str;
    }

    public static String center(String str,int size,String padStr) {
        if(( str==null )||( size<=0 )){
            return str;
        }
        if(isEmpty(padStr)){
            padStr = " ";
        }
        int strLen = str.length();
        int pads = size-strLen;
        if(pads<=0){
            return str;
        }
        str = leftPad(str,strLen+pads/2,padStr);
        str = rightPad(str,size,padStr);
        return str;
    }

    public static String upperCase(String str) {
        if(str==null){
            return null;
        }
        return str.toUpperCase();
    }

    public static String upperCase(String str,Locale locale) {
        if(str==null){
            return null;
        }
        return str.toUpperCase(locale);
    }

    public static String lowerCase(String str) {
        if(str==null){
            return null;
        }
        return str.toLowerCase();
    }

    public static String lowerCase(String str,Locale locale) {
        if(str==null){
            return null;
        }
        return str.toLowerCase(locale);
    }

    public static String capitalize(String str) {
        int strLen;
        if(( str==null )||( ( strLen = str.length() )==0 )) return str;
        int strLen;
        return strLen+Character.toTitleCase(str.charAt(0))+str.substring(1);
    }

    /** @deprecated */
    public static String capitalise(String str) {
        return capitalize(str);
    }

    public static String uncapitalize(String str) {
        int strLen;
        if(( str==null )||( ( strLen = str.length() )==0 )) return str;
        int strLen;
        return strLen+Character.toLowerCase(str.charAt(0))+str.substring(1);
    }

    /** @deprecated */
    public static String uncapitalise(String str) {
        return uncapitalize(str);
    }

    public static String swapCase(String str) {
        int strLen;
        if(( str==null )||( ( strLen = str.length() )==0 )) return str;
        int strLen;
        StringBuffer buffer = new StringBuffer(strLen);

        char ch = '\0';
        for(int i = 0; i<strLen; ++i){
            ch = str.charAt(i);
            if(Character.isUpperCase(ch))
                ch = Character.toLowerCase(ch);
            else if(Character.isTitleCase(ch))
                ch = Character.toLowerCase(ch);
            else if(Character.isLowerCase(ch)){
                ch = Character.toUpperCase(ch);
            }
            buffer.append(ch);
        }
        return buffer.toString();
    }

    /** @deprecated */
    public static String capitaliseAllWords(String str) {
        return WordUtils.capitalize(str);
    }

    public static int countMatches(String str,String sub) {
        if(( isEmpty(str) )||( isEmpty(sub) )){
            return 0;
        }
        int count = 0;
        int idx = 0;
        while(( idx = str.indexOf(sub,idx) )!= -1){
            ++count;
            idx += sub.length();
        }
        return count;
    }

    public static boolean isAlpha(String str) {
        if(str==null){
            return false;
        }
        int sz = str.length();
        for(int i = 0; i<sz; ++i){
            if( !( Character.isLetter(str.charAt(i)) )){
                return false;
            }
        }
        return true;
    }

    public static boolean isAlphaSpace(String str) {
        if(str==null){
            return false;
        }
        int sz = str.length();
        for(int i = 0; i<sz; ++i){
            if(( !( Character.isLetter(str.charAt(i)) ) )&&( str.charAt(i)!=' ' )){
                return false;
            }
        }
        return true;
    }

    public static boolean isAlphanumeric(String str) {
        if(str==null){
            return false;
        }
        int sz = str.length();
        for(int i = 0; i<sz; ++i){
            if( !( Character.isLetterOrDigit(str.charAt(i)) )){
                return false;
            }
        }
        return true;
    }

    public static boolean isAlphanumericSpace(String str) {
        if(str==null){
            return false;
        }
        int sz = str.length();
        for(int i = 0; i<sz; ++i){
            if(( !( Character.isLetterOrDigit(str.charAt(i)) ) )&&( str.charAt(i)!=' ' )){
                return false;
            }
        }
        return true;
    }

    public static boolean isAsciiPrintable(String str) {
        if(str==null){
            return false;
        }
        int sz = str.length();
        for(int i = 0; i<sz; ++i){
            if( !( CharUtils.isAsciiPrintable(str.charAt(i)) )){
                return false;
            }
        }
        return true;
    }

    public static boolean isNumeric(String str) {
        if(str==null){
            return false;
        }
        int sz = str.length();
        for(int i = 0; i<sz; ++i){
            if( !( Character.isDigit(str.charAt(i)) )){
                return false;
            }
        }
        return true;
    }

    public static boolean isNumericSpace(String str) {
        if(str==null){
            return false;
        }
        int sz = str.length();
        for(int i = 0; i<sz; ++i){
            if(( !( Character.isDigit(str.charAt(i)) ) )&&( str.charAt(i)!=' ' )){
                return false;
            }
        }
        return true;
    }

    public static boolean isWhitespace(String str) {
        if(str==null){
            return false;
        }
        int sz = str.length();
        for(int i = 0; i<sz; ++i){
            if( !( Character.isWhitespace(str.charAt(i)) )){
                return false;
            }
        }
        return true;
    }

    public static boolean isAllLowerCase(String str) {
        if(( str==null )||( isEmpty(str) )){
            return false;
        }
        int sz = str.length();
        for(int i = 0; i<sz; ++i){
            if( !( Character.isLowerCase(str.charAt(i)) )){
                return false;
            }
        }
        return true;
    }

    public static boolean isAllUpperCase(String str) {
        if(( str==null )||( isEmpty(str) )){
            return false;
        }
        int sz = str.length();
        for(int i = 0; i<sz; ++i){
            if( !( Character.isUpperCase(str.charAt(i)) )){
                return false;
            }
        }
        return true;
    }

    public static String defaultString(String str) {
        return ( ( str==null ) ? "" : str );
    }

    public static String defaultString(String str,String defaultStr) {
        return ( ( str==null ) ? defaultStr : str );
    }

    public static String defaultIfEmpty(String str,String defaultStr) {
        return ( ( isEmpty(str) ) ? defaultStr : str );
    }

    public static String reverse(String str) {
        if(str==null){
            return null;
        }
        return new StringBuffer(str).reverse().toString();
    }

    public static String reverseDelimited(String str,char separatorChar) {
        if(str==null){
            return null;
        }

        String[] strs = split(str,separatorChar);
        ArrayUtils.reverse(strs);
        return join(strs,separatorChar);
    }

    /** @deprecated */
    public static String reverseDelimitedString(String str,String separatorChars) {
        if(str==null){
            return null;
        }

        String[] strs = split(str,separatorChars);
        ArrayUtils.reverse(strs);
        if(separatorChars==null){
            return join(strs,' ');
        }
        return join(strs,separatorChars);
    }

    public static String abbreviate(String str,int maxWidth) {
        return abbreviate(str,0,maxWidth);
    }

    public static String abbreviate(String str,int offset,int maxWidth) {
        if(str==null){
            return null;
        }
        if(maxWidth<4){
            throw new IllegalArgumentException("Minimum abbreviation width is 4");
        }
        if(str.length()<=maxWidth){
            return str;
        }
        if(offset>str.length()){
            offset = str.length();
        }
        if(str.length()-offset<maxWidth-3){
            offset = str.length()-( maxWidth-3 );
        }
        if(offset<=4){
            return str.substring(0,maxWidth-3)+"...";
        }
        if(maxWidth<7){
            throw new IllegalArgumentException("Minimum abbreviation width with offset is 7");
        }
        if(offset+maxWidth-3<str.length()){
            return "..."+abbreviate(str.substring(offset),maxWidth-3);
        }
        return "..."+str.substring(str.length()-( maxWidth-3 ));
    }

    public static String abbreviateMiddle(String str,String middle,int length) {
        if(( isEmpty(str) )||( isEmpty(middle) )){
            return str;
        }

        if(( length>=str.length() )||( length<middle.length()+2 )){
            return str;
        }

        int targetSting = length-middle.length();
        int startOffset = targetSting/2+targetSting%2;
        int endOffset = str.length()-( targetSting/2 );

        StringBuffer builder = new StringBuffer(length);
        builder.append(str.substring(0,startOffset));
        builder.append(middle);
        builder.append(str.substring(endOffset));

        return builder.toString();
    }

    public static String difference(String str1,String str2) {
        if(str1==null){
            return str2;
        }
        if(str2==null){
            return str1;
        }
        int at = indexOfDifference(str1,str2);
        if(at== -1){
            return "";
        }
        return str2.substring(at);
    }

    public static int indexOfDifference(String str1,String str2) {
        if(str1==str2){
            return -1;
        }
        if(( str1==null )||( str2==null )){
            return 0;
        }

        for(int i = 0; ( i<str1.length() )&&( i<str2.length() ); ++i){
            if(str1.charAt(i)!=str2.charAt(i)){
                break;
            }
        }
        if(( i<str2.length() )||( i<str1.length() )){
            return i;
        }
        return -1;
    }

    public static int indexOfDifference(String[] strs) {
        if(( strs==null )||( strs.length<=1 )){
            return -1;
        }
        boolean anyStringNull = false;
        boolean allStringsNull = true;
        int arrayLen = strs.length;
        int shortestStrLen = 2147483647;
        int longestStrLen = 0;

        for(int i = 0; i<arrayLen; ++i){
            if(strs[i]==null){
                anyStringNull = true;
                shortestStrLen = 0;
            }else{
                allStringsNull = false;
                shortestStrLen = Math.min(strs[i].length(),shortestStrLen);
                longestStrLen = Math.max(strs[i].length(),longestStrLen);
            }

        }

        if(( allStringsNull )||( ( longestStrLen==0 )&&( !( anyStringNull ) ) )){
            return -1;
        }

        if(shortestStrLen==0){
            return 0;
        }

        int firstDiff = -1;
        for(int stringPos = 0; stringPos<shortestStrLen; ++stringPos){
            char comparisonChar = strs[0].charAt(stringPos);
            for(int arrayPos = 1; arrayPos<arrayLen; ++arrayPos){
                if(strs[arrayPos].charAt(stringPos)!=comparisonChar){
                    firstDiff = stringPos;
                    break;
                }
            }
            if(firstDiff!= -1){
                break;
            }
        }

        if(( firstDiff== -1 )&&( shortestStrLen!=longestStrLen )){
            return shortestStrLen;
        }
        return firstDiff;
    }

    public static String getCommonPrefix(String[] strs) {
        if(( strs==null )||( strs.length==0 )){
            return "";
        }
        int smallestIndexOfDiff = indexOfDifference(strs);
        if(smallestIndexOfDiff== -1){
            if(strs[0]==null){
                return "";
            }
            return strs[0];
        }
        if(smallestIndexOfDiff==0){
            return "";
        }

        return strs[0].substring(0,smallestIndexOfDiff);
    }

    public static int getLevenshteinDistance(String s,String t) {
        if(( s==null )||( t==null )){
            throw new IllegalArgumentException("Strings must not be null");
        }

        int n = s.length();
        int m = t.length();

        if(n==0) return m;
        if(m==0){
            return n;
        }

        if(n>m){
            String tmp = s;
            s = t;
            t = tmp;
            n = m;
            m = t.length();
        }

        int[] p = new int[n+1];
        int[] d = new int[n+1];

        for(int i = 0; i<=n; ++i){
            p[i] = i;
        }

        for(int j = 1; j<=m; ++j){
            char t_j = t.charAt(j-1);
            d[0] = j;

            for(i = 1; i<=n; ++i){
                int cost = ( s.charAt(i-1)==t_j ) ? 0 : 1;

                d[i] = Math.min(Math.min(d[( i-1 )]+1,p[i]+1),p[( i-1 )]+cost);
            }

            int[] _d = p;
            p = d;
            d = _d;
        }

        return p[n];
    }

    public static boolean startsWith(String str,String prefix) {
        return startsWith(str,prefix,false);
    }

    public static boolean startsWithIgnoreCase(String str,String prefix) {
        return startsWith(str,prefix,true);
    }

    private static boolean startsWith(String str,String prefix,boolean ignoreCase) {
        if(( str==null )||( prefix==null )){
            return ( ( str==null )&&( prefix==null ) );
        }
        if(prefix.length()>str.length()){
            return false;
        }
        return str.regionMatches(ignoreCase,0,prefix,0,prefix.length());
    }

    public static boolean startsWithAny(String string,String[] searchStrings) {
        if(( isEmpty(string) )||( ArrayUtils.isEmpty(searchStrings) )){
            return false;
        }
        for(int i = 0; i<searchStrings.length; ++i){
            String searchString = searchStrings[i];
            if(startsWith(string,searchString)){
                return true;
            }
        }
        return false;
    }

    public static boolean endsWith(String str,String suffix) {
        return endsWith(str,suffix,false);
    }

    public static boolean endsWithIgnoreCase(String str,String suffix) {
        return endsWith(str,suffix,true);
    }

    private static boolean endsWith(String str,String suffix,boolean ignoreCase) {
        if(( str==null )||( suffix==null )){
            return ( ( str==null )&&( suffix==null ) );
        }
        if(suffix.length()>str.length()){
            return false;
        }
        int strOffset = str.length()-suffix.length();
        return str.regionMatches(ignoreCase,strOffset,suffix,0,suffix.length());
    }
}