Java String Uncapitalize uncapitalize(final String str)

Description

Uncapitalizes a String changing the first letter to title case as per Character#toLowerCase(char) .

License

Apache License

Parameter

Parameter	Description
str	the String to uncapitalize, may be null

Return

the uncapitalized String, null if null String input

Declaration

public static String uncapitalize(final String str) 

Method Source Code

//package com.java2s;
//License from project: Apache License 

public class Main {
    /**//www.  ja  v  a2  s.com
     * <p>
     * Uncapitalizes a String changing the first letter to title case as per {@link Character#toLowerCase(char)}. No other
     * letters are changed.
     * </p>
     * <p>
     * A {@code null} input String returns {@code null}.
     * </p>
     * <p/>
     * <pre>
     * StringUtils.uncapitalize(null)  = null
     * StringUtils.uncapitalize("")    = ""
     * StringUtils.uncapitalize("Cat") = "cat"
     * StringUtils.uncapitalize("CAT") = "cAT"
     * </pre>
     *
     * @param str
     *         the String to uncapitalize, may be null
     * @return the uncapitalized String, {@code null} if null String input
     * @see #capitalize(String)
     */
    public static String uncapitalize(final String str) {

        int strLen;
        if (str == null || (strLen = str.length()) == 0) {
            return str;
        }

        char firstChar = str.charAt(0);
        if (Character.isLowerCase(firstChar)) {
            // already uncapitalized
            return str;
        }

        return new StringBuilder(strLen).append(Character.toLowerCase(firstChar)).append(str.substring(1))
                .toString();

    }

    /**
     * Gets a CharSequence length or {@code 0} if the CharSequence is {@code null}.
     *
     * @param cs
     *         a CharSequence or {@code null}
     * @return CharSequence length or {@code 0} if the CharSequence is {@code null}.
     */
    public static int length(CharSequence cs) {
        return cs == null ? 0 : cs.length();
    }

    /**
     * <p>
     * Converts the given value to lower case.
     * </p>
     * <p/>
     * <pre>
     * toLowerCase(null)    = null
     * toLowerCase("")      = ""
     * toLowerCase("aBc")   = "abc"
     * toLowerCase("abc")   = "abc"
     * toLowerCase(" ABC ") = "abc"
     * </pre>
     *
     * @param value
     *         The string value, may be null.
     * @return the given {@code value} converted to lower case or {@code null}.
     */
    public static String toLowerCase(String value) {
        if (value == null) {
            return null;
        }

        return value.trim().toLowerCase();
    }

    /**
     * <p>
     * Gets a substring from the specified String avoiding exceptions.
     * </p>
     * <p>
     * A negative start position can be used to start/end {@code n} characters from the end of the String.
     * </p>
     * <p>
     * The returned substring starts with the character in the {@code start} position and ends before the {@code end}
     * position. All position counting is zero-based -- i.e., to start at the beginning of the string use
     * {@code start = 0}. Negative start and end positions can be used to specify offsets relative to the end of the
     * String.
     * </p>
     * <p>
     * If {@code start} is not strictly to the left of {@code end}, "" is returned.
     * </p>
     * <p/>
     * <pre>
     * StringUtils.substring(null, *, *)    = null
     * StringUtils.substring("", * ,  *)    = "";
     * StringUtils.substring("abc", 0, 2)   = "ab"
     * StringUtils.substring("abc", 2, 0)   = ""
     * StringUtils.substring("abc", 2, 4)   = "c"
     * StringUtils.substring("abc", 4, 6)   = ""
     * StringUtils.substring("abc", 2, 2)   = ""
     * StringUtils.substring("abc", -2, -1) = "b"
     * StringUtils.substring("abc", -4, 2)  = "ab"
     * </pre>
     *
     * @param str
     *         the String to get the substring from, may be null
     * @param start
     *         the position to start from, negative means count back from the end of the String by this many characters
     * @param end
     *         the position to end at (exclusive), negative means count back from the end of the String by this many
     *         characters
     * @return substring from start position to end position, {@code null} if null String input
     */
    public static String substring(final String str, int start, int end) {
        if (str == null) {
            return null;
        }

        // handle negatives
        if (end < 0) {
            end = str.length() + end; // remember end is negative
        }
        if (start < 0) {
            start = str.length() + start; // remember start is negative
        }

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

        // if start is greater than end, return ""
        if (start > end) {
            return "";
        }

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

        return str.substring(start, end);
    }

    /**
     * Trims the given {@code value}.
     *
     * @param value
     *         The value to trim.
     * @return the given {@code value} trimmed or {@code null}.
     */
    public static String trim(String value) {
        if (value == null) {
            return null;
        }
        return value.trim();
    }
}

Related

1. uncapitalize(CharSequence cs)
2. uncapitalize(final CharSequence s)
3. uncapitalize(final CharSequence sequence)
4. uncapitalize(final String s)
5. uncapitalize(final String str)
6. uncapitalize(final String str)
7. unCapitalize(String data, int pos)
8. uncapitalize(String input)