String helper methods to perform various string manipulations in Codename One.

StringUtils.java

package group.diamonddev.util;

import com.codename1.io.Util;
import com.codename1.l10n.L10NManager;
import com.codename1.util.StringUtil;
import com.codename1.util.regex.RE;

import java.util.*;

/**
 * @author Diamond Mubaarak
 * @version 1.0
 */
public class StringUtils {

    /**
     * Convert a given string to title case.
     *
     * @param string the string value
     *
     * @return converted string
     */
    public static String title(String string) {

        if (string == null || string.isEmpty()) return "";
        if (string.length() == 1) return string.toUpperCase();

        List<String> parts = StringUtil.tokenize(string, " ");

        StringBuilder buffer = new StringBuilder(string.length());
        for (String part : parts) {
            char[] charArray = part.toLowerCase().toCharArray();
            charArray[0] = Character.toUpperCase(charArray[0]);

            buffer.append(new String(charArray)).append(" ");
        }

        return buffer.toString().trim();
    }

    /**
     * Convert a given string to sentence case.
     *
     * @param string the string value
     *
     * @return converted string
     */
    public static String sentence(String string) {

        if (string == null || string.isEmpty()) return "";
        if (string.length() == 1) return string.toUpperCase();

        char c = string.charAt(0);
        String s = "" + c;

        String result = string.substring(1).toLowerCase();

        return s.toUpperCase() + result;
    }

    /**
     * Convert a given string from camel case to sentence case.
     *
     * @param text the string value
     *
     * @return converted string
     */
    public static String camelToSentence(String text) {
        String string = replaceAll(text, "([A-Z])", " $1");
        string = trim(string);

        String c = string.substring(0, 1).toUpperCase();

        return c + string.substring(1);
    }

    /**
     * Convert a given string from camel case to snake case.
     *
     * @param string the string value
     *
     * @return converted string
     */
    public static String camelToSnake(String string) {
        return camelToSnake(string, '_');
    }

    /**
     * Convert a given string from camel case to snake case.
     *
     * @param string    the string value
     * @param delimiter the delimiter character
     *
     * @return converted string
     */
    public static String camelToSnake(String string, char delimiter) {

        StringBuilder buffer = new StringBuilder();

        char c = string.charAt(0);
        buffer.append(Character.toLowerCase(c));

        for (int i = 1; i < string.length(); i++) {
            char ch = string.charAt(i);

            if (Character.isUpperCase(ch)) {
                buffer.append(delimiter);
                buffer.append(Character.toLowerCase(ch));
            } else {
                buffer.append(ch);
            }
        }

        return buffer.toString();
    }

    /**
     * Convert a given string to snake case.
     *
     * @param string    the string value
     * @param delimiter the delimiter character
     *
     * @return converted string
     */
    public String snake(String string, char delimiter) {

        StringBuilder buffer = new StringBuilder();
        for (int i = 0; i < string.length(); i++) {
            if (Character.isUpperCase(string.charAt(i))) {
                if (i > 0) {
                    buffer.append('_');
                }
                buffer.append(Character.toLowerCase(string.charAt(i)));
            } else {
                buffer.append(string.charAt(i));
            }
        }

        return buffer.toString();
    }

    /**
     * Check if a string is in alphanumeric-underscore format
     *
     * @param text the string value
     *
     * @return true/false to show whether the string is in the right format
     */
    public static boolean isAlphaNumericUnderscore(String text) {
        String regex = "^[\\w]+$";

        return new RE(regex).match(text);
    }

    /**
     * Helper method to format a decimal while maintaining a fixed length of decimal places by appending zeros when
     * necessary.
     *
     * @param value         the double value to be formatted
     * @param decimalPlaces the decimal places to apply
     *
     * @return a formatted decimal string
     */
    public static String formatDecimal(double value, int decimalPlaces) {
        if (decimalPlaces < 0) return value + "";

        L10NManager manager = L10NManager.getInstance();
        manager.setLocale("US", "EN"); // To ensure "," is used for thousand delimiter and "." for a decimal separator

        String result = manager.format(value, decimalPlaces);

        if (!result.contains(".") && decimalPlaces > 0) result += ".";

        int dec = result.length() - (result.indexOf(".") + 1);
        if (dec <= decimalPlaces) {
            int len = result.length() + decimalPlaces - dec;
            result = rightPad(result, len, "0");
        }

        return result;
    }

    /**
     * Splits the provided text into an array, using whitespace as the separator.
     *
     * @param string the String to split
     *
     * @return an array of parsed Strings
     */
    public static String[] split(String string) {
        return split(string, " ");
    }

    /**
     * Splits the provided text into an array, using the specified separator.
     *
     * @param string    the String to split
     * @param separator the characters used as the delimiters
     *
     * @return an array of parsed Strings
     */
    public static String[] split(String string, String separator) {
        List<String> l = StringUtil.tokenize(string, separator);
        return l.toArray(new String[0]);
    }

    public static String chunk(String text) {
        String s = replaceAll(text, "\\D", "");
        s = replaceAll(s, "([0-9]{4})", " $0  ");

        return rtrim(StringUtil.replaceAll(s.trim(), "   ", "  "));
    }

    public static Map<String, List<String>> queryParams(String url) {
        try {
            Map<String, List<String>> params = new HashMap<>();
            List<String> urlParts = StringUtil.tokenize(url, "\\?");
            if (urlParts.size() > 1) {
                String query = urlParts.get(1);
                for (String param : split(query, "&")) {
                    String[] pair = split(param, "=");
                    String key = Util.decode(pair[0], "UTF-8", true);
                    String value = "";
                    if (pair.length > 1) {
                        value = Util.decode(pair[1], "UTF-8", true);
                    }

                    List<String> values = params.get(key);
                    if (values == null) {
                        values = new ArrayList<>();
                        params.put(key, values);
                    }
                    values.add(value);
                }
            }

            return params;
        } catch (Exception ex) {
            return new HashMap<>();
        }
    }

    /**
     * @param strings The array of strings to be joined
     */
    public static String sentence(List<String> strings) {
        return sentence("&", strings.toArray(new String[0]));
    }

    /**
     * @param joiner  The "and" character to use on last item
     * @param strings The array of strings to be joined
     */
    public static String sentence(String joiner, List<String> strings) {
        return sentence(joiner, strings.toArray(new String[0]));
    }

    /**
     * @param joiner  The "and" character to use on last item
     * @param strings The array of strings to be joined
     */
    public static String sentence(String joiner, String... strings) {
        String result = "";
        if (strings.length > 1) {
            result = join(strings, ", ");
            result = replaceLast(result, ", ", " " + joiner + " ");
        } else if (strings.length == 1) {
            result = strings[0];
        }

        return result;
    }

    /**
     * Replace the last occurrence of a given value in the string.
     *
     * @param subject subject
     * @param search  search
     * @param replace replace
     *
     * @return string
     */
    public static String replaceLast(String subject, String search, String replace) {
        if (search.isEmpty()) return subject;

        int lastIndex = subject.lastIndexOf(search);

        if (lastIndex < 0) return subject;

        String tail = StringUtil.replaceFirst(subject.substring(lastIndex), search, replace);
        return subject.substring(0, lastIndex) + tail;
    }

    /**
     * Strip whitespace (or other characters) from the beginning of a string.
     *
     * @param string the string to trim
     *
     * @return trimmed string
     */
    public static String ltrim(String string) {
        return stripStart(string, " \t\r\n\\v\f\b\u007F");
    }

    /**
     * Strip whitespace (or other characters) from the end of a string.
     *
     * @param string the string to trim
     *
     * @return trimmed string
     */
    public static String rtrim(String string) {
        return stripEnd(string, " \t\r\n\\v\f\b\u007F");
    }

    /**
     * Create an acronym from a string.
     *
     * @param string the string to create acronym from
     *
     * @return an acronym
     */
    public static String acronym(String string, String separator) {
        if (string == null || string.isEmpty()) {
            return "";
        }

        StringBuilder builder = new StringBuilder();

        List<String> strings = StringUtil.tokenize(string, " ");
        for (String s : strings) {
            String c = substring(firstNonBlank(s).toUpperCase(), 0, 1);
            builder.append(c).append(separator);
        }

        return rtrim(builder.toString());
    }

    /**
     * Helper method to remove common symbols from a string
     *
     * @param dirtyString the string to be cleaned
     *
     * @return a clean string with no bad symbols and space
     */
    public static String clean(String dirtyString) {
        return clean(dirtyString, "_");
    }

    /**
     * Helper method to remove common symbols from a string
     *
     * @param dirtyString the string to be cleaned
     * @param replacement the replacement for the symbols removed
     *
     * @return a clean string with no bad symbols and space
     */
    public static String clean(String dirtyString, String replacement) {
        char[] characterSet = " :&!#*$)(.,`~@+=/\\?'\"][}{|".toCharArray();
        return clean(dirtyString, replacement, characterSet);
    }

    /**
     * Helper method to remove common symbols from a string
     *
     * @param dirtyString  the string to be cleaned
     * @param characterSet the set of characters to look for
     *
     * @return a clean string with no bad symbols and space
     */
    public static String clean(String dirtyString, char[] characterSet) {
        return clean(dirtyString, "_", characterSet);
    }

    /**
     * Helper method to remove common symbols from a string
     *
     * @param dirtyString  the string to be cleaned
     * @param replacement  the replacement for the symbols removed
     * @param characterSet the set of characters to look for
     *
     * @return a clean string with no bad symbols and space
     */
    public static String clean(String dirtyString, String replacement, char[] characterSet) {
        String result = dirtyString;
        for (char c : characterSet) {
            char[] value = {c};
            result = StringUtil.replaceAll(result, new String(value), replacement);
        }
        return result;
    }

    @SafeVarargs
    public static <T extends CharSequence> T firstNonBlank(T... values) {
        if (values != null) {
            int var2 = values.length;

            for (int var3 = 0; var3 < var2; ++var3) {
                T val = (T) ((CharSequence[]) values)[var3];
                if (isNotBlank(val)) {
                    return val;
                }
            }
        }

        return null;
    }

    @SafeVarargs
    public static <T extends CharSequence> T firstNonEmpty(T... values) {
        if (values != null) {
            int var2 = values.length;

            for (int var3 = 0; var3 < var2; ++var3) {
                T val = (T) ((CharSequence[]) values)[var3];
                if (isNotEmpty(val)) {
                    return val;
                }
            }
        }

        return null;
    }

    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) {
            int strLen = str.length();
            int pads = size - strLen;
            if (pads > 0) {
                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) {
            if (isEmpty(padStr)) {
                padStr = " ";
            }

            int strLen = str.length();
            int pads = size - strLen;
            if (pads > 0) {
                str = leftPad(str, strLen + pads / 2, padStr);
                str = rightPad(str, size, padStr);
            }
        }
        return str;
    }

    public static String chomp(String str) {
        if (isEmpty(str)) {
            return str;
        } else if (str.length() == 1) {
            char ch = str.charAt(0);
            return ch != '\r' && ch != '\n' ? str : "";
        } else {
            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);
        }
    }

    /**
     * @deprecated
     */
    @Deprecated
    public static String chomp(String str, String separator) {
        return removeEnd(str, separator);
    }

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

    public static int compare(String str1, String str2) {
        return compare(str1, str2, true);
    }

    public static int compare(String str1, String str2, boolean nullIsLess) {
        if (Objects.equals(str1, str2)) {
            return 0;
        } else if (str1 == null) {
            return nullIsLess ? -1 : 1;
        } else if (str2 == null) {
            return nullIsLess ? 1 : -1;
        } else {
            return str1.compareTo(str2);
        }
    }

    public static int compareIgnoreCase(String str1, String str2) {
        return compareIgnoreCase(str1, str2, true);
    }

    public static int compareIgnoreCase(String str1, String str2, boolean nullIsLess) {
        if (Objects.equals(str1, str2)) {
            return 0;
        } else if (str1 == null) {
            return nullIsLess ? -1 : 1;
        } else if (str2 == null) {
            return nullIsLess ? 1 : -1;
        } else {
            return str1.compareToIgnoreCase(str2);
        }
    }

    public static boolean containsNone(CharSequence cs, char... searchChars) {
        if (cs != null && searchChars != null) {
            int csLen = cs.length();
            int csLast = csLen - 1;
            int searchLen = searchChars.length;
            int searchLast = searchLen - 1;

            for (int i = 0; i < csLen; ++i) {
                char ch = cs.charAt(i);

                for (int j = 0; j < searchLen; ++j) {
                    if (searchChars[j] == ch) {
                        if (!Character.isHighSurrogate(ch)) {
                            return false;
                        }

                        if (j == searchLast) {
                            return false;
                        }

                        if (i < csLast && searchChars[j + 1] == cs.charAt(i + 1)) {
                            return false;
                        }
                    }
                }
            }

        }
        return true;
    }

    public static boolean containsNone(CharSequence cs, String invalidChars) {
        return cs == null || invalidChars == null || containsNone(cs, invalidChars.toCharArray());
    }

    public static boolean containsWhitespace(CharSequence seq) {
        if (!isEmpty(seq)) {
            int strLen = seq.length();

            for (int i = 0; i < strLen; ++i) {
                if (Character.isWhitespace(seq.charAt(i))) {
                    return true;
                }
            }

        }
        return false;
    }

    private static void convertRemainingAccentCharacters(StringBuilder decomposed) {
        for (int i = 0; i < decomposed.length(); ++i) {
            if (decomposed.charAt(i) == 321) {
                decomposed.deleteCharAt(i);
                decomposed.insert(i, 'L');
            } else if (decomposed.charAt(i) == 322) {
                decomposed.deleteCharAt(i);
                decomposed.insert(i, 'l');
            }
        }

    }

    public static int countMatches(CharSequence str, char ch) {
        if (isEmpty(str)) {
            return 0;
        } else {
            int count = 0;

            for (int i = 0; i < str.length(); ++i) {
                if (ch == str.charAt(i)) {
                    ++count;
                }
            }

            return count;
        }
    }

    public static <T extends CharSequence> T defaultIfBlank(T str, T defaultStr) {
        return isBlank(str) ? defaultStr : str;
    }

    public static <T extends CharSequence> T defaultIfEmpty(T str, T defaultStr) {
        return isEmpty(str) ? defaultStr : str;
    }

    public static String defaultString(String str) {
        return defaultString(str, "");
    }

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

    public static String deleteWhitespace(String str) {
        if (isEmpty(str)) {
            return str;
        } else {
            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;
            } else {
                return new String(chs, 0, count);
            }
        }
    }

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

    public static boolean equals(CharSequence cs1, CharSequence cs2) {
        if (cs1 == cs2) {
            return true;
        } else if (cs1 != null && cs2 != null) {
            if (cs1.length() != cs2.length()) {
                return false;
            } else if (cs1 instanceof String && cs2 instanceof String) {
                return cs1.equals(cs2);
            } else {
                int length = cs1.length();

                for (int i = 0; i < length; ++i) {
                    if (cs1.charAt(i) != cs2.charAt(i)) {
                        return false;
                    }
                }

                return true;
            }
        } else {
            return false;
        }
    }

    public static String getDigits(String str) {
        if (isEmpty(str)) {
            return str;
        } else {
            int sz = str.length();
            StringBuilder strDigits = new StringBuilder(sz);

            for (int i = 0; i < sz; ++i) {
                char tempChar = str.charAt(i);
                if (Character.isDigit(tempChar)) {
                    strDigits.append(tempChar);
                }
            }

            return strDigits.toString();
        }
    }

    public static int indexOfDifference(CharSequence cs1, CharSequence cs2) {
        if (cs1 == cs2) {
            return -1;
        } else if (cs1 != null && cs2 != null) {
            int i;
            for (i = 0; i < cs1.length() && i < cs2.length() && cs1.charAt(i) == cs2.charAt(i); ++i) {
                System.out.println();
            }

            return i >= cs2.length() && i >= cs1.length() ? -1 : i;
        } else {
            return 0;
        }
    }

    public static boolean isAllLowerCase(CharSequence cs) {
        if (isEmpty(cs)) {
            return false;
        } else {
            int sz = cs.length();

            for (int i = 0; i < sz; ++i) {
                if (!Character.isLowerCase(cs.charAt(i))) {
                    return false;
                }
            }

            return true;
        }
    }

    public static boolean isAllUpperCase(CharSequence cs) {
        if (isEmpty(cs)) {
            return false;
        } else {
            int sz = cs.length();

            for (int i = 0; i < sz; ++i) {
                if (!Character.isUpperCase(cs.charAt(i))) {
                    return false;
                }
            }

            return true;
        }
    }

    public static boolean isBlank(CharSequence cs) {
        int strLen = length(cs);
        if (strLen != 0) {
            for (int i = 0; i < strLen; ++i) {
                if (!Character.isWhitespace(cs.charAt(i))) {
                    return false;
                }
            }

        }
        return true;
    }

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

    public static boolean isMixedCase(CharSequence cs) {
        if (!isEmpty(cs) && cs.length() != 1) {
            boolean containsUppercase = false;
            boolean containsLowercase = false;
            int sz = cs.length();

            for (int i = 0; i < sz; ++i) {
                if (containsUppercase && containsLowercase) {
                    return true;
                }

                if (Character.isUpperCase(cs.charAt(i))) {
                    containsUppercase = true;
                } else if (Character.isLowerCase(cs.charAt(i))) {
                    containsLowercase = true;
                }
            }

            return containsUppercase && containsLowercase;
        } else {
            return false;
        }
    }

    public static boolean isNotBlank(CharSequence cs) {
        return !isBlank(cs);
    }

    public static boolean isNotEmpty(CharSequence cs) {
        return !isEmpty(cs);
    }

    public static boolean isNumeric(CharSequence cs) {
        if (isEmpty(cs)) {
            return false;
        } else {
            int sz = cs.length();

            for (int i = 0; i < sz; ++i) {
                if (!Character.isDigit(cs.charAt(i))) {
                    return false;
                }
            }

            return true;
        }
    }

    public static boolean isNumericSpace(CharSequence cs) {
        if (cs == null) {
            return false;
        } else {
            int sz = cs.length();

            for (int i = 0; i < sz; ++i) {
                if (!Character.isDigit(cs.charAt(i)) && cs.charAt(i) != ' ') {
                    return false;
                }
            }

            return true;
        }
    }

    public static boolean isWhitespace(CharSequence cs) {
        if (cs == null) {
            return false;
        } else {
            int sz = cs.length();

            for (int i = 0; i < sz; ++i) {
                if (!Character.isWhitespace(cs.charAt(i))) {
                    return false;
                }
            }

            return true;
        }
    }

    public static String join(byte[] array, char separator) {
        return array == null ? null : join(array, separator, 0, array.length);
    }

    public static String join(byte[] array, char separator, int startIndex, int endIndex) {
        return joinObj(new byte[][]{array}, separator, startIndex, endIndex);
    }

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

    public static String join(char[] array, char separator, int startIndex, int endIndex) {
        return joinObj(new char[][]{array}, separator, startIndex, endIndex);
    }

    public static String join(double[] array, char separator) {
        return array == null ? null : join(array, separator, 0, array.length);
    }

    public static String join(double[] array, char separator, int startIndex, int endIndex) {
        return joinObj(new double[][]{array}, separator, startIndex, endIndex);
    }

    public static String join(float[] array, char separator) {
        return array == null ? null : join(array, separator, 0, array.length);
    }

    public static String join(float[] array, char separator, int startIndex, int endIndex) {
        return joinObj(new float[][]{array}, separator, startIndex, endIndex);
    }

    public static String join(int[] array, char separator) {
        return array == null ? null : join(array, separator, 0, array.length);
    }

    public static String join(int[] array, char separator, int startIndex, int endIndex) {
        return joinObj(new int[][]{array}, separator, startIndex, endIndex);
    }

    public static String join(Iterable<?> iterable, char separator) {
        return iterable == null ? null : join(iterable.iterator(), separator);
    }

    public static String join(Iterable<?> iterable, String separator) {
        return iterable == null ? null : join(iterable.iterator(), separator);
    }

    public static String join(Iterator<?> iterator, char separator) {
        if (iterator == null) {
            return null;
        } else if (!iterator.hasNext()) {
            return "";
        } else {
            Object first = iterator.next();
            if (!iterator.hasNext()) {
                return Objects.toString(first, "");
            } else {
                StringBuilder buf = new StringBuilder(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;
        } else if (!iterator.hasNext()) {
            return "";
        } else {
            Object first = iterator.next();
            if (!iterator.hasNext()) {
                return Objects.toString(first, "");
            } else {
                StringBuilder buf = new StringBuilder(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(List<?> list, char separator, int startIndex, int endIndex) {
        if (list == null) {
            return null;
        } else {
            int noOfItems = endIndex - startIndex;
            if (noOfItems <= 0) {
                return "";
            } else {
                List<?> subList = list.subList(startIndex, endIndex);
                return join(subList.iterator(), separator);
            }
        }
    }

    public static String join(List<?> list, String separator, int startIndex, int endIndex) {
        if (list == null) {
            return null;
        } else {
            int noOfItems = endIndex - startIndex;
            if (noOfItems <= 0) {
                return "";
            } else {
                List<?> subList = list.subList(startIndex, endIndex);
                return join(subList.iterator(), separator);
            }
        }
    }

    public static String join(long[] array, char separator) {
        return array == null ? null : join(array, separator, 0, array.length);
    }

    public static String join(long[] array, char separator, int startIndex, int endIndex) {
        return joinObj(new long[][]{array}, separator, startIndex, endIndex);
    }

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

    public static String join(Object[] array, char separator, int startIndex, int endIndex) {
        return joinObj(array, separator, startIndex, endIndex);
    }

    public static String joinObj(Object[] array, char separator, int startIndex, int endIndex) {
        if (array == null) {
            return null;
        } else {
            return joiner(array, separator + "", startIndex, endIndex);
        }
    }

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

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

            return joiner(array, separator, startIndex, endIndex);
        }
    }

    private static String joiner(Object[] array, String separator, int startIndex, int endIndex) {
        int noOfItems = endIndex - startIndex;
        if (noOfItems <= 0) {
            return "";
        } else {
            StringBuilder buf = newStringBuilder(noOfItems);
            if (array[startIndex] != null) {
                buf.append(array[startIndex]);
            }

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

            return buf.toString();
        }
    }

    public static String join(short[] array, char separator) {
        return array == null ? null : join(array, separator, 0, array.length);
    }

    public static String join(short[] array, char separator, int startIndex, int endIndex) {
        return joinObj(new short[][]{array}, separator, startIndex, endIndex);
    }

    @SafeVarargs
    public static <T> String join(T... elements) {
        return join(elements, null);
    }

    public static String joinWith(String separator, Object... objects) {
        if (objects == null) {
            throw new IllegalArgumentException("Object varargs must not be null");
        } else {
            String sanitizedSeparator = defaultString(separator);
            StringBuilder result = new StringBuilder();
            Iterator iterator = Arrays.asList(objects).iterator();

            while (iterator.hasNext()) {
                String value = Objects.toString(iterator.next(), "");
                result.append(value);
                if (iterator.hasNext()) {
                    result.append(sanitizedSeparator);
                }
            }

            return result.toString();
        }
    }

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

    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;
        } else {
            int pads = size - str.length();
            if (pads <= 0) {
                return str;
            } else {
                return pads > 8192 ? leftPad(str, size, String.valueOf(padChar)) : repeat(padChar, pads).concat(str);
            }
        }
    }

    public static String leftPad(String str, int size, String padStr) {
        if (str == null) {
            return null;
        } else {
            if (isEmpty(padStr)) {
                padStr = " ";
            }

            int padLen = padStr.length();
            int strLen = str.length();
            int pads = size - strLen;
            if (pads <= 0) {
                return str;
            } else if (padLen == 1 && pads <= 8192) {
                return leftPad(str, size, padStr.charAt(0));
            } else if (pads == padLen) {
                return padStr.concat(str);
            } else if (pads < padLen) {
                return padStr.substring(0, pads).concat(str);
            } else {
                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(CharSequence cs) {
        return cs == null ? 0 : cs.length();
    }

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

    private static int[] matches(CharSequence first, CharSequence second) {
        CharSequence max;
        CharSequence min;
        if (first.length() > second.length()) {
            max = first;
            min = second;
        } else {
            max = second;
            min = first;
        }

        int range = Math.max(max.length() / 2 - 1, 0);
        int[] matchIndexes = new int[min.length()];
        Arrays.fill(matchIndexes, -1);
        boolean[] matchFlags = new boolean[max.length()];
        int matches = 0;

        int transpositions;
        int prefix;
        for (int mi = 0; mi < min.length(); ++mi) {
            char c1 = min.charAt(mi);
            transpositions = Math.max(mi - range, 0);

            for (prefix = Math.min(mi + range + 1, max.length()); transpositions < prefix; ++transpositions) {
                if (!matchFlags[transpositions] && c1 == max.charAt(transpositions)) {
                    matchIndexes[mi] = transpositions;
                    matchFlags[transpositions] = true;
                    ++matches;
                    break;
                }
            }
        }

        char[] ms1 = new char[matches];
        char[] ms2 = new char[matches];
        transpositions = 0;

        for (prefix = 0; transpositions < min.length(); ++transpositions) {
            if (matchIndexes[transpositions] != -1) {
                ms1[prefix] = min.charAt(transpositions);
                ++prefix;
            }
        }

        transpositions = 0;

        for (prefix = 0; transpositions < max.length(); ++transpositions) {
            if (matchFlags[transpositions]) {
                ms2[prefix] = max.charAt(transpositions);
                ++prefix;
            }
        }

        transpositions = 0;

        for (prefix = 0; prefix < ms1.length; ++prefix) {
            if (ms1[prefix] != ms2[prefix]) {
                ++transpositions;
            }
        }

        prefix = 0;

        for (int mi = 0; mi < min.length() && first.charAt(mi) == second.charAt(mi); ++mi) {
            ++prefix;
        }

        return new int[]{matches, transpositions / 2, prefix, max.length()};
    }

    public static String mid(String str, int pos, int len) {
        if (str == null) {
            return null;
        } else if (len >= 0 && pos <= str.length()) {
            if (pos < 0) {
                pos = 0;
            }

            return str.length() <= pos + len ? str.substring(pos) : str.substring(pos, pos + len);
        } else {
            return "";
        }
    }

    private static StringBuilder newStringBuilder(int noOfItems) {
        return new StringBuilder(noOfItems * 16);
    }

    public static String normalizeSpace(String str) {
        if (isEmpty(str)) {
            return str;
        } else {
            int size = str.length();
            char[] newChars = new char[size];
            int count = 0;
            int whitespacesCount = 0;
            boolean startWhitespaces = true;

            for (int i = 0; i < size; ++i) {
                char actualChar = str.charAt(i);
                boolean isWhitespace = Character.isWhitespace(actualChar);
                if (isWhitespace) {
                    if (whitespacesCount == 0 && !startWhitespaces) {
                        newChars[count++] = " ".charAt(0);
                    }

                    ++whitespacesCount;
                } else {
                    startWhitespaces = false;
                    newChars[count++] = actualChar == 160 ? 32 : actualChar;
                    whitespacesCount = 0;
                }
            }

            if (startWhitespaces) {
                return "";
            } else {
                return (new String(newChars, 0, count - (whitespacesCount > 0 ? 1 : 0))).trim();
            }
        }
    }

    public static String overlay(String str, String overlay, int start, int end) {
        if (str == null) {
            return null;
        } else {
            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 str.substring(0, start) + overlay + str.substring(end);
        }
    }

    public static String remove(String str, char remove) {
        if (!isEmpty(str) && str.indexOf(remove) != -1) {
            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);
        } else {
            return str;
        }
    }

    public static String removeEnd(String str, String remove) {
        if (!isEmpty(str) && !isEmpty(remove)) {
            return str.endsWith(remove) ? str.substring(0, str.length() - remove.length()) : str;
        } else {
            return str;
        }
    }

    public static String removeStart(String str, String remove) {
        if (!isEmpty(str) && !isEmpty(remove)) {
            return str.startsWith(remove) ? str.substring(remove.length()) : str;
        } else {
            return str;
        }
    }

    public static String repeat(char ch, int repeat) {
        if (repeat <= 0) {
            return "";
        } else {
            char[] buf = new char[repeat];

            for (int i = repeat - 1; i >= 0; --i) {
                buf[i] = ch;
            }

            return new String(buf);
        }
    }

    public static String repeat(String str, int repeat) {
        if (str == null) {
            return null;
        } else if (repeat <= 0) {
            return "";
        } else {
            int inputLength = str.length();
            if (repeat != 1 && inputLength != 0) {
                if (inputLength == 1 && repeat <= 8192) {
                    return repeat(str.charAt(0), repeat);
                } else {
                    int outputLength = inputLength * repeat;
                    switch (inputLength) {
                        case 1:
                            return repeat(str.charAt(0), repeat);
                        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);
                        default:
                            StringBuilder buf = new StringBuilder(outputLength);

                            for (int i = 0; i < repeat; ++i) {
                                buf.append(str);
                            }

                            return buf.toString();
                    }
                }
            } else {
                return str;
            }
        }
    }

    public static String repeat(String str, String separator, int repeat) {
        if (str != null && separator != null) {
            String result = repeat(str + separator, repeat);
            return removeEnd(result, separator);
        } else {
            return repeat(str, repeat);
        }
    }

    public static String replace(String str, String needle, String replacement) {
        return replaceAll(str, needle, replacement);
    }

    public static String replaceAll(String str, String regex, String replacement) {
        RE r = new RE(regex);
        return r.subst(str, replacement, 2);
    }

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

    public static String replaceChars(String str, String searchChars, String replaceChars) {
        if (!isEmpty(str) && !isEmpty(searchChars)) {
            if (replaceChars == null) {
                replaceChars = "";
            }

            boolean modified = false;
            int replaceCharsLength = replaceChars.length();
            int strLength = str.length();
            StringBuilder buf = new StringBuilder(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();
            } else {
                return str;
            }
        } else {
            return str;
        }
    }

    public static String reverse(String str) {
        return str == null ? null : (new StringBuilder(str)).reverse().toString();
    }

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

    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;
        } else {
            int pads = size - str.length();
            if (pads <= 0) {
                return str;
            } else {
                return pads > 8192 ? rightPad(str, size, String.valueOf(padChar)) : str.concat(repeat(padChar, pads));
            }
        }
    }

    public static String rightPad(String str, int size, String padStr) {
        if (str == null) {
            return null;
        } else {
            if (isEmpty(padStr)) {
                padStr = " ";
            }

            int padLen = padStr.length();
            int strLen = str.length();
            int pads = size - strLen;
            if (pads <= 0) {
                return str;
            } else if (padLen == 1 && pads <= 8192) {
                return rightPad(str, size, padStr.charAt(0));
            } else if (pads == padLen) {
                return str.concat(padStr);
            } else if (pads < padLen) {
                return str.concat(padStr.substring(0, pads));
            } else {
                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 rotate(String str, int shift) {
        if (str == null) {
            return null;
        } else {
            int strLen = str.length();
            if (shift != 0 && strLen != 0 && shift % strLen != 0) {
                StringBuilder builder = new StringBuilder(strLen);
                int offset = -(shift % strLen);
                builder.append(substring(str, offset));
                builder.append(substring(str, 0, offset));
                return builder.toString();
            } else {
                return str;
            }
        }
    }

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

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

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

                while (end != 0 && stripChars.indexOf(str.charAt(end - 1)) != -1) {
                    --end;
                }
            }

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

    public static String stripStart(String str, String stripChars) {
        int strLen = length(str);
        if (strLen == 0) {
            return str;
        } else {
            int start = 0;
            if (stripChars == null) {
                while (start != strLen && Character.isWhitespace(str.charAt(start))) {
                    ++start;
                }
            } else {
                if (stripChars.isEmpty()) {
                    return str;
                }

                while (start != strLen && stripChars.indexOf(str.charAt(start)) != -1) {
                    ++start;
                }
            }

            return str.substring(start);
        }
    }

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

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

    public static String substring(String str, int start) {
        if (str == null) {
            return null;
        } else {
            if (start < 0) {
                start += str.length();
            }

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

            return start > str.length() ? "" : str.substring(start);
        }
    }

    public static String substring(String str, int start, int end) {
        if (str == null) {
            return null;
        } else {
            if (end < 0) {
                end += str.length();
            }

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

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

            if (start > end) {
                return "";
            } else {
                if (start < 0) {
                    start = 0;
                }

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

                return str.substring(start, end);
            }
        }
    }

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

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

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

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

    public static String substringBefore(String str, String separator) {
        if (!isEmpty(str) && separator != null) {
            if (separator.isEmpty()) {
                return "";
            } else {
                int pos = str.indexOf(separator);
                return pos == -1 ? str : str.substring(0, pos);
            }
        } else {
            return str;
        }
    }

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

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

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

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

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

    public static String truncate(String str, int offset, int maxWidth) {
        if (offset < 0) {
            throw new IllegalArgumentException("offset cannot be negative");
        } else if (maxWidth < 0) {
            throw new IllegalArgumentException("maxWith cannot be negative");
        } else if (str == null) {
            return null;
        } else if (offset > str.length()) {
            return "";
        } else if (str.length() > maxWidth) {
            int ix = Math.min(offset + maxWidth, str.length());
            return str.substring(offset, ix);
        } else {
            return str.substring(offset);
        }
    }

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

    public static String valueOf(char[] value) {
        return value == null ? null : String.valueOf(value);
    }

    public static String wrap(String str, char wrapWith) {
        return !isEmpty(str) && wrapWith != 0 ? wrapWith + str + wrapWith : str;
    }

    public static String wrap(String str, String wrapWith) {
        return !isEmpty(str) && !isEmpty(wrapWith) ? wrapWith.concat(str).concat(wrapWith) : str;
    }

    public static String wrapIfMissing(String str, char wrapWith) {
        if (!isEmpty(str) && wrapWith != 0) {
            boolean wrapStart = str.charAt(0) != wrapWith;
            boolean wrapEnd = str.charAt(str.length() - 1) != wrapWith;
            if (!wrapStart && !wrapEnd) {
                return str;
            } else {
                StringBuilder builder = new StringBuilder(str.length() + 2);
                if (wrapStart) {
                    builder.append(wrapWith);
                }

                builder.append(str);
                if (wrapEnd) {
                    builder.append(wrapWith);
                }

                return builder.toString();
            }
        } else {
            return str;
        }
    }

    public static String wrapIfMissing(String str, String wrapWith) {
        if (!isEmpty(str) && !isEmpty(wrapWith)) {
            boolean wrapStart = !str.startsWith(wrapWith);
            boolean wrapEnd = !str.endsWith(wrapWith);
            if (!wrapStart && !wrapEnd) {
                return str;
            } else {
                StringBuilder builder = new StringBuilder(str.length() + wrapWith.length() + wrapWith.length());
                if (wrapStart) {
                    builder.append(wrapWith);
                }

                builder.append(str);
                if (wrapEnd) {
                    builder.append(wrapWith);
                }

                return builder.toString();
            }
        } else {
            return str;
        }
    }
}

MIssing the isEmpty and repeat methods.

@MoKamal I added more methods you may find useful.