public static String callStackToString() 
{
        return stackToString(new RuntimeException());
}

Get a string containing the stack of the current location. Note This utility is useful in debug scenarios to dump out the call stack.

 public static String capitalizeFirstChar(String name) 
{
        if ((name == null) || name.length() == 0) {
            return name;
        }
        char start = name.charAt(0);
        if (Character.isLowerCase(start)) {
            start = Character.toUpperCase(start);
            return start + name.substring(1);
        }
        return name;
}

Capitalizes the first character of the name.

 public static Class getWrapperClass(Class primitive) 
{
        if (primitive == int.class) {
            return java.lang.Integer.class;
        } else if (primitive == short.class) {
            return java.lang.Short.class;
        } else if (primitive == boolean.class) {
            return java.lang.Boolean.class;
        } else if (primitive == byte.class) {
            return java.lang.Byte.class;
        } else if (primitive == long.class) {
            return java.lang.Long.class;
        } else if (primitive == double.class) {
            return java.lang.Double.class;
        } else if (primitive == float.class) {
            return java.lang.Float.class;
        } else if (primitive == char.class) {
            return java.lang.Character.class;
        }
        return null;
}

 public static Class getWrapperClass(String primitive) 
{
        if (primitive.equals("int")) {
            return java.lang.Integer.class;
        } else if (primitive.equals("short")) {
            return java.lang.Short.class;
        } else if (primitive.equals("boolean")) {
            return java.lang.Boolean.class;
        } else if (primitive.equals("byte")) {
            return java.lang.Byte.class;
        } else if (primitive.equals("long")) {
            return java.lang.Long.class;
        } else if (primitive.equals("double")) {
            return java.lang.Double.class;
        } else if (primitive.equals("float")) {
            return java.lang.Float.class;
        } else if (primitive.equals("char")) {
            return java.lang.Character.class;
        }
        return null;
}

 public static boolean hasUpperCase(String word) 
{
        if (word == null) {
            return false;
        }
        int len = word.length();
        for (int i = 0; i <  len; i++) {
            if (Character.isUpperCase(word.charAt(i))) {
                return true;
            }
        }
        return false;
}

Check if the word has any uppercase letters

 public static int indexOfIgnoreCase(String string,
    String search) 
{
        int index = -1;
        final int stringLength = string.length();
        final int testLength = search.length();
        if (stringLength  > 1 || testLength  > 1) {
            final char firstCharOfTest = Character.toLowerCase(search.charAt(0));
            final int lastStringCharacterToCheck = stringLength - testLength + 1;
            for (int i = 0; i <  lastStringCharacterToCheck; i++) {
                if (firstCharOfTest == Character.toLowerCase(string.charAt(i))) {
                    index = i;
                    for (int j = 1; j <  testLength; j++) {
                        final char c = string.charAt(i + j);
                        final char otherChar = search.charAt(j);
                        if (Character.toLowerCase(c) != Character.toLowerCase(otherChar)) {
                            index = -1;
                            break;
                        }
                    }
                    if (-1 != index) {
                        break;
                    }
                }
            }
        }
        return index;
}

Scans the parameter string for the parameter search ignoring case when comparing characters.

 public static boolean isFalse(String value) 
{
        return isFalseExplicitly(value);
}

Tests the String 'value': return 'true' if its 'false', '0', or 'no' - else 'false'

Follow in 'C' tradition of boolean values: false is specific (0), everything else is true;

 public static boolean isFalse(Object value) 
{
        return isFalse(value, true);
}

 public static boolean isFalse(Object value,
    boolean defaultVal) 
{
        return isFalseExplicitly(value, defaultVal);
}

Tests the Object 'value': if its null, return default. if its a Boolean, return booleanValue() if its an Integer, return 'false' if its '0' else 'true' if its a String, return 'false' if its 'false', 'no', or '0' - else 'true' All other types return 'true'

 public static boolean isFalseExplicitly(String value) 
{
        return value == null ||
                value.equalsIgnoreCase("false") ||
                value.equals("0") ||
                value.equalsIgnoreCase("no");
}

Tests the String 'value': return 'true' if its null, 'false', '0', or 'no' - else 'false'

 public static boolean isFalseExplicitly(Object value) 
{
        return isFalseExplicitly(value, true);
}

 public static boolean isFalseExplicitly(Object value,
    boolean defaultVal) 
{
        if (value == null) {
            return defaultVal;
        }
        if (value instanceof Boolean) {
            return !((Boolean) value).booleanValue();
        }
        if (value instanceof Integer) {
            return ((Integer) value).intValue() == 0;
        }
        if (value instanceof String) {
            return isFalseExplicitly((String) value);
        }
        return false;
}

Tests the Object 'value': if its null, return default. if its a Boolean, return !booleanValue() if its an Integer, return 'true' if its '0' else 'false' if its a String, return isFalseExplicitly((String)value). All other types return 'false'

 public static boolean isJavaId(String id) 
{
        if (id == null || id.length() == 0 || isJavaKeyword(id)) {
            return false;
        }
        if (!Character.isJavaIdentifierStart(id.charAt(0))) {
            return false;
        }
        for (int i = 1; i <  id.length(); i++) {
            if (!Character.isJavaIdentifierPart(id.charAt(i))) {
                return false;
            }
        }
        return true;
}

 public static boolean isJavaKeyword(String keyword) 
{
        // None of the java keywords have uppercase characters
        if (hasUpperCase(keyword)) {
            return false;
        }
        return (Arrays.binarySearch(keywords, keyword, englishCollator)  >= 0);
}

Checks if the input string is a valid java keyword.

 public static boolean isTrue(String value) 
{
        return !isFalseExplicitly(value);
}

Tests the String 'value': return 'false' if its 'false', '0', or 'no' - else 'true'

Follow in 'C' tradition of boolean values: false is specific (0), everything else is true;

 public static boolean isTrue(Object value) 
{
        return isTrue(value, false);
}

 public static boolean isTrue(Object value,
    boolean defaultVal) 
{
        return !isFalseExplicitly(value, !defaultVal);
}

Tests the Object 'value': if its null, return default. if its a Boolean, return booleanValue() if its an Integer, return 'false' if its '0' else 'true' if its a String, return 'false' if its 'false', 'no', or '0' - else 'true' All other types return 'true'

 public static boolean isTrueExplicitly(String value) 
{
        return value != null &&
                (value.equalsIgnoreCase("true") ||
                        value.equals("1") ||
                        value.equalsIgnoreCase("yes"));
}

Tests the String 'value': return 'true' if its 'true', '1', or 'yes' - else 'false'

 public static boolean isTrueExplicitly(Object value) 
{
        return isTrueExplicitly(value, false);
}

 public static boolean isTrueExplicitly(Object value,
    boolean defaultVal) 
{
        if (value == null) {
            return defaultVal;
        }
        if (value instanceof Boolean) {
            return ((Boolean) value).booleanValue();
        }
        if (value instanceof Integer) {
            return ((Integer) value).intValue() != 0;
        }
        if (value instanceof String) {
            return isTrueExplicitly((String) value);
        }
        return defaultVal;
}

Tests the Object 'value': if its null, return default. if its a Boolean, return booleanValue() if its an Integer, return 'false' if its '0' else 'true' if its a String, return isTrueExplicitly((String)value). All other types return 'true'

 public static String makeNonJavaKeyword(String keyword) 
{
        return keywordPrefix + keyword;
}

Turns a java keyword string into a non-Java keyword string. (Right now this simply means appending an underscore.)

 public static final String replace(String name,
    String oldT,
    String newT) 
{
        if (name == null) return "";
        // Create a string buffer that is twice initial length.
        // This is a good starting point.
        StringBuffer sb = new StringBuffer(name.length() * 2);
        int len = oldT.length();
        try {
            int start = 0;
            int i = name.indexOf(oldT, start);
            while (i  >= 0) {
                sb.append(name.substring(start, i));
                sb.append(newT);
                start = i + len;
                i = name.indexOf(oldT, start);
            }
            if (start <  name.length())
                sb.append(name.substring(start));
        } catch (NullPointerException e) {
            // No FFDC code needed
        }
        return new String(sb);
}

replace: Like String.replace except that the old new items are strings.

 public static String[] split(String str,
    char separatorChar) 
{
                                                                                                                                                                                        
        if (str == null) {
            return null;
        }
        int len = str.length();
        if (len == 0) {
            return EMPTY_STRING_ARRAY;
        }
        List list = new ArrayList();
        int i = 0, start = 0;
        boolean match = false;
        while (i <  len) {
            if (str.charAt(i) == separatorChar) {
                if (match) {
                    list.add(str.substring(start, i));
                    match = false;
                }
                start = ++i;
                continue;
            }
            match = true;
            i++;
        }
        if (match) {
            list.add(str.substring(start, i));
        }
        return (String[]) list.toArray(new String[list.size()]);
}

Splits the provided text into an array, separator specified. This is an alternative to using StringTokenizer.

The separator is not included in the returned String array. Adjacent separators are treated as one separator.

A null input String returns null.

StringUtils.split(null, *) = null
StringUtils.split("", *) = []
StringUtils.split("a.b.c", '.') = ["a", "b", "c"]
StringUtils.split("a..b.c", '.') = ["a", "b", "c"]
StringUtils.split("a:b:c", '.') = ["a:b:c"]
StringUtils.split("a\tb\nc", null) = ["a", "b", "c"]
StringUtils.split("a b c", ' ') = ["a", "b", "c"]

 public static String stackToString(Throwable e) 
{
        java.io.StringWriter sw = new java.io.StringWriter();
        java.io.BufferedWriter bw = new java.io.BufferedWriter(sw);
        java.io.PrintWriter pw = new java.io.PrintWriter(bw);
        e.printStackTrace(pw);
        pw.close();
        String text = sw.getBuffer().toString();
        // Jump past the throwable
        text = text.substring(text.indexOf("at"));
        text = replace(text, "at ", "DEBUG_FRAME = ");
        return text;
}

Get a string containing the stack of the specified exception

 public static String xmlNameToJava(String name) 
{
        // protect ourselves from garbage
        if (name == null || name.length() == 0) {
            return name;
        }
        char[] nameArray = name.toCharArray();
        int nameLen = name.length();
        StringBuffer result = new StringBuffer(nameLen);
        boolean wordStart = false;
        // The mapping indicates to convert first character.
        int i = 0;
        while (i <  nameLen
                && (isPunctuation(nameArray[i])
                || !Character.isJavaIdentifierStart(nameArray[i]))) {
            i++;
        }
        if (i <  nameLen) {
            // Decapitalization code used to be here, but we use the
            // Introspector function now after we filter out all bad chars.
            result.append(nameArray[i]);
            //wordStart = !Character.isLetter(nameArray[i]);
            wordStart = !Character.isLetter(nameArray[i]) && nameArray[i] != "_".charAt(0);
        } else {
            // The identifier cannot be mapped strictly according to
            // JSR 101
            if (Character.isJavaIdentifierPart(nameArray[0])) {
                result.append("_").append(nameArray[0]);
            } else {
                // The XML identifier does not contain any characters
                // we can map to Java.  Using the length of the string
                // will make it somewhat unique.
                result.append("_").append(nameArray.length);
            }
        }
        // The mapping indicates to skip over
        // all characters that are not letters or
        // digits.  The first letter/digit
        // following a skipped character is
        // upper-cased.
        for (++i; i <  nameLen; ++i) {
            char c = nameArray[i];
            // if this is a bad char, skip it and remember to capitalize next
            // good character we encounter
            if (isPunctuation(c) || !Character.isJavaIdentifierPart(c)) {
                wordStart = true;
                continue;
            }
            if (wordStart && Character.isLowerCase(c)) {
                result.append(Character.toUpperCase(c));
            } else {
                result.append(c);
            }
            // If c is not a character, but is a legal Java
            // identifier character, capitalize the next character.
            // For example:  "22hi" becomes "22Hi"
            //wordStart = !Character.isLetter(c);
            wordStart = !Character.isLetter(c) && c != "_".charAt(0);
        }
        // covert back to a String
        String newName = result.toString();
        // check for Java keywords
        if (isJavaKeyword(newName)) {
            newName = makeNonJavaKeyword(newName);
        }
        return newName;
}

 public static String xmlNameToJavaIdentifier(String name) 
{
        String javaName = xmlNameToJava(name);
        // convert the first letter to lowercase
        if ((javaName != null) && (javaName.length()  > 0)) {
            javaName = javaName.substring(0, 1).toLowerCase() + javaName.substring(1);
        }
        return javaName;
}

converts an xml name to a java identifier