public static String[] addStringToArray(String[] array,
    String str) 
{
		if (ObjectUtils.isEmpty(array)) {
			return new String[] {str};
		}
		String[] newArr = new String[array.length + 1];
		System.arraycopy(array, 0, newArr, 0, array.length);
		newArr[array.length] = str;
		return newArr;
}

Append the given String to the given String array, returning a new array consisting of the input array contents plus the given String.

 public static String applyRelativePath(String path,
    String relativePath) 
{
		int separatorIndex = path.lastIndexOf(FOLDER_SEPARATOR);
		if (separatorIndex != -1) {
			String newPath = path.substring(0, separatorIndex);
			if (!relativePath.startsWith(FOLDER_SEPARATOR)) {
				newPath += FOLDER_SEPARATOR;
			}
			return newPath + relativePath;
		}
		else {
			return relativePath;
		}
}

Apply the given relative path to the given path, assuming standard Java folder separation (i.e. "/" separators);

 public static String arrayToCommaDelimitedString(Object[] arr) 
{
		return arrayToDelimitedString(arr, ",");
}

Convenience method to return a String array as a CSV String. E.g. useful for toString() implementations.

 public static String arrayToDelimitedString(Object[] arr,
    String delim) 
{
		if (ObjectUtils.isEmpty(arr)) {
			return "";
		}
		StringBuffer sb = new StringBuffer();
		for (int i = 0; i <  arr.length; i++) {
			if (i  > 0) {
				sb.append(delim);
			}
			sb.append(arr[i]);
		}
		return sb.toString();
}

Convenience method to return a String array as a delimited (e.g. CSV) String. E.g. useful for toString() implementations.

 public static String capitalize(String str) 
{
		return changeFirstCharacterCase(str, true);
}

Capitalize a String, changing the first letter to upper case as per Character#toUpperCase(char) . No other letters are changed.

 public static String cleanPath(String path) 
{
		String pathToUse = replace(path, WINDOWS_FOLDER_SEPARATOR, FOLDER_SEPARATOR);
		// Strip prefix from path to analyze, to not treat it as part of the
		// first path element. This is necessary to correctly parse paths like
		// "file:core/../core/io/Resource.class", where the ".." should just
		// strip the first "core" directory while keeping the "file:" prefix.
		int prefixIndex = pathToUse.indexOf(":");
		String prefix = "";
		if (prefixIndex != -1) {
			prefix = pathToUse.substring(0, prefixIndex + 1);
			pathToUse = pathToUse.substring(prefixIndex + 1);
		}
		String[] pathArray = delimitedListToStringArray(pathToUse, FOLDER_SEPARATOR);
		List pathElements = new LinkedList();
		int tops = 0;
		for (int i = pathArray.length - 1; i  >= 0; i--) {
			if (CURRENT_PATH.equals(pathArray[i])) {
				// Points to current directory - drop it.
			}
			else if (TOP_PATH.equals(pathArray[i])) {
				// Registering top path found.
				tops++;
			}
			else {
				if (tops  > 0) {
					// Merging path element with corresponding to top path.
					tops--;
				}
				else {
					// Normal path element found.
					pathElements.add(0, pathArray[i]);
				}
			}
		}
		// Remaining top paths need to be retained.
		for (int i = 0; i <  tops; i++) {
			pathElements.add(0, TOP_PATH);
		}
		return prefix + collectionToDelimitedString(pathElements, FOLDER_SEPARATOR);
}

Normalize the path by suppressing sequences like "path/.." and inner simple dots.

The result is convenient for path comparison. For other uses, notice that Windows separators ("\") are replaced by simple slashes.

 public static String collectionToCommaDelimitedString(Collection coll) 
{
		return collectionToDelimitedString(coll, ",");
}

Convenience method to return a Collection as a CSV String. E.g. useful for toString() implementations.

 public static String collectionToDelimitedString(Collection coll,
    String delim) 
{
		return collectionToDelimitedString(coll, delim, "", "");
}

Convenience method to return a Collection as a delimited (e.g. CSV) String. E.g. useful for toString() implementations.

 public static String collectionToDelimitedString(Collection coll,
    String delim,
    String prefix,
    String suffix) 
{
		if (CollectionUtils.isEmpty(coll)) {
			return "";
		}
		StringBuffer sb = new StringBuffer();
		Iterator it = coll.iterator();
		while (it.hasNext()) {
			sb.append(prefix).append(it.next()).append(suffix);
			if (it.hasNext()) {
				sb.append(delim);
			}
		}
		return sb.toString();
}

Convenience method to return a Collection as a delimited (e.g. CSV) String. E.g. useful for toString() implementations.

 public static Set commaDelimitedListToSet(String str) 
{
		Set set = new TreeSet();
		String[] tokens = commaDelimitedListToStringArray(str);
		for (int i = 0; i <  tokens.length; i++) {
			set.add(tokens[i]);
		}
		return set;
}

Convenience method to convert a CSV string list to a set. Note that this will suppress duplicates.

 public static String[] commaDelimitedListToStringArray(String str) 
{
		return delimitedListToStringArray(str, ",");
}

Convert a CSV list into an array of Strings.

 public static String[] concatenateStringArrays(String[] array1,
    String[] array2) 
{
		if (ObjectUtils.isEmpty(array1)) {
			return array2;
		}
		if (ObjectUtils.isEmpty(array2)) {
			return array1;
		}
		String[] newArr = new String[array1.length + array2.length];
		System.arraycopy(array1, 0, newArr, 0, array1.length);
		System.arraycopy(array2, 0, newArr, array1.length, array2.length);
		return newArr;
}

Concatenate the given String arrays into one, with overlapping array elements included twice.

The order of elements in the original arrays is preserved.

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

Check whether the given CharSequence contains any whitespace characters.

 public static boolean containsWhitespace(String str) 
{
		return containsWhitespace((CharSequence) str);
}

Check whether the given String contains any whitespace characters.

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

Count the occurrences of the substring in string s.

 public static String delete(String inString,
    String pattern) 
{
		return replace(inString, pattern, "");
}

Delete all occurrences of the given substring.

 public static String deleteAny(String inString,
    String charsToDelete) 
{
		if (!hasLength(inString) || !hasLength(charsToDelete)) {
			return inString;
		}
		StringBuffer out = new StringBuffer();
		for (int i = 0; i <  inString.length(); i++) {
			char c = inString.charAt(i);
			if (charsToDelete.indexOf(c) == -1) {
				out.append(c);
			}
		}
		return out.toString();
}

Delete any character in a given String.

 public static String[] delimitedListToStringArray(String str,
    String delimiter) 
{
		return delimitedListToStringArray(str, delimiter, null);
}

Take a String which is a delimited list and convert it to a String array.

A single delimiter can consists of more than one character: It will still be considered as single delimiter string, rather than as bunch of potential delimiter characters - in contrast to tokenizeToStringArray.

 public static String[] delimitedListToStringArray(String str,
    String delimiter,
    String charsToDelete) 
{
		if (str == null) {
			return new String[0];
		}
		if (delimiter == null) {
			return new String[] {str};
		}
		List result = new ArrayList();
		if ("".equals(delimiter)) {
			for (int i = 0; i <  str.length(); i++) {
				result.add(deleteAny(str.substring(i, i + 1), charsToDelete));
			}
		}
		else {
			int pos = 0;
			int delPos = 0;
			while ((delPos = str.indexOf(delimiter, pos)) != -1) {
				result.add(deleteAny(str.substring(pos, delPos), charsToDelete));
				pos = delPos + delimiter.length();
			}
			if (str.length()  > 0 && pos < = str.length()) {
				// Add rest of String, but not in case of empty input.
				result.add(deleteAny(str.substring(pos), charsToDelete));
			}
		}
		return toStringArray(result);
}

Take a String which is a delimited list and convert it to a String array.

A single delimiter can consists of more than one character: It will still be considered as single delimiter string, rather than as bunch of potential delimiter characters - in contrast to tokenizeToStringArray.

 public static boolean endsWithIgnoreCase(String str,
    String suffix) 
{
		if (str == null || suffix == null) {
			return false;
		}
		if (str.endsWith(suffix)) {
			return true;
		}
		if (str.length() <  suffix.length()) {
			return false;
		}
		String lcStr = str.substring(str.length() - suffix.length()).toLowerCase();
		String lcSuffix = suffix.toLowerCase();
		return lcStr.equals(lcSuffix);
}

Test if the given String ends with the specified suffix, ignoring upper/lower case.

 public static String getFilename(String path) 
{
		if (path == null) {
			return null;
		}
		int separatorIndex = path.lastIndexOf(FOLDER_SEPARATOR);
		return (separatorIndex != -1 ? path.substring(separatorIndex + 1) : path);
}

Extract the filename from the given path, e.g. "mypath/myfile.txt" -> "myfile.txt".

 public static String getFilenameExtension(String path) 
{
		if (path == null) {
			return null;
		}
		int sepIndex = path.lastIndexOf(EXTENSION_SEPARATOR);
		return (sepIndex != -1 ? path.substring(sepIndex + 1) : null);
}

Extract the filename extension from the given path, e.g. "mypath/myfile.txt" -> "txt".

 public static boolean hasLength(CharSequence str) 
{
		return (str != null && str.length()  > 0);
}

Check that the given CharSequence is neither null nor of length 0. Note: Will return true for a CharSequence that purely consists of whitespace.

StringUtils.hasLength(null) = false
StringUtils.hasLength("") = false
StringUtils.hasLength(" ") = true
StringUtils.hasLength("Hello") = true

 public static boolean hasLength(String str) 
{
		return hasLength((CharSequence) str);
}

Check that the given String is neither null nor of length 0. Note: Will return true for a String that purely consists of whitespace.

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

Check whether the given CharSequence has actual text. More specifically, returns true if the string not null, its length is greater than 0, and it contains at least one non-whitespace character.

StringUtils.hasText(null) = false
StringUtils.hasText("") = false
StringUtils.hasText(" ") = false
StringUtils.hasText("12345") = true
StringUtils.hasText(" 12345 ") = true

 public static boolean hasText(String str) 
{
		return hasText((CharSequence) str);
}

Check whether the given String has actual text. More specifically, returns true if the string not null, its length is greater than 0, and it contains at least one non-whitespace character.

 public static String[] mergeStringArrays(String[] array1,
    String[] array2) 
{
		if (ObjectUtils.isEmpty(array1)) {
			return array2;
		}
		if (ObjectUtils.isEmpty(array2)) {
			return array1;
		}
		List result = new ArrayList();
		result.addAll(Arrays.asList(array1));
		for (int i = 0; i <  array2.length; i++) {
			String str = array2[i];
			if (!result.contains(str)) {
				result.add(str);
			}
		}
		return toStringArray(result);
}

Merge the given String arrays into one, with overlapping array elements only included once.

The order of elements in the original arrays is preserved (with the exception of overlapping elements, which are only included on their first occurence).

 public static Locale parseLocaleString(String localeString) 
{
		String[] parts = tokenizeToStringArray(localeString, "_ ", false, false);
		String language = (parts.length  > 0 ? parts[0] : "");
		String country = (parts.length  > 1 ? parts[1] : "");
		String variant = "";
		if (parts.length  >= 2) {
			// There is definitely a variant, and it is everything after the country
			// code sans the separator between the country code and the variant.
			int endIndexOfCountryCode = localeString.indexOf(country) + country.length();
			// Strip off any leading '_' and whitespace, what's left is the variant.
			variant = trimLeadingWhitespace(localeString.substring(endIndexOfCountryCode));
			if (variant.startsWith("_")) {
				variant = trimLeadingCharacter(variant, '_');
			}
		}
		return (language.length()  > 0 ? new Locale(language, country, variant) : null);
}

Parse the given localeString into a Locale .

This is the inverse operation of Locale's toString .

 public static boolean pathEquals(String path1,
    String path2) 
{
		return cleanPath(path1).equals(cleanPath(path2));
}

Compare two paths after normalization of them.

 public static String quote(String str) 
{
		return (str != null ? "'" + str + "'" : null);
}

Quote the given String with single quotes.

 public static Object quoteIfString(Object obj) 
{
		return (obj instanceof String ? quote((String) obj) : obj);
}

Turn the given Object into a String with single quotes if it is a String; keeping the Object as-is else.

 public static String[] removeDuplicateStrings(String[] array) 
{
		if (ObjectUtils.isEmpty(array)) {
			return array;
		}
		Set set = new TreeSet();
		for (int i = 0; i <  array.length; i++) {
			set.add(array[i]);
		}
		return toStringArray(set);
}

Remove duplicate Strings from the given array. Also sorts the array, as it uses a TreeSet.

 public static String replace(String inString,
    String oldPattern,
    String newPattern) 
{
		if (inString == null) {
			return null;
		}
		if (oldPattern == null || newPattern == null) {
			return inString;
		}
		StringBuffer sbuf = new StringBuffer();
		// output StringBuffer we'll build up
		int pos = 0; // our position in the old string
		int index = inString.indexOf(oldPattern);
		// the index of an occurrence we've found, or -1
		int patLen = oldPattern.length();
		while (index  >= 0) {
			sbuf.append(inString.substring(pos, index));
			sbuf.append(newPattern);
			pos = index + patLen;
			index = inString.indexOf(oldPattern, pos);
		}
		sbuf.append(inString.substring(pos));
		// remember to append any characters to the right of a match
		return sbuf.toString();
}

Replace all occurences of a substring within a string with another string.

 public static String[] sortStringArray(String[] array) 
{
		if (ObjectUtils.isEmpty(array)) {
			return new String[0];
		}
		Arrays.sort(array);
		return array;
}

Turn given source String array into sorted array.

 public static String[] split(String toSplit,
    String delimiter) 
{
		if (!hasLength(toSplit) || !hasLength(delimiter)) {
			return null;
		}
		int offset = toSplit.indexOf(delimiter);
		if (offset <  0) {
			return null;
		}
		String beforeDelimiter = toSplit.substring(0, offset);
		String afterDelimiter = toSplit.substring(offset + delimiter.length());
		return new String[] {beforeDelimiter, afterDelimiter};
}

Split a String at the first occurrence of the delimiter. Does not include the delimiter in the result.

 public static Properties splitArrayElementsIntoProperties(String[] array,
    String delimiter) 
{
		return splitArrayElementsIntoProperties(array, delimiter, null);
}

Take an array Strings and split each element based on the given delimiter. A Properties instance is then generated, with the left of the delimiter providing the key, and the right of the delimiter providing the value.

Will trim both the key and value before adding them to the Properties instance.

 public static Properties splitArrayElementsIntoProperties(String[] array,
    String delimiter,
    String charsToDelete) 
{
		if (ObjectUtils.isEmpty(array)) {
			return null;
		}
		Properties result = new Properties();
		for (int i = 0; i <  array.length; i++) {
			String element = array[i];
			if (charsToDelete != null) {
				element = deleteAny(array[i], charsToDelete);
			}
			String[] splittedElement = split(element, delimiter);
			if (splittedElement == null) {
				continue;
			}
			result.setProperty(splittedElement[0].trim(), splittedElement[1].trim());
		}
		return result;
}

Take an array Strings and split each element based on the given delimiter. A Properties instance is then generated, with the left of the delimiter providing the key, and the right of the delimiter providing the value.

Will trim both the key and value before adding them to the Properties instance.

 public static boolean startsWithIgnoreCase(String str,
    String prefix) 
{
		if (str == null || prefix == null) {
			return false;
		}
		if (str.startsWith(prefix)) {
			return true;
		}
		if (str.length() <  prefix.length()) {
			return false;
		}
		String lcStr = str.substring(0, prefix.length()).toLowerCase();
		String lcPrefix = prefix.toLowerCase();
		return lcStr.equals(lcPrefix);
}

Test if the given String starts with the specified prefix, ignoring upper/lower case.

 public static String stripFilenameExtension(String path) 
{
		if (path == null) {
			return null;
		}
		int sepIndex = path.lastIndexOf(EXTENSION_SEPARATOR);
		return (sepIndex != -1 ? path.substring(0, sepIndex) : path);
}

Strip the filename extension from the given path, e.g. "mypath/myfile.txt" -> "mypath/myfile".

 public static boolean substringMatch(CharSequence str,
    int index,
    CharSequence substring) 
{
		for (int j = 0; j <  substring.length(); j++) {
			int i = index + j;
			if (i  >= str.length() || str.charAt(i) != substring.charAt(j)) {
				return false;
			}
		}
		return true;
}

Test whether the given string matches the given substring at the given index.

 public static String[] toStringArray(Collection collection) 
{
		if (collection == null) {
			return null;
		}
		return (String[]) collection.toArray(new String[collection.size()]);
}

Copy the given Collection into a String array. The Collection must contain String elements only.

 public static String[] toStringArray(Enumeration enumeration) 
{
		if (enumeration == null) {
			return null;
		}
		List list = Collections.list(enumeration);
		return (String[]) list.toArray(new String[list.size()]);
}

Copy the given Enumeration into a String array. The Enumeration must contain String elements only.

 public static String[] tokenizeToStringArray(String str,
    String delimiters) 
{
		return tokenizeToStringArray(str, delimiters, true, true);
}

Tokenize the given String into a String array via a StringTokenizer. Trims tokens and omits empty tokens.

The given delimiters string is supposed to consist of any number of delimiter characters. Each of those characters can be used to separate tokens. A delimiter is always a single character; for multi-character delimiters, consider using delimitedListToStringArray

 public static String[] tokenizeToStringArray(String str,
    String delimiters,
    boolean trimTokens,
    boolean ignoreEmptyTokens) 
{
		if (str == null) {
			return null;
		}
		StringTokenizer st = new StringTokenizer(str, delimiters);
		List tokens = new ArrayList();
		while (st.hasMoreTokens()) {
			String token = st.nextToken();
			if (trimTokens) {
				token = token.trim();
			}
			if (!ignoreEmptyTokens || token.length()  > 0) {
				tokens.add(token);
			}
		}
		return toStringArray(tokens);
}

Tokenize the given String into a String array via a StringTokenizer.

The given delimiters string is supposed to consist of any number of delimiter characters. Each of those characters can be used to separate tokens. A delimiter is always a single character; for multi-character delimiters, consider using delimitedListToStringArray

 public static String trimAllWhitespace(String str) 
{
		if (!hasLength(str)) {
			return str;
		}
		StringBuffer buf = new StringBuffer(str);
		int index = 0;
		while (buf.length()  > index) {
			if (Character.isWhitespace(buf.charAt(index))) {
				buf.deleteCharAt(index);
			}
			else {
				index++;
			}
		}
		return buf.toString();
}

Trim all whitespace from the given String: leading, trailing, and inbetween characters.

 public static String[] trimArrayElements(String[] array) 
{
		if (ObjectUtils.isEmpty(array)) {
			return new String[0];
		}
		String[] result = new String[array.length];
		for (int i = 0; i <  array.length; i++) {
			String element = array[i];
			result[i] = (element != null ? element.trim() : null);
		}
		return result;
}

Trim the elements of the given String array, calling String.trim() on each of them.

 public static String trimLeadingCharacter(String str,
    char leadingCharacter) 
{
		if (!hasLength(str)) {
			return str;
		}
		StringBuffer buf = new StringBuffer(str);
		while (buf.length()  > 0 && buf.charAt(0) == leadingCharacter) {
			buf.deleteCharAt(0);
		}
		return buf.toString();
}

Trim all occurences of the supplied leading character from the given String.

 public static String trimLeadingWhitespace(String str) 
{
		if (!hasLength(str)) {
			return str;
		}
		StringBuffer buf = new StringBuffer(str);
		while (buf.length()  > 0 && Character.isWhitespace(buf.charAt(0))) {
			buf.deleteCharAt(0);
		}
		return buf.toString();
}

Trim leading whitespace from the given String.

 public static String trimTrailingCharacter(String str,
    char trailingCharacter) 
{
		if (!hasLength(str)) {
			return str;
		}
		StringBuffer buf = new StringBuffer(str);
		while (buf.length()  > 0 && buf.charAt(buf.length() - 1) == trailingCharacter) {
			buf.deleteCharAt(buf.length() - 1);
		}
		return buf.toString();
}

Trim all occurences of the supplied trailing character from the given String.

 public static String trimTrailingWhitespace(String str) 
{
		if (!hasLength(str)) {
			return str;
		}
		StringBuffer buf = new StringBuffer(str);
		while (buf.length()  > 0 && Character.isWhitespace(buf.charAt(buf.length() - 1))) {
			buf.deleteCharAt(buf.length() - 1);
		}
		return buf.toString();
}

Trim trailing whitespace from the given String.

 public static String trimWhitespace(String str) 
{
		if (!hasLength(str)) {
			return str;
		}
		StringBuffer buf = new StringBuffer(str);
		while (buf.length()  > 0 && Character.isWhitespace(buf.charAt(0))) {
			buf.deleteCharAt(0);
		}
		while (buf.length()  > 0 && Character.isWhitespace(buf.charAt(buf.length() - 1))) {
			buf.deleteCharAt(buf.length() - 1);
		}
		return buf.toString();
}

Trim leading and trailing whitespace from the given String.

 public static String uncapitalize(String str) 
{
		return changeFirstCharacterCase(str, false);
}

Uncapitalize a String, changing the first letter to lower case as per Character#toLowerCase(char) . No other letters are changed.

 public static String unqualify(String qualifiedName) 
{
		return unqualify(qualifiedName, '.');
}

Unqualify a string qualified by a '.' dot character. For example, "this.name.is.qualified", returns "qualified".

 public static String unqualify(String qualifiedName,
    char separator) 
{
		return qualifiedName.substring(qualifiedName.lastIndexOf(separator) + 1);
}

Unqualify a string qualified by a separator character. For example, "this:name:is:qualified" returns "qualified" if using a ':' separator.