/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.apache.commons.lang3;

import java.io.UnsupportedEncodingException;
import java.nio.charset.Charset;
import java.text.Normalizer;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;
import java.util.Objects;
import java.util.Set;
import java.util.StringJoiner;
import java.util.function.Supplier;
import java.util.regex.Pattern;

import net.lax1dude.eaglercraft.v1_8.HString;

import org.apache.commons.lang3.function.ToBooleanBiFunction;

/**
 * <p>
 * Operations on {@link java.lang.String} that are {@code null} safe.
 * </p>
 *
 * <ul>
 * <li><b>IsEmpty/IsBlank</b> - checks if a String contains text</li>
 * <li><b>Trim/Strip</b> - removes leading and trailing whitespace</li>
 * <li><b>Equals/Compare</b> - compares two strings in a null-safe manner</li>
 * <li><b>startsWith</b> - check if a String starts with a prefix in a null-safe
 * manner</li>
 * <li><b>endsWith</b> - check if a String ends with a suffix in a null-safe
 * manner</li>
 * <li><b>IndexOf/LastIndexOf/Contains</b> - null-safe index-of checks
 * <li><b>IndexOfAny/LastIndexOfAny/IndexOfAnyBut/LastIndexOfAnyBut</b> -
 * index-of any of a set of Strings</li>
 * <li><b>ContainsOnly/ContainsNone/ContainsAny</b> - checks if String contains
 * only/none/any of these characters</li>
 * <li><b>Substring/Left/Right/Mid</b> - null-safe substring extractions</li>
 * <li><b>SubstringBefore/SubstringAfter/SubstringBetween</b> - substring
 * extraction relative to other strings</li>
 * <li><b>Split/Join</b> - splits a String into an array of substrings and vice
 * versa</li>
 * <li><b>Remove/Delete</b> - removes part of a String</li>
 * <li><b>Replace/Overlay</b> - Searches a String and replaces one String with
 * another</li>
 * <li><b>Chomp/Chop</b> - removes the last part of a String</li>
 * <li><b>AppendIfMissing</b> - appends a suffix to the end of the String if not
 * present</li>
 * <li><b>PrependIfMissing</b> - prepends a prefix to the start of the String if
 * not present</li>
 * <li><b>LeftPad/RightPad/Center/Repeat</b> - pads a String</li>
 * <li><b>UpperCase/LowerCase/SwapCase/Capitalize/Uncapitalize</b> - changes the
 * case of a String</li>
 * <li><b>CountMatches</b> - counts the number of occurrences of one String in
 * another</li>
 * <li><b>IsAlpha/IsNumeric/IsWhitespace/IsAsciiPrintable</b> - checks the
 * characters in a String</li>
 * <li><b>DefaultString</b> - protects against a null input String</li>
 * <li><b>Rotate</b> - rotate (circular shift) a String</li>
 * <li><b>Reverse/ReverseDelimited</b> - reverses a String</li>
 * <li><b>Abbreviate</b> - abbreviates a string using ellipses or another given
 * String</li>
 * <li><b>Difference</b> - compares Strings and reports on their
 * differences</li>
 * <li><b>LevenshteinDistance</b> - the number of changes needed to change one
 * String into another</li>
 * </ul>
 *
 * <p>
 * The {@code StringUtils} class defines certain words related to String
 * handling.
 * </p>
 *
 * <ul>
 * <li>null - {@code null}</li>
 * <li>empty - a zero-length string ({@code ""})</li>
 * <li>space - the space character ({@code ' '}, char 32)</li>
 * <li>whitespace - the characters defined by
 * {@link Character#isWhitespace(char)}</li>
 * <li>trim - the characters &lt;= 32 as in {@link String#trim()}</li>
 * </ul>
 *
 * <p>
 * {@code StringUtils} handles {@code null} input Strings quietly. That is to
 * say that a {@code null} input will return {@code null}. Where a
 * {@code boolean} or {@code int} is being returned details vary by method.
 * </p>
 *
 * <p>
 * A side effect of the {@code null} handling is that a
 * {@code NullPointerException} should be considered a bug in
 * {@code StringUtils}.
 * </p>
 *
 * <p>
 * Methods in this class include sample code in their Javadoc comments to
 * explain their operation. The symbol {@code *} is used to indicate any input
 * including {@code null}.
 * </p>
 *
 * <p>
 * #ThreadSafe#
 * </p>
 * 
 * @see java.lang.String
 * @since 1.0
 */
//@Immutable
public class StringUtils {

	private static final int STRING_BUILDER_SIZE = 256;

	// Performance testing notes (JDK 1.4, Jul03, scolebourne)
	// Whitespace:
	// Character.isWhitespace() is faster than WHITESPACE.indexOf()
	// where WHITESPACE is a string of all whitespace characters
	//
	// Character access:
	// String.charAt(n) versus toCharArray(), then array[n]
	// String.charAt(n) is about 15% worse for a 10K string
	// They are about equal for a length 50 string
	// String.charAt(n) is about 4 times better for a length 3 string
	// String.charAt(n) is best bet overall
	//
	// Append:
	// String.concat about twice as fast as StringBuffer.append
	// (not sure who tested this)

	/**
	 * A String for a space character.
	 *
	 * @since 3.2
	 */
	public static final String SPACE = " ";

	/**
	 * The empty String {@code ""}.
	 * 
	 * @since 2.0
	 */
	public static final String EMPTY = "";

	/**
	 * A String for linefeed LF ("\n").
	 *
	 * @see <a href=
	 *      "http://docs.oracle.com/javase/specs/jls/se7/html/jls-3.html#jls-3.10.6">JLF:
	 *      Escape Sequences for Character and String Literals</a>
	 * @since 3.2
	 */
	public static final String LF = "\n";

	/**
	 * A String for carriage return CR ("\r").
	 *
	 * @see <a href=
	 *      "http://docs.oracle.com/javase/specs/jls/se7/html/jls-3.html#jls-3.10.6">JLF:
	 *      Escape Sequences for Character and String Literals</a>
	 * @since 3.2
	 */
	public static final String CR = "\r";

	/**
	 * Represents a failed index search.
	 * 
	 * @since 2.1
	 */
	public static final int INDEX_NOT_FOUND = -1;

	/**
	 * <p>
	 * The maximum size to which the padding constant(s) can expand.
	 * </p>
	 */
	private static final int PAD_LIMIT = 8192;

	/**
	 * Pattern used in {@link #stripAccents(String)}.
	 */
	private static final Pattern STRIP_ACCENTS_PATTERN = Pattern.compile("\\p{InCombiningDiacriticalMarks}+"); //$NON-NLS-1$

	/**
	 * <p>
	 * Abbreviates a String using ellipses. This will turn "Now is the time for all
	 * good men" into "Now is the time for..."
	 * </p>
	 *
	 * <p>
	 * Specifically:
	 * </p>
	 * <ul>
	 * <li>If the number of characters in {@code str} is less than or equal to
	 * {@code maxWidth}, return {@code str}.</li>
	 * <li>Else abbreviate it to {@code (substring(str, 0, max-3) + "...")}.</li>
	 * <li>If {@code maxWidth} is less than {@code 4}, throw an
	 * {@code IllegalArgumentException}.</li>
	 * <li>In no case will it return a String of length greater than
	 * {@code maxWidth}.</li>
	 * </ul>
	 *
	 * <pre>
	 * StringUtils.abbreviate(null, *)      = null
	 * StringUtils.abbreviate("", 4)        = ""
	 * StringUtils.abbreviate("abcdefg", 6) = "abc..."
	 * StringUtils.abbreviate("abcdefg", 7) = "abcdefg"
	 * StringUtils.abbreviate("abcdefg", 8) = "abcdefg"
	 * StringUtils.abbreviate("abcdefg", 4) = "a..."
	 * StringUtils.abbreviate("abcdefg", 3) = IllegalArgumentException
	 * </pre>
	 *
	 * @param str      the String to check, may be null
	 * @param maxWidth maximum length of result String, must be at least 4
	 * @return abbreviated String, {@code null} if null String input
	 * @throws IllegalArgumentException if the width is too small
	 * @since 2.0
	 */
	public static String abbreviate(final String str, final int maxWidth) {
		return abbreviate(str, "...", 0, maxWidth);
	}

	/**
	 * <p>
	 * Abbreviates a String using ellipses. This will turn "Now is the time for all
	 * good men" into "...is the time for..."
	 * </p>
	 *
	 * <p>
	 * Works like {@code abbreviate(String, int)}, but allows you to specify a "left
	 * edge" offset. Note that this left edge is not necessarily going to be the
	 * leftmost character in the result, or the first character following the
	 * ellipses, but it will appear somewhere in the result.
	 *
	 * <p>
	 * In no case will it return a String of length greater than {@code maxWidth}.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.abbreviate(null, *, *)                = null
	 * StringUtils.abbreviate("", 0, 4)                  = ""
	 * StringUtils.abbreviate("abcdefghijklmno", -1, 10) = "abcdefg..."
	 * StringUtils.abbreviate("abcdefghijklmno", 0, 10)  = "abcdefg..."
	 * StringUtils.abbreviate("abcdefghijklmno", 1, 10)  = "abcdefg..."
	 * StringUtils.abbreviate("abcdefghijklmno", 4, 10)  = "abcdefg..."
	 * StringUtils.abbreviate("abcdefghijklmno", 5, 10)  = "...fghi..."
	 * StringUtils.abbreviate("abcdefghijklmno", 6, 10)  = "...ghij..."
	 * StringUtils.abbreviate("abcdefghijklmno", 8, 10)  = "...ijklmno"
	 * StringUtils.abbreviate("abcdefghijklmno", 10, 10) = "...ijklmno"
	 * StringUtils.abbreviate("abcdefghijklmno", 12, 10) = "...ijklmno"
	 * StringUtils.abbreviate("abcdefghij", 0, 3)        = IllegalArgumentException
	 * StringUtils.abbreviate("abcdefghij", 5, 6)        = IllegalArgumentException
	 * </pre>
	 *
	 * @param str      the String to check, may be null
	 * @param offset   left edge of source String
	 * @param maxWidth maximum length of result String, must be at least 4
	 * @return abbreviated String, {@code null} if null String input
	 * @throws IllegalArgumentException if the width is too small
	 * @since 2.0
	 */
	public static String abbreviate(final String str, final int offset, final int maxWidth) {
		return abbreviate(str, "...", offset, maxWidth);
	}

	/**
	 * <p>
	 * Abbreviates a String using another given String as replacement marker. This
	 * will turn "Now is the time for all good men" into "Now is the time for..." if
	 * "..." was defined as the replacement marker.
	 * </p>
	 *
	 * <p>
	 * Specifically:
	 * </p>
	 * <ul>
	 * <li>If the number of characters in {@code str} is less than or equal to
	 * {@code maxWidth}, return {@code str}.</li>
	 * <li>Else abbreviate it to
	 * {@code (substring(str, 0, max-abbrevMarker.length) + abbrevMarker)}.</li>
	 * <li>If {@code maxWidth} is less than {@code abbrevMarker.length + 1}, throw
	 * an {@code IllegalArgumentException}.</li>
	 * <li>In no case will it return a String of length greater than
	 * {@code maxWidth}.</li>
	 * </ul>
	 *
	 * <pre>
	 * StringUtils.abbreviate(null, "...", *)      = null
	 * StringUtils.abbreviate("abcdefg", null, *)  = "abcdefg"
	 * StringUtils.abbreviate("", "...", 4)        = ""
	 * StringUtils.abbreviate("abcdefg", ".", 5)   = "abcd."
	 * StringUtils.abbreviate("abcdefg", ".", 7)   = "abcdefg"
	 * StringUtils.abbreviate("abcdefg", ".", 8)   = "abcdefg"
	 * StringUtils.abbreviate("abcdefg", "..", 4)  = "ab.."
	 * StringUtils.abbreviate("abcdefg", "..", 3)  = "a.."
	 * StringUtils.abbreviate("abcdefg", "..", 2)  = IllegalArgumentException
	 * StringUtils.abbreviate("abcdefg", "...", 3) = IllegalArgumentException
	 * </pre>
	 *
	 * @param str          the String to check, may be null
	 * @param abbrevMarker the String used as replacement marker
	 * @param maxWidth     maximum length of result String, must be at least
	 *                     {@code abbrevMarker.length + 1}
	 * @return abbreviated String, {@code null} if null String input
	 * @throws IllegalArgumentException if the width is too small
	 * @since 3.6
	 */
	public static String abbreviate(final String str, final String abbrevMarker, final int maxWidth) {
		return abbreviate(str, abbrevMarker, 0, maxWidth);
	}

	/**
	 * <p>
	 * Abbreviates a String using a given replacement marker. This will turn "Now is
	 * the time for all good men" into "...is the time for..." if "..." was defined
	 * as the replacement marker.
	 * </p>
	 *
	 * <p>
	 * Works like {@code abbreviate(String, String, int)}, but allows you to specify
	 * a "left edge" offset. Note that this left edge is not necessarily going to be
	 * the leftmost character in the result, or the first character following the
	 * replacement marker, but it will appear somewhere in the result.
	 *
	 * <p>
	 * In no case will it return a String of length greater than {@code maxWidth}.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.abbreviate(null, null, *, *)                 = null
	 * StringUtils.abbreviate("abcdefghijklmno", null, *, *)    = "abcdefghijklmno"
	 * StringUtils.abbreviate("", "...", 0, 4)                  = ""
	 * StringUtils.abbreviate("abcdefghijklmno", "---", -1, 10) = "abcdefg---"
	 * StringUtils.abbreviate("abcdefghijklmno", ",", 0, 10)    = "abcdefghi,"
	 * StringUtils.abbreviate("abcdefghijklmno", ",", 1, 10)    = "abcdefghi,"
	 * StringUtils.abbreviate("abcdefghijklmno", ",", 2, 10)    = "abcdefghi,"
	 * StringUtils.abbreviate("abcdefghijklmno", "::", 4, 10)   = "::efghij::"
	 * StringUtils.abbreviate("abcdefghijklmno", "...", 6, 10)  = "...ghij..."
	 * StringUtils.abbreviate("abcdefghijklmno", "*", 9, 10)    = "*ghijklmno"
	 * StringUtils.abbreviate("abcdefghijklmno", "'", 10, 10)   = "'ghijklmno"
	 * StringUtils.abbreviate("abcdefghijklmno", "!", 12, 10)   = "!ghijklmno"
	 * StringUtils.abbreviate("abcdefghij", "abra", 0, 4)       = IllegalArgumentException
	 * StringUtils.abbreviate("abcdefghij", "...", 5, 6)        = IllegalArgumentException
	 * </pre>
	 *
	 * @param str          the String to check, may be null
	 * @param abbrevMarker the String used as replacement marker
	 * @param offset       left edge of source String
	 * @param maxWidth     maximum length of result String, must be at least 4
	 * @return abbreviated String, {@code null} if null String input
	 * @throws IllegalArgumentException if the width is too small
	 * @since 3.6
	 */
	public static String abbreviate(final String str, final String abbrevMarker, int offset, final int maxWidth) {
		if (isNotEmpty(str) && EMPTY.equals(abbrevMarker) && maxWidth > 0) {
			return substring(str, 0, maxWidth);
		} else if (isAnyEmpty(str, abbrevMarker)) {
			return str;
		}
		final int abbrevMarkerLength = abbrevMarker.length();
		final int minAbbrevWidth = abbrevMarkerLength + 1;
		final int minAbbrevWidthOffset = abbrevMarkerLength + abbrevMarkerLength + 1;

		if (maxWidth < minAbbrevWidth) {
			throw new IllegalArgumentException(HString.format("Minimum abbreviation width is %d", minAbbrevWidth));
		}
		final int strLen = str.length();
		if (strLen <= maxWidth) {
			return str;
		}
		if (offset > strLen) {
			offset = strLen;
		}
		if (strLen - offset < maxWidth - abbrevMarkerLength) {
			offset = strLen - (maxWidth - abbrevMarkerLength);
		}
		if (offset <= abbrevMarkerLength + 1) {
			return str.substring(0, maxWidth - abbrevMarkerLength) + abbrevMarker;
		}
		if (maxWidth < minAbbrevWidthOffset) {
			throw new IllegalArgumentException(
					HString.format("Minimum abbreviation width with offset is %d", minAbbrevWidthOffset));
		}
		if (offset + maxWidth - abbrevMarkerLength < strLen) {
			return abbrevMarker + abbreviate(str.substring(offset), abbrevMarker, maxWidth - abbrevMarkerLength);
		}
		return abbrevMarker + str.substring(strLen - (maxWidth - abbrevMarkerLength));
	}

	/**
	 * <p>
	 * Abbreviates a String to the length passed, replacing the middle characters
	 * with the supplied replacement String.
	 * </p>
	 *
	 * <p>
	 * This abbreviation only occurs if the following criteria is met:
	 * </p>
	 * <ul>
	 * <li>Neither the String for abbreviation nor the replacement String are null
	 * or empty</li>
	 * <li>The length to truncate to is less than the length of the supplied
	 * String</li>
	 * <li>The length to truncate to is greater than 0</li>
	 * <li>The abbreviated String will have enough room for the length supplied
	 * replacement String and the first and last characters of the supplied String
	 * for abbreviation</li>
	 * </ul>
	 * <p>
	 * Otherwise, the returned String will be the same as the supplied String for
	 * abbreviation.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.abbreviateMiddle(null, null, 0)      = null
	 * StringUtils.abbreviateMiddle("abc", null, 0)      = "abc"
	 * StringUtils.abbreviateMiddle("abc", ".", 0)      = "abc"
	 * StringUtils.abbreviateMiddle("abc", ".", 3)      = "abc"
	 * StringUtils.abbreviateMiddle("abcdef", ".", 4)     = "ab.f"
	 * </pre>
	 *
	 * @param str    the String to abbreviate, may be null
	 * @param middle the String to replace the middle characters with, may be null
	 * @param length the length to abbreviate {@code str} to.
	 * @return the abbreviated String if the above criteria is met, or the original
	 *         String supplied for abbreviation.
	 * @since 2.5
	 */
	public static String abbreviateMiddle(final String str, final String middle, final int length) {
		if (isAnyEmpty(str, middle) || length >= str.length() || length < middle.length() + 2) {
			return str;
		}

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

		return str.substring(0, startOffset) + middle + str.substring(endOffset);
	}

	/**
	 * <p>
	 * Capitalizes a String changing the first character to title case as per
	 * {@link Character#toTitleCase(int)}. No other characters are changed.
	 * </p>
	 *
	 * <p>
	 * For a word based algorithm, see
	 * {@link org.apache.commons.lang3.text.WordUtils#capitalize(String)}. A
	 * {@code null} input String returns {@code null}.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.capitalize(null)  = null
	 * StringUtils.capitalize("")    = ""
	 * StringUtils.capitalize("cat") = "Cat"
	 * StringUtils.capitalize("cAt") = "CAt"
	 * StringUtils.capitalize("'cat'") = "'cat'"
	 * </pre>
	 *
	 * @param str the String to capitalize, may be null
	 * @return the capitalized String, {@code null} if null String input
	 * @see org.apache.commons.lang3.text.WordUtils#capitalize(String)
	 * @see #uncapitalize(String)
	 * @since 2.0
	 */
	public static String capitalize(final String str) {
		final int strLen = length(str);
		if (strLen == 0) {
			return str;
		}

		final int firstCodepoint = str.codePointAt(0);
		final int newCodePoint = Character.toTitleCase(firstCodepoint);
		if (firstCodepoint == newCodePoint) {
			// already capitalized
			return str;
		}

		final int[] newCodePoints = new int[strLen]; // cannot be longer than the char array
		int outOffset = 0;
		newCodePoints[outOffset++] = newCodePoint; // copy the first codepoint
		for (int inOffset = Character.charCount(firstCodepoint); inOffset < strLen;) {
			final int codepoint = str.codePointAt(inOffset);
			newCodePoints[outOffset++] = codepoint; // copy the remaining ones
			inOffset += Character.charCount(codepoint);
		}
		return new String(newCodePoints, 0, outOffset);
	}

	/**
	 * <p>
	 * Centers a String in a larger String of size {@code size} using the space
	 * character (' ').
	 * </p>
	 *
	 * <p>
	 * If the size is less than the String length, the original String is returned.
	 * A {@code null} String returns {@code null}. A negative size is treated as
	 * zero.
	 * </p>
	 *
	 * <p>
	 * Equivalent to {@code center(str, size, " ")}.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.center(null, *)   = null
	 * StringUtils.center("", 4)     = "    "
	 * StringUtils.center("ab", -1)  = "ab"
	 * StringUtils.center("ab", 4)   = " ab "
	 * StringUtils.center("abcd", 2) = "abcd"
	 * StringUtils.center("a", 4)    = " a  "
	 * </pre>
	 *
	 * @param str  the String to center, may be null
	 * @param size the int size of new String, negative treated as zero
	 * @return centered String, {@code null} if null String input
	 */
	public static String center(final String str, final int size) {
		return center(str, size, ' ');
	}

	/**
	 * <p>
	 * Centers a String in a larger String of size {@code size}. Uses a supplied
	 * character as the value to pad the String with.
	 * </p>
	 *
	 * <p>
	 * If the size is less than the String length, the String is returned. A
	 * {@code null} String returns {@code null}. A negative size is treated as zero.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.center(null, *, *)     = null
	 * StringUtils.center("", 4, ' ')     = "    "
	 * StringUtils.center("ab", -1, ' ')  = "ab"
	 * StringUtils.center("ab", 4, ' ')   = " ab "
	 * StringUtils.center("abcd", 2, ' ') = "abcd"
	 * StringUtils.center("a", 4, ' ')    = " a  "
	 * StringUtils.center("a", 4, 'y')    = "yayy"
	 * </pre>
	 *
	 * @param str     the String to center, may be null
	 * @param size    the int size of new String, negative treated as zero
	 * @param padChar the character to pad the new String with
	 * @return centered String, {@code null} if null String input
	 * @since 2.0
	 */
	public static String center(String str, final int size, final char padChar) {
		if (str == null || size <= 0) {
			return str;
		}
		final int strLen = str.length();
		final int pads = size - strLen;
		if (pads <= 0) {
			return str;
		}
		str = leftPad(str, strLen + pads / 2, padChar);
		str = rightPad(str, size, padChar);
		return str;
	}

	/**
	 * <p>
	 * Centers a String in a larger String of size {@code size}. Uses a supplied
	 * String as the value to pad the String with.
	 * </p>
	 *
	 * <p>
	 * If the size is less than the String length, the String is returned. A
	 * {@code null} String returns {@code null}. A negative size is treated as zero.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.center(null, *, *)     = null
	 * StringUtils.center("", 4, " ")     = "    "
	 * StringUtils.center("ab", -1, " ")  = "ab"
	 * StringUtils.center("ab", 4, " ")   = " ab "
	 * StringUtils.center("abcd", 2, " ") = "abcd"
	 * StringUtils.center("a", 4, " ")    = " a  "
	 * StringUtils.center("a", 4, "yz")   = "yayz"
	 * StringUtils.center("abc", 7, null) = "  abc  "
	 * StringUtils.center("abc", 7, "")   = "  abc  "
	 * </pre>
	 *
	 * @param str    the String to center, may be null
	 * @param size   the int size of new String, negative treated as zero
	 * @param padStr the String to pad the new String with, must not be null or
	 *               empty
	 * @return centered String, {@code null} if null String input
	 * @throws IllegalArgumentException if padStr is {@code null} or empty
	 */
	public static String center(String str, final int size, String padStr) {
		if (str == null || size <= 0) {
			return str;
		}
		if (isEmpty(padStr)) {
			padStr = SPACE;
		}
		final int strLen = str.length();
		final int pads = size - strLen;
		if (pads <= 0) {
			return str;
		}
		str = leftPad(str, strLen + pads / 2, padStr);
		str = rightPad(str, size, padStr);
		return str;
	}

	/**
	 * <p>
	 * Removes one newline from end of a String if it's there, otherwise leave it
	 * alone. A newline is &quot;{@code \n}&quot;, &quot;{@code \r}&quot;, or
	 * &quot;{@code \r\n}&quot;.
	 * </p>
	 *
	 * <p>
	 * NOTE: This method changed in 2.0. It now more closely matches Perl chomp.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.chomp(null)          = null
	 * StringUtils.chomp("")            = ""
	 * StringUtils.chomp("abc \r")      = "abc "
	 * StringUtils.chomp("abc\n")       = "abc"
	 * StringUtils.chomp("abc\r\n")     = "abc"
	 * StringUtils.chomp("abc\r\n\r\n") = "abc\r\n"
	 * StringUtils.chomp("abc\n\r")     = "abc\n"
	 * StringUtils.chomp("abc\n\rabc")  = "abc\n\rabc"
	 * StringUtils.chomp("\r")          = ""
	 * StringUtils.chomp("\n")          = ""
	 * StringUtils.chomp("\r\n")        = ""
	 * </pre>
	 *
	 * @param str the String to chomp a newline from, may be null
	 * @return String without newline, {@code null} if null String input
	 */
	public static String chomp(final String str) {
		if (isEmpty(str)) {
			return str;
		}

		if (str.length() == 1) {
			final char ch = str.charAt(0);
			if (ch == CharUtils.CR || ch == CharUtils.LF) {
				return EMPTY;
			}
			return str;
		}

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

		if (last == CharUtils.LF) {
			if (str.charAt(lastIdx - 1) == CharUtils.CR) {
				lastIdx--;
			}
		} else if (last != CharUtils.CR) {
			lastIdx++;
		}
		return str.substring(0, lastIdx);
	}

	/**
	 * <p>
	 * Removes {@code separator} from the end of {@code str} if it's there,
	 * otherwise leave it alone.
	 * </p>
	 *
	 * <p>
	 * NOTE: This method changed in version 2.0. It now more closely matches Perl
	 * chomp. For the previous behavior, use
	 * {@link #substringBeforeLast(String, String)}. This method uses
	 * {@link String#endsWith(String)}.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.chomp(null, *)         = null
	 * StringUtils.chomp("", *)           = ""
	 * StringUtils.chomp("foobar", "bar") = "foo"
	 * StringUtils.chomp("foobar", "baz") = "foobar"
	 * StringUtils.chomp("foo", "foo")    = ""
	 * StringUtils.chomp("foo ", "foo")   = "foo "
	 * StringUtils.chomp(" foo", "foo")   = " "
	 * StringUtils.chomp("foo", "foooo")  = "foo"
	 * StringUtils.chomp("foo", "")       = "foo"
	 * StringUtils.chomp("foo", null)     = "foo"
	 * </pre>
	 *
	 * @param str       the String to chomp from, may be null
	 * @param separator separator String, may be null
	 * @return String without trailing separator, {@code null} if null String input
	 * @deprecated This feature will be removed in Lang 4.0, use
	 *             {@link StringUtils#removeEnd(String, String)} instead
	 */
	@Deprecated
	public static String chomp(final String str, final String separator) {
		return removeEnd(str, separator);
	}

	/**
	 * <p>
	 * Remove the last character from a String.
	 * </p>
	 *
	 * <p>
	 * If the String ends in {@code \r\n}, then remove both of them.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.chop(null)          = null
	 * StringUtils.chop("")            = ""
	 * StringUtils.chop("abc \r")      = "abc "
	 * StringUtils.chop("abc\n")       = "abc"
	 * StringUtils.chop("abc\r\n")     = "abc"
	 * StringUtils.chop("abc")         = "ab"
	 * StringUtils.chop("abc\nabc")    = "abc\nab"
	 * StringUtils.chop("a")           = ""
	 * StringUtils.chop("\r")          = ""
	 * StringUtils.chop("\n")          = ""
	 * StringUtils.chop("\r\n")        = ""
	 * </pre>
	 *
	 * @param str the String to chop last character from, may be null
	 * @return String without last character, {@code null} if null String input
	 */
	public static String chop(final String str) {
		if (str == null) {
			return null;
		}
		final int strLen = str.length();
		if (strLen < 2) {
			return EMPTY;
		}
		final int lastIdx = strLen - 1;
		final String ret = str.substring(0, lastIdx);
		final char last = str.charAt(lastIdx);
		if (last == CharUtils.LF && ret.charAt(lastIdx - 1) == CharUtils.CR) {
			return ret.substring(0, lastIdx - 1);
		}
		return ret;
	}

	/**
	 * <p>
	 * Compare two Strings lexicographically, as per
	 * {@link String#compareTo(String)}, returning :
	 * </p>
	 * <ul>
	 * <li>{@code int = 0}, if {@code str1} is equal to {@code str2} (or both
	 * {@code null})</li>
	 * <li>{@code int < 0}, if {@code str1} is less than {@code str2}</li>
	 * <li>{@code int > 0}, if {@code str1} is greater than {@code str2}</li>
	 * </ul>
	 *
	 * <p>
	 * This is a {@code null} safe version of :
	 * </p>
	 * <blockquote>
	 * 
	 * <pre>
	 * str1.compareTo(str2)
	 * </pre>
	 * 
	 * </blockquote>
	 *
	 * <p>
	 * {@code null} value is considered less than non-{@code null} value. Two
	 * {@code null} references are considered equal.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.compare(null, null)   = 0
	 * StringUtils.compare(null , "a")   &lt; 0
	 * StringUtils.compare("a", null)    &gt; 0
	 * StringUtils.compare("abc", "abc") = 0
	 * StringUtils.compare("a", "b")     &lt; 0
	 * StringUtils.compare("b", "a")     &gt; 0
	 * StringUtils.compare("a", "B")     &gt; 0
	 * StringUtils.compare("ab", "abc")  &lt; 0
	 * </pre>
	 *
	 * @see #compare(String, String, boolean)
	 * @see String#compareTo(String)
	 * @param str1 the String to compare from
	 * @param str2 the String to compare to
	 * @return &lt; 0, 0, &gt; 0, if {@code str1} is respectively less, equal or
	 *         greater than {@code str2}
	 * @since 3.5
	 */
	public static int compare(final String str1, final String str2) {
		return compare(str1, str2, true);
	}

	/**
	 * <p>
	 * Compare two Strings lexicographically, as per
	 * {@link String#compareTo(String)}, returning :
	 * </p>
	 * <ul>
	 * <li>{@code int = 0}, if {@code str1} is equal to {@code str2} (or both
	 * {@code null})</li>
	 * <li>{@code int < 0}, if {@code str1} is less than {@code str2}</li>
	 * <li>{@code int > 0}, if {@code str1} is greater than {@code str2}</li>
	 * </ul>
	 *
	 * <p>
	 * This is a {@code null} safe version of :
	 * </p>
	 * <blockquote>
	 * 
	 * <pre>
	 * str1.compareTo(str2)
	 * </pre>
	 * 
	 * </blockquote>
	 *
	 * <p>
	 * {@code null} inputs are handled according to the {@code nullIsLess}
	 * parameter. Two {@code null} references are considered equal.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.compare(null, null, *)     = 0
	 * StringUtils.compare(null , "a", true)  &lt; 0
	 * StringUtils.compare(null , "a", false) &gt; 0
	 * StringUtils.compare("a", null, true)   &gt; 0
	 * StringUtils.compare("a", null, false)  &lt; 0
	 * StringUtils.compare("abc", "abc", *)   = 0
	 * StringUtils.compare("a", "b", *)       &lt; 0
	 * StringUtils.compare("b", "a", *)       &gt; 0
	 * StringUtils.compare("a", "B", *)       &gt; 0
	 * StringUtils.compare("ab", "abc", *)    &lt; 0
	 * </pre>
	 *
	 * @see String#compareTo(String)
	 * @param str1       the String to compare from
	 * @param str2       the String to compare to
	 * @param nullIsLess whether consider {@code null} value less than
	 *                   non-{@code null} value
	 * @return &lt; 0, 0, &gt; 0, if {@code str1} is respectively less, equal ou
	 *         greater than {@code str2}
	 * @since 3.5
	 */
	public static int compare(final String str1, final String str2, final boolean nullIsLess) {
		if (str1 == str2) { // NOSONARLINT this intentionally uses == to allow for both null
			return 0;
		}
		if (str1 == null) {
			return nullIsLess ? -1 : 1;
		}
		if (str2 == null) {
			return nullIsLess ? 1 : -1;
		}
		return str1.compareTo(str2);
	}

	/**
	 * <p>
	 * Compare two Strings lexicographically, ignoring case differences, as per
	 * {@link String#compareToIgnoreCase(String)}, returning :
	 * </p>
	 * <ul>
	 * <li>{@code int = 0}, if {@code str1} is equal to {@code str2} (or both
	 * {@code null})</li>
	 * <li>{@code int < 0}, if {@code str1} is less than {@code str2}</li>
	 * <li>{@code int > 0}, if {@code str1} is greater than {@code str2}</li>
	 * </ul>
	 *
	 * <p>
	 * This is a {@code null} safe version of :
	 * </p>
	 * <blockquote>
	 * 
	 * <pre>
	 * str1.compareToIgnoreCase(str2)
	 * </pre>
	 * 
	 * </blockquote>
	 *
	 * <p>
	 * {@code null} value is considered less than non-{@code null} value. Two
	 * {@code null} references are considered equal. Comparison is case insensitive.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.compareIgnoreCase(null, null)   = 0
	 * StringUtils.compareIgnoreCase(null , "a")   &lt; 0
	 * StringUtils.compareIgnoreCase("a", null)    &gt; 0
	 * StringUtils.compareIgnoreCase("abc", "abc") = 0
	 * StringUtils.compareIgnoreCase("abc", "ABC") = 0
	 * StringUtils.compareIgnoreCase("a", "b")     &lt; 0
	 * StringUtils.compareIgnoreCase("b", "a")     &gt; 0
	 * StringUtils.compareIgnoreCase("a", "B")     &lt; 0
	 * StringUtils.compareIgnoreCase("A", "b")     &lt; 0
	 * StringUtils.compareIgnoreCase("ab", "ABC")  &lt; 0
	 * </pre>
	 *
	 * @see #compareIgnoreCase(String, String, boolean)
	 * @see String#compareToIgnoreCase(String)
	 * @param str1 the String to compare from
	 * @param str2 the String to compare to
	 * @return &lt; 0, 0, &gt; 0, if {@code str1} is respectively less, equal ou
	 *         greater than {@code str2}, ignoring case differences.
	 * @since 3.5
	 */
	public static int compareIgnoreCase(final String str1, final String str2) {
		return compareIgnoreCase(str1, str2, true);
	}

	/**
	 * <p>
	 * Compare two Strings lexicographically, ignoring case differences, as per
	 * {@link String#compareToIgnoreCase(String)}, returning :
	 * </p>
	 * <ul>
	 * <li>{@code int = 0}, if {@code str1} is equal to {@code str2} (or both
	 * {@code null})</li>
	 * <li>{@code int < 0}, if {@code str1} is less than {@code str2}</li>
	 * <li>{@code int > 0}, if {@code str1} is greater than {@code str2}</li>
	 * </ul>
	 *
	 * <p>
	 * This is a {@code null} safe version of :
	 * </p>
	 * <blockquote>
	 * 
	 * <pre>
	 * str1.compareToIgnoreCase(str2)
	 * </pre>
	 * 
	 * </blockquote>
	 *
	 * <p>
	 * {@code null} inputs are handled according to the {@code nullIsLess}
	 * parameter. Two {@code null} references are considered equal. Comparison is
	 * case insensitive.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.compareIgnoreCase(null, null, *)     = 0
	 * StringUtils.compareIgnoreCase(null , "a", true)  &lt; 0
	 * StringUtils.compareIgnoreCase(null , "a", false) &gt; 0
	 * StringUtils.compareIgnoreCase("a", null, true)   &gt; 0
	 * StringUtils.compareIgnoreCase("a", null, false)  &lt; 0
	 * StringUtils.compareIgnoreCase("abc", "abc", *)   = 0
	 * StringUtils.compareIgnoreCase("abc", "ABC", *)   = 0
	 * StringUtils.compareIgnoreCase("a", "b", *)       &lt; 0
	 * StringUtils.compareIgnoreCase("b", "a", *)       &gt; 0
	 * StringUtils.compareIgnoreCase("a", "B", *)       &lt; 0
	 * StringUtils.compareIgnoreCase("A", "b", *)       &lt; 0
	 * StringUtils.compareIgnoreCase("ab", "abc", *)    &lt; 0
	 * </pre>
	 *
	 * @see String#compareToIgnoreCase(String)
	 * @param str1       the String to compare from
	 * @param str2       the String to compare to
	 * @param nullIsLess whether consider {@code null} value less than
	 *                   non-{@code null} value
	 * @return &lt; 0, 0, &gt; 0, if {@code str1} is respectively less, equal ou
	 *         greater than {@code str2}, ignoring case differences.
	 * @since 3.5
	 */
	public static int compareIgnoreCase(final String str1, final String str2, final boolean nullIsLess) {
		if (str1 == str2) { // NOSONARLINT this intentionally uses == to allow for both null
			return 0;
		}
		if (str1 == null) {
			return nullIsLess ? -1 : 1;
		}
		if (str2 == null) {
			return nullIsLess ? 1 : -1;
		}
		return str1.compareToIgnoreCase(str2);
	}

	/**
	 * <p>
	 * Checks if CharSequence contains a search CharSequence, handling {@code null}.
	 * This method uses {@link String#indexOf(String)} if possible.
	 * </p>
	 *
	 * <p>
	 * A {@code null} CharSequence will return {@code false}.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.contains(null, *)     = false
	 * StringUtils.contains(*, null)     = false
	 * StringUtils.contains("", "")      = true
	 * StringUtils.contains("abc", "")   = true
	 * StringUtils.contains("abc", "a")  = true
	 * StringUtils.contains("abc", "z")  = false
	 * </pre>
	 *
	 * @param seq       the CharSequence to check, may be null
	 * @param searchSeq the CharSequence to find, may be null
	 * @return true if the CharSequence contains the search CharSequence, false if
	 *         not or {@code null} string input
	 * @since 2.0
	 * @since 3.0 Changed signature from contains(String, String) to
	 *        contains(CharSequence, CharSequence)
	 */
	public static boolean contains(final CharSequence seq, final CharSequence searchSeq) {
		if (seq == null || searchSeq == null) {
			return false;
		}
		return CharSequenceUtils.indexOf(seq, searchSeq, 0) >= 0;
	}

	/**
	 * <p>
	 * Checks if CharSequence contains a search character, handling {@code null}.
	 * This method uses {@link String#indexOf(int)} if possible.
	 * </p>
	 *
	 * <p>
	 * A {@code null} or empty ("") CharSequence will return {@code false}.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.contains(null, *)    = false
	 * StringUtils.contains("", *)      = false
	 * StringUtils.contains("abc", 'a') = true
	 * StringUtils.contains("abc", 'z') = false
	 * </pre>
	 *
	 * @param seq        the CharSequence to check, may be null
	 * @param searchChar the character to find
	 * @return true if the CharSequence contains the search character, false if not
	 *         or {@code null} string input
	 * @since 2.0
	 * @since 3.0 Changed signature from contains(String, int) to
	 *        contains(CharSequence, int)
	 */
	public static boolean contains(final CharSequence seq, final int searchChar) {
		if (isEmpty(seq)) {
			return false;
		}
		return CharSequenceUtils.indexOf(seq, searchChar, 0) >= 0;
	}

	/**
	 * <p>
	 * Checks if the CharSequence contains any character in the given set of
	 * characters.
	 * </p>
	 *
	 * <p>
	 * A {@code null} CharSequence will return {@code false}. A {@code null} or zero
	 * length search array will return {@code false}.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.containsAny(null, *)                  = false
	 * StringUtils.containsAny("", *)                    = false
	 * StringUtils.containsAny(*, null)                  = false
	 * StringUtils.containsAny(*, [])                    = false
	 * StringUtils.containsAny("zzabyycdxx", ['z', 'a']) = true
	 * StringUtils.containsAny("zzabyycdxx", ['b', 'y']) = true
	 * StringUtils.containsAny("zzabyycdxx", ['z', 'y']) = true
	 * StringUtils.containsAny("aba", ['z'])             = false
	 * </pre>
	 *
	 * @param cs          the CharSequence to check, may be null
	 * @param searchChars the chars to search for, may be null
	 * @return the {@code true} if any of the chars are found, {@code false} if no
	 *         match or null input
	 * @since 2.4
	 * @since 3.0 Changed signature from containsAny(String, char[]) to
	 *        containsAny(CharSequence, char...)
	 */
	public static boolean containsAny(final CharSequence cs, final char... searchChars) {
		if (isEmpty(cs) || searchChars.length == 0) {
			return false;
		}
		final int csLength = cs.length();
		final int searchLength = searchChars.length;
		final int csLast = csLength - 1;
		final int searchLast = searchLength - 1;
		for (int i = 0; i < csLength; i++) {
			final char ch = cs.charAt(i);
			for (int j = 0; j < searchLength; j++) {
				if (searchChars[j] == ch) {
					if (Character.isHighSurrogate(ch)) {
						if (j == searchLast) {
							// missing low surrogate, fine, like String.indexOf(String)
							return true;
						}
						if (i < csLast && searchChars[j + 1] == cs.charAt(i + 1)) {
							return true;
						}
					} else {
						// ch is in the Basic Multilingual Plane
						return true;
					}
				}
			}
		}
		return false;
	}

	/**
	 * <p>
	 * Checks if the CharSequence contains any character in the given set of
	 * characters.
	 * </p>
	 *
	 * <p>
	 * A {@code null} CharSequence will return {@code false}. A {@code null} search
	 * CharSequence will return {@code false}.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.containsAny(null, *)               = false
	 * StringUtils.containsAny("", *)                 = false
	 * StringUtils.containsAny(*, null)               = false
	 * StringUtils.containsAny(*, "")                 = false
	 * StringUtils.containsAny("zzabyycdxx", "za")    = true
	 * StringUtils.containsAny("zzabyycdxx", "by")    = true
	 * StringUtils.containsAny("zzabyycdxx", "zy")    = true
	 * StringUtils.containsAny("zzabyycdxx", "\tx")   = true
	 * StringUtils.containsAny("zzabyycdxx", "$.#yF") = true
	 * StringUtils.containsAny("aba", "z")            = false
	 * </pre>
	 *
	 * @param cs          the CharSequence to check, may be null
	 * @param searchChars the chars to search for, may be null
	 * @return the {@code true} if any of the chars are found, {@code false} if no
	 *         match or null input
	 * @since 2.4
	 * @since 3.0 Changed signature from containsAny(String, String) to
	 *        containsAny(CharSequence, CharSequence)
	 */
	public static boolean containsAny(final CharSequence cs, final CharSequence searchChars) {
		if (searchChars == null) {
			return false;
		}
		return containsAny(cs, CharSequenceUtils.toCharArray(searchChars));
	}

	/**
	 * <p>
	 * Checks if the CharSequence contains any of the CharSequences in the given
	 * array.
	 * </p>
	 *
	 * <p>
	 * A {@code null} {@code cs} CharSequence will return {@code false}. A
	 * {@code null} or zero length search array will return {@code false}.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.containsAny(null, *)            = false
	 * StringUtils.containsAny("", *)              = false
	 * StringUtils.containsAny(*, null)            = false
	 * StringUtils.containsAny(*, [])              = false
	 * StringUtils.containsAny("abcd", "ab", null) = true
	 * StringUtils.containsAny("abcd", "ab", "cd") = true
	 * StringUtils.containsAny("abc", "d", "abc")  = true
	 * </pre>
	 *
	 *
	 * @param cs                  The CharSequence to check, may be null
	 * @param searchCharSequences The array of CharSequences to search for, may be
	 *                            null. Individual CharSequences may be null as
	 *                            well.
	 * @return {@code true} if any of the search CharSequences are found,
	 *         {@code false} otherwise
	 * @since 3.4
	 */
	public static boolean containsAny(final CharSequence cs, final CharSequence... searchCharSequences) {
		return containsAny(StringUtils::contains, cs, searchCharSequences);
	}

	/**
	 * <p>
	 * Checks if the CharSequence contains any of the CharSequences in the given
	 * array.
	 * </p>
	 *
	 * <p>
	 * A {@code null} {@code cs} CharSequence will return {@code false}. A
	 * {@code null} or zero length search array will return {@code false}.
	 * </p>
	 *
	 * @param cs                  The CharSequence to check, may be null
	 * @param searchCharSequences The array of CharSequences to search for, may be
	 *                            null. Individual CharSequences may be null as
	 *                            well.
	 * @return {@code true} if any of the search CharSequences are found,
	 *         {@code false} otherwise
	 * @since 3.12.0
	 */
	private static boolean containsAny(final ToBooleanBiFunction<CharSequence, CharSequence> test,
			final CharSequence cs, final CharSequence... searchCharSequences) {
		if (isEmpty(cs) || searchCharSequences.length == 0) {
			return false;
		}
		for (final CharSequence searchCharSequence : searchCharSequences) {
			if (test.applyAsBoolean(cs, searchCharSequence)) {
				return true;
			}
		}
		return false;
	}

	/**
	 * <p>
	 * Checks if the CharSequence contains any of the CharSequences in the given
	 * array, ignoring case.
	 * </p>
	 *
	 * <p>
	 * A {@code null} {@code cs} CharSequence will return {@code false}. A
	 * {@code null} or zero length search array will return {@code false}.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.containsAny(null, *)            = false
	 * StringUtils.containsAny("", *)              = false
	 * StringUtils.containsAny(*, null)            = false
	 * StringUtils.containsAny(*, [])              = false
	 * StringUtils.containsAny("abcd", "ab", null) = true
	 * StringUtils.containsAny("abcd", "ab", "cd") = true
	 * StringUtils.containsAny("abc", "d", "abc")  = true
	 * StringUtils.containsAny("abc", "D", "ABC")  = true
	 * StringUtils.containsAny("ABC", "d", "abc")  = true
	 * </pre>
	 *
	 *
	 * @param cs                  The CharSequence to check, may be null
	 * @param searchCharSequences The array of CharSequences to search for, may be
	 *                            null. Individual CharSequences may be null as
	 *                            well.
	 * @return {@code true} if any of the search CharSequences are found,
	 *         {@code false} otherwise
	 * @since 3.12.0
	 */
	public static boolean containsAnyIgnoreCase(final CharSequence cs, final CharSequence... searchCharSequences) {
		return containsAny(StringUtils::containsIgnoreCase, cs, searchCharSequences);
	}

	/**
	 * <p>
	 * Checks if CharSequence contains a search CharSequence irrespective of case,
	 * handling {@code null}. Case-insensitivity is defined as by
	 * {@link String#equalsIgnoreCase(String)}.
	 *
	 * <p>
	 * A {@code null} CharSequence will return {@code false}.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.containsIgnoreCase(null, *) = false
	 * StringUtils.containsIgnoreCase(*, null) = false
	 * StringUtils.containsIgnoreCase("", "") = true
	 * StringUtils.containsIgnoreCase("abc", "") = true
	 * StringUtils.containsIgnoreCase("abc", "a") = true
	 * StringUtils.containsIgnoreCase("abc", "z") = false
	 * StringUtils.containsIgnoreCase("abc", "A") = true
	 * StringUtils.containsIgnoreCase("abc", "Z") = false
	 * </pre>
	 *
	 * @param str       the CharSequence to check, may be null
	 * @param searchStr the CharSequence to find, may be null
	 * @return true if the CharSequence contains the search CharSequence
	 *         irrespective of case or false if not or {@code null} string input
	 * @since 3.0 Changed signature from containsIgnoreCase(String, String) to
	 *        containsIgnoreCase(CharSequence, CharSequence)
	 */
	public static boolean containsIgnoreCase(final CharSequence str, final CharSequence searchStr) {
		if (str == null || searchStr == null) {
			return false;
		}
		final int len = searchStr.length();
		final int max = str.length() - len;
		for (int i = 0; i <= max; i++) {
			if (CharSequenceUtils.regionMatches(str, true, i, searchStr, 0, len)) {
				return true;
			}
		}
		return false;
	}

	/**
	 * <p>
	 * Checks that the CharSequence does not contain certain characters.
	 * </p>
	 *
	 * <p>
	 * A {@code null} CharSequence will return {@code true}. A {@code null} invalid
	 * character array will return {@code true}. An empty CharSequence (length()=0)
	 * always returns true.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.containsNone(null, *)       = true
	 * StringUtils.containsNone(*, null)       = true
	 * StringUtils.containsNone("", *)         = true
	 * StringUtils.containsNone("ab", '')      = true
	 * StringUtils.containsNone("abab", 'xyz') = true
	 * StringUtils.containsNone("ab1", 'xyz')  = true
	 * StringUtils.containsNone("abz", 'xyz')  = false
	 * </pre>
	 *
	 * @param cs          the CharSequence to check, may be null
	 * @param searchChars an array of invalid chars, may be null
	 * @return true if it contains none of the invalid chars, or is null
	 * @since 2.0
	 * @since 3.0 Changed signature from containsNone(String, char[]) to
	 *        containsNone(CharSequence, char...)
	 */
	public static boolean containsNone(final CharSequence cs, final char... searchChars) {
		if (cs == null || searchChars == null) {
			return true;
		}
		final int csLen = cs.length();
		final int csLast = csLen - 1;
		final int searchLen = searchChars.length;
		final int searchLast = searchLen - 1;
		for (int i = 0; i < csLen; i++) {
			final char ch = cs.charAt(i);
			for (int j = 0; j < searchLen; j++) {
				if (searchChars[j] == ch) {
					if (Character.isHighSurrogate(ch)) {
						if (j == searchLast) {
							// missing low surrogate, fine, like String.indexOf(String)
							return false;
						}
						if (i < csLast && searchChars[j + 1] == cs.charAt(i + 1)) {
							return false;
						}
					} else {
						// ch is in the Basic Multilingual Plane
						return false;
					}
				}
			}
		}
		return true;
	}

	/**
	 * <p>
	 * Checks that the CharSequence does not contain certain characters.
	 * </p>
	 *
	 * <p>
	 * A {@code null} CharSequence will return {@code true}. A {@code null} invalid
	 * character array will return {@code true}. An empty String ("") always returns
	 * true.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.containsNone(null, *)       = true
	 * StringUtils.containsNone(*, null)       = true
	 * StringUtils.containsNone("", *)         = true
	 * StringUtils.containsNone("ab", "")      = true
	 * StringUtils.containsNone("abab", "xyz") = true
	 * StringUtils.containsNone("ab1", "xyz")  = true
	 * StringUtils.containsNone("abz", "xyz")  = false
	 * </pre>
	 *
	 * @param cs           the CharSequence to check, may be null
	 * @param invalidChars a String of invalid chars, may be null
	 * @return true if it contains none of the invalid chars, or is null
	 * @since 2.0
	 * @since 3.0 Changed signature from containsNone(String, String) to
	 *        containsNone(CharSequence, String)
	 */
	public static boolean containsNone(final CharSequence cs, final String invalidChars) {
		if (invalidChars == null) {
			return true;
		}
		return containsNone(cs, invalidChars.toCharArray());
	}

	/**
	 * <p>
	 * Checks if the CharSequence contains only certain characters.
	 * </p>
	 *
	 * <p>
	 * A {@code null} CharSequence will return {@code false}. A {@code null} valid
	 * character array will return {@code false}. An empty CharSequence (length()=0)
	 * always returns {@code true}.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.containsOnly(null, *)       = false
	 * StringUtils.containsOnly(*, null)       = false
	 * StringUtils.containsOnly("", *)         = true
	 * StringUtils.containsOnly("ab", '')      = false
	 * StringUtils.containsOnly("abab", 'abc') = true
	 * StringUtils.containsOnly("ab1", 'abc')  = false
	 * StringUtils.containsOnly("abz", 'abc')  = false
	 * </pre>
	 *
	 * @param cs    the String to check, may be null
	 * @param valid an array of valid chars, may be null
	 * @return true if it only contains valid chars and is non-null
	 * @since 3.0 Changed signature from containsOnly(String, char[]) to
	 *        containsOnly(CharSequence, char...)
	 */
	public static boolean containsOnly(final CharSequence cs, final char... valid) {
		// All these pre-checks are to maintain API with an older version
		if (valid == null || cs == null) {
			return false;
		}
		if (cs.length() == 0) {
			return true;
		}
		if (valid.length == 0) {
			return false;
		}
		return indexOfAnyBut(cs, valid) == INDEX_NOT_FOUND;
	}

	/**
	 * <p>
	 * Checks if the CharSequence contains only certain characters.
	 * </p>
	 *
	 * <p>
	 * A {@code null} CharSequence will return {@code false}. A {@code null} valid
	 * character String will return {@code false}. An empty String (length()=0)
	 * always returns {@code true}.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.containsOnly(null, *)       = false
	 * StringUtils.containsOnly(*, null)       = false
	 * StringUtils.containsOnly("", *)         = true
	 * StringUtils.containsOnly("ab", "")      = false
	 * StringUtils.containsOnly("abab", "abc") = true
	 * StringUtils.containsOnly("ab1", "abc")  = false
	 * StringUtils.containsOnly("abz", "abc")  = false
	 * </pre>
	 *
	 * @param cs         the CharSequence to check, may be null
	 * @param validChars a String of valid chars, may be null
	 * @return true if it only contains valid chars and is non-null
	 * @since 2.0
	 * @since 3.0 Changed signature from containsOnly(String, String) to
	 *        containsOnly(CharSequence, String)
	 */
	public static boolean containsOnly(final CharSequence cs, final String validChars) {
		if (cs == null || validChars == null) {
			return false;
		}
		return containsOnly(cs, validChars.toCharArray());
	}

	/**
	 * <p>
	 * Check whether the given CharSequence contains any whitespace characters.
	 * </p>
	 *
	 * <p>
	 * Whitespace is defined by {@link Character#isWhitespace(char)}.
	 * </p>
	 *
	 * @param seq the CharSequence to check (may be {@code null})
	 * @return {@code true} if the CharSequence is not empty and contains at least 1
	 *         (breaking) whitespace character
	 * @since 3.0
	 */
	// From org.springframework.util.StringUtils, under Apache License 2.0
	public static boolean containsWhitespace(final CharSequence seq) {
		if (isEmpty(seq)) {
			return false;
		}
		final 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(final StringBuilder decomposed) {
		for (int i = 0; i < decomposed.length(); i++) {
			if (decomposed.charAt(i) == '\u0141') {
				decomposed.setCharAt(i, 'L');
			} else if (decomposed.charAt(i) == '\u0142') {
				decomposed.setCharAt(i, 'l');
			}
		}
	}

	/**
	 * <p>
	 * Counts how many times the char appears in the given string.
	 * </p>
	 *
	 * <p>
	 * A {@code null} or empty ("") String input returns {@code 0}.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.countMatches(null, *)       = 0
	 * StringUtils.countMatches("", *)         = 0
	 * StringUtils.countMatches("abba", 0)  = 0
	 * StringUtils.countMatches("abba", 'a')   = 2
	 * StringUtils.countMatches("abba", 'b')  = 2
	 * StringUtils.countMatches("abba", 'x') = 0
	 * </pre>
	 *
	 * @param str the CharSequence to check, may be null
	 * @param ch  the char to count
	 * @return the number of occurrences, 0 if the CharSequence is {@code null}
	 * @since 3.4
	 */
	public static int countMatches(final CharSequence str, final char ch) {
		if (isEmpty(str)) {
			return 0;
		}
		int count = 0;
		// We could also call str.toCharArray() for faster look ups but that would
		// generate more garbage.
		for (int i = 0; i < str.length(); i++) {
			if (ch == str.charAt(i)) {
				count++;
			}
		}
		return count;
	}

	/**
	 * <p>
	 * Counts how many times the substring appears in the larger string. Note that
	 * the code only counts non-overlapping matches.
	 * </p>
	 *
	 * <p>
	 * A {@code null} or empty ("") String input returns {@code 0}.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.countMatches(null, *)       = 0
	 * StringUtils.countMatches("", *)         = 0
	 * StringUtils.countMatches("abba", null)  = 0
	 * StringUtils.countMatches("abba", "")    = 0
	 * StringUtils.countMatches("abba", "a")   = 2
	 * StringUtils.countMatches("abba", "ab")  = 1
	 * StringUtils.countMatches("abba", "xxx") = 0
	 * StringUtils.countMatches("ababa", "aba") = 1
	 * </pre>
	 *
	 * @param str the CharSequence to check, may be null
	 * @param sub the substring to count, may be null
	 * @return the number of occurrences, 0 if either CharSequence is {@code null}
	 * @since 3.0 Changed signature from countMatches(String, String) to
	 *        countMatches(CharSequence, CharSequence)
	 */
	public static int countMatches(final CharSequence str, final CharSequence sub) {
		if (isEmpty(str) || isEmpty(sub)) {
			return 0;
		}
		int count = 0;
		int idx = 0;
		while ((idx = CharSequenceUtils.indexOf(str, sub, idx)) != INDEX_NOT_FOUND) {
			count++;
			idx += sub.length();
		}
		return count;
	}

	/**
	 * <p>
	 * Returns either the passed in CharSequence, or if the CharSequence is
	 * whitespace, empty ("") or {@code null}, the value of {@code defaultStr}.
	 * </p>
	 *
	 * <p>
	 * Whitespace is defined by {@link Character#isWhitespace(char)}.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.defaultIfBlank(null, "NULL")  = "NULL"
	 * StringUtils.defaultIfBlank("", "NULL")    = "NULL"
	 * StringUtils.defaultIfBlank(" ", "NULL")   = "NULL"
	 * StringUtils.defaultIfBlank("bat", "NULL") = "bat"
	 * StringUtils.defaultIfBlank("", null)      = null
	 * </pre>
	 * 
	 * @param <T>        the specific kind of CharSequence
	 * @param str        the CharSequence to check, may be null
	 * @param defaultStr the default CharSequence to return if the input is
	 *                   whitespace, empty ("") or {@code null}, may be null
	 * @return the passed in CharSequence, or the default
	 * @see StringUtils#defaultString(String, String)
	 */
	public static <T extends CharSequence> T defaultIfBlank(final T str, final T defaultStr) {
		return isBlank(str) ? defaultStr : str;
	}

	/**
	 * <p>
	 * Returns either the passed in CharSequence, or if the CharSequence is empty or
	 * {@code null}, the value of {@code defaultStr}.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.defaultIfEmpty(null, "NULL")  = "NULL"
	 * StringUtils.defaultIfEmpty("", "NULL")    = "NULL"
	 * StringUtils.defaultIfEmpty(" ", "NULL")   = " "
	 * StringUtils.defaultIfEmpty("bat", "NULL") = "bat"
	 * StringUtils.defaultIfEmpty("", null)      = null
	 * </pre>
	 * 
	 * @param <T>        the specific kind of CharSequence
	 * @param str        the CharSequence to check, may be null
	 * @param defaultStr the default CharSequence to return if the input is empty
	 *                   ("") or {@code null}, may be null
	 * @return the passed in CharSequence, or the default
	 * @see StringUtils#defaultString(String, String)
	 */
	public static <T extends CharSequence> T defaultIfEmpty(final T str, final T defaultStr) {
		return isEmpty(str) ? defaultStr : str;
	}

	/**
	 * <p>
	 * Returns either the passed in String, or if the String is {@code null}, an
	 * empty String ("").
	 * </p>
	 *
	 * <pre>
	 * StringUtils.defaultString(null)  = ""
	 * StringUtils.defaultString("")    = ""
	 * StringUtils.defaultString("bat") = "bat"
	 * </pre>
	 *
	 * @see ObjectUtils#toString(Object)
	 * @see String#valueOf(Object)
	 * @param str the String to check, may be null
	 * @return the passed in String, or the empty String if it was {@code null}
	 */
	public static String defaultString(final String str) {
		return defaultString(str, EMPTY);
	}

	/**
	 * <p>
	 * Returns either the passed in String, or if the String is {@code null}, the
	 * value of {@code defaultStr}.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.defaultString(null, "NULL")  = "NULL"
	 * StringUtils.defaultString("", "NULL")    = ""
	 * StringUtils.defaultString("bat", "NULL") = "bat"
	 * </pre>
	 *
	 * @see ObjectUtils#toString(Object,String)
	 * @see String#valueOf(Object)
	 * @param str        the String to check, may be null
	 * @param defaultStr the default String to return if the input is {@code null},
	 *                   may be null
	 * @return the passed in String, or the default if it was {@code null}
	 */
	public static String defaultString(final String str, final String defaultStr) {
		return str == null ? defaultStr : str;
	}

	/**
	 * <p>
	 * Deletes all whitespaces from a String as defined by
	 * {@link Character#isWhitespace(char)}.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.deleteWhitespace(null)         = null
	 * StringUtils.deleteWhitespace("")           = ""
	 * StringUtils.deleteWhitespace("abc")        = "abc"
	 * StringUtils.deleteWhitespace("   ab  c  ") = "abc"
	 * </pre>
	 *
	 * @param str the String to delete whitespace from, may be null
	 * @return the String without whitespaces, {@code null} if null String input
	 */
	public static String deleteWhitespace(final String str) {
		if (isEmpty(str)) {
			return str;
		}
		final int sz = str.length();
		final 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;
		}
		if (count == 0) {
			return EMPTY;
		}
		return new String(chs, 0, count);
	}

	/**
	 * <p>
	 * Compares two Strings, and returns the portion where they differ. More
	 * precisely, return the remainder of the second String, starting from where
	 * it's different from the first. This means that the difference between "abc"
	 * and "ab" is the empty String and not "c".
	 * </p>
	 *
	 * <p>
	 * For example, {@code difference("i am a machine", "i am a robot") -> "robot"}.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.difference(null, null) = null
	 * StringUtils.difference("", "") = ""
	 * StringUtils.difference("", "abc") = "abc"
	 * StringUtils.difference("abc", "") = ""
	 * StringUtils.difference("abc", "abc") = ""
	 * StringUtils.difference("abc", "ab") = ""
	 * StringUtils.difference("ab", "abxyz") = "xyz"
	 * StringUtils.difference("abcde", "abxyz") = "xyz"
	 * StringUtils.difference("abcde", "xyz") = "xyz"
	 * </pre>
	 *
	 * @param str1 the first String, may be null
	 * @param str2 the second String, may be null
	 * @return the portion of str2 where it differs from str1; returns the empty
	 *         String if they are equal
	 * @see #indexOfDifference(CharSequence,CharSequence)
	 * @since 2.0
	 */
	public static String difference(final String str1, final String str2) {
		if (str1 == null) {
			return str2;
		}
		if (str2 == null) {
			return str1;
		}
		final int at = indexOfDifference(str1, str2);
		if (at == INDEX_NOT_FOUND) {
			return EMPTY;
		}
		return str2.substring(at);
	}

	/**
	 * <p>
	 * Check if a CharSequence ends with a specified suffix.
	 * </p>
	 *
	 * <p>
	 * {@code null}s are handled without exceptions. Two {@code null} references are
	 * considered to be equal. The comparison is case sensitive.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.endsWith(null, null)      = true
	 * StringUtils.endsWith(null, "def")     = false
	 * StringUtils.endsWith("abcdef", null)  = false
	 * StringUtils.endsWith("abcdef", "def") = true
	 * StringUtils.endsWith("ABCDEF", "def") = false
	 * StringUtils.endsWith("ABCDEF", "cde") = false
	 * StringUtils.endsWith("ABCDEF", "")    = true
	 * </pre>
	 *
	 * @see java.lang.String#endsWith(String)
	 * @param str    the CharSequence to check, may be null
	 * @param suffix the suffix to find, may be null
	 * @return {@code true} if the CharSequence ends with the suffix, case
	 *         sensitive, or both {@code null}
	 * @since 2.4
	 * @since 3.0 Changed signature from endsWith(String, String) to
	 *        endsWith(CharSequence, CharSequence)
	 */
	public static boolean endsWith(final CharSequence str, final CharSequence suffix) {
		return endsWith(str, suffix, false);
	}

	/**
	 * <p>
	 * Check if a CharSequence ends with a specified suffix (optionally case
	 * insensitive).
	 * </p>
	 *
	 * @see java.lang.String#endsWith(String)
	 * @param str        the CharSequence to check, may be null
	 * @param suffix     the suffix to find, may be null
	 * @param ignoreCase indicates whether the compare should ignore case (case
	 *                   insensitive) or not.
	 * @return {@code true} if the CharSequence starts with the prefix or both
	 *         {@code null}
	 */
	private static boolean endsWith(final CharSequence str, final CharSequence suffix, final boolean ignoreCase) {
		if (str == null || suffix == null) {
			return str == suffix;
		}
		if (suffix.length() > str.length()) {
			return false;
		}
		final int strOffset = str.length() - suffix.length();
		return CharSequenceUtils.regionMatches(str, ignoreCase, strOffset, suffix, 0, suffix.length());
	}

	/**
	 * <p>
	 * Check if a CharSequence ends with any of the provided case-sensitive
	 * suffixes.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.endsWithAny(null, null)      = false
	 * StringUtils.endsWithAny(null, new String[] {"abc"})  = false
	 * StringUtils.endsWithAny("abcxyz", null)     = false
	 * StringUtils.endsWithAny("abcxyz", new String[] {""}) = true
	 * StringUtils.endsWithAny("abcxyz", new String[] {"xyz"}) = true
	 * StringUtils.endsWithAny("abcxyz", new String[] {null, "xyz", "abc"}) = true
	 * StringUtils.endsWithAny("abcXYZ", "def", "XYZ") = true
	 * StringUtils.endsWithAny("abcXYZ", "def", "xyz") = false
	 * </pre>
	 *
	 * @param sequence      the CharSequence to check, may be null
	 * @param searchStrings the case-sensitive CharSequences to find, may be empty
	 *                      or contain {@code null}
	 * @see StringUtils#endsWith(CharSequence, CharSequence)
	 * @return {@code true} if the input {@code sequence} is {@code null} AND no
	 *         {@code searchStrings} are provided, or the input {@code sequence}
	 *         ends in any of the provided case-sensitive {@code searchStrings}.
	 * @since 3.0
	 */
	public static boolean endsWithAny(final CharSequence sequence, final CharSequence... searchStrings) {
		if (isEmpty(sequence) || searchStrings.length == 0) {
			return false;
		}
		for (final CharSequence searchString : searchStrings) {
			if (endsWith(sequence, searchString)) {
				return true;
			}
		}
		return false;
	}

	/**
	 * <p>
	 * Case insensitive check if a CharSequence ends with a specified suffix.
	 * </p>
	 *
	 * <p>
	 * {@code null}s are handled without exceptions. Two {@code null} references are
	 * considered to be equal. The comparison is case insensitive.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.endsWithIgnoreCase(null, null)      = true
	 * StringUtils.endsWithIgnoreCase(null, "def")     = false
	 * StringUtils.endsWithIgnoreCase("abcdef", null)  = false
	 * StringUtils.endsWithIgnoreCase("abcdef", "def") = true
	 * StringUtils.endsWithIgnoreCase("ABCDEF", "def") = true
	 * StringUtils.endsWithIgnoreCase("ABCDEF", "cde") = false
	 * </pre>
	 *
	 * @see java.lang.String#endsWith(String)
	 * @param str    the CharSequence to check, may be null
	 * @param suffix the suffix to find, may be null
	 * @return {@code true} if the CharSequence ends with the suffix, case
	 *         insensitive, or both {@code null}
	 * @since 2.4
	 * @since 3.0 Changed signature from endsWithIgnoreCase(String, String) to
	 *        endsWithIgnoreCase(CharSequence, CharSequence)
	 */
	public static boolean endsWithIgnoreCase(final CharSequence str, final CharSequence suffix) {
		return endsWith(str, suffix, true);
	}

	/**
	 * <p>
	 * Compares two CharSequences, returning {@code true} if they represent equal
	 * sequences of characters.
	 * </p>
	 *
	 * <p>
	 * {@code null}s are handled without exceptions. Two {@code null} references are
	 * considered to be equal. The comparison is <strong>case sensitive</strong>.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.equals(null, null)   = true
	 * StringUtils.equals(null, "abc")  = false
	 * StringUtils.equals("abc", null)  = false
	 * StringUtils.equals("abc", "abc") = true
	 * StringUtils.equals("abc", "ABC") = false
	 * </pre>
	 *
	 * @param cs1 the first CharSequence, may be {@code null}
	 * @param cs2 the second CharSequence, may be {@code null}
	 * @return {@code true} if the CharSequences are equal (case-sensitive), or both
	 *         {@code null}
	 * @since 3.0 Changed signature from equals(String, String) to
	 *        equals(CharSequence, CharSequence)
	 * @see Object#equals(Object)
	 * @see #equalsIgnoreCase(CharSequence, CharSequence)
	 */
	public static boolean equals(final CharSequence cs1, final CharSequence cs2) {
		if (cs1 == cs2) {
			return true;
		}
		if (cs1 == null || cs2 == null) {
			return false;
		}
		if (cs1.length() != cs2.length()) {
			return false;
		}
		if (cs1 instanceof String && cs2 instanceof String) {
			return cs1.equals(cs2);
		}
		// Step-wise comparison
		final int length = cs1.length();
		for (int i = 0; i < length; i++) {
			if (cs1.charAt(i) != cs2.charAt(i)) {
				return false;
			}
		}
		return true;
	}

	/**
	 * <p>
	 * Compares given {@code string} to a CharSequences vararg of
	 * {@code searchStrings}, returning {@code true} if the {@code string} is equal
	 * to any of the {@code searchStrings}.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.equalsAny(null, (CharSequence[]) null) = false
	 * StringUtils.equalsAny(null, null, null)    = true
	 * StringUtils.equalsAny(null, "abc", "def")  = false
	 * StringUtils.equalsAny("abc", null, "def")  = false
	 * StringUtils.equalsAny("abc", "abc", "def") = true
	 * StringUtils.equalsAny("abc", "ABC", "DEF") = false
	 * </pre>
	 *
	 * @param string        to compare, may be {@code null}.
	 * @param searchStrings a vararg of strings, may be {@code null}.
	 * @return {@code true} if the string is equal (case-sensitive) to any other
	 *         element of {@code searchStrings}; {@code false} if
	 *         {@code searchStrings} is null or contains no matches.
	 * @since 3.5
	 */
	public static boolean equalsAny(final CharSequence string, final CharSequence... searchStrings) {
		if (searchStrings.length > 0) {
			for (final CharSequence next : searchStrings) {
				if (equals(string, next)) {
					return true;
				}
			}
		}
		return false;
	}

	/**
	 * <p>
	 * Compares given {@code string} to a CharSequences vararg of
	 * {@code searchStrings}, returning {@code true} if the {@code string} is equal
	 * to any of the {@code searchStrings}, ignoring case.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.equalsAnyIgnoreCase(null, (CharSequence[]) null) = false
	 * StringUtils.equalsAnyIgnoreCase(null, null, null)    = true
	 * StringUtils.equalsAnyIgnoreCase(null, "abc", "def")  = false
	 * StringUtils.equalsAnyIgnoreCase("abc", null, "def")  = false
	 * StringUtils.equalsAnyIgnoreCase("abc", "abc", "def") = true
	 * StringUtils.equalsAnyIgnoreCase("abc", "ABC", "DEF") = true
	 * </pre>
	 *
	 * @param string        to compare, may be {@code null}.
	 * @param searchStrings a vararg of strings, may be {@code null}.
	 * @return {@code true} if the string is equal (case-insensitive) to any other
	 *         element of {@code searchStrings}; {@code false} if
	 *         {@code searchStrings} is null or contains no matches.
	 * @since 3.5
	 */
	public static boolean equalsAnyIgnoreCase(final CharSequence string, final CharSequence... searchStrings) {
		if (searchStrings.length > 0) {
			for (final CharSequence next : searchStrings) {
				if (equalsIgnoreCase(string, next)) {
					return true;
				}
			}
		}
		return false;
	}

	/**
	 * <p>
	 * Compares two CharSequences, returning {@code true} if they represent equal
	 * sequences of characters, ignoring case.
	 * </p>
	 *
	 * <p>
	 * {@code null}s are handled without exceptions. Two {@code null} references are
	 * considered equal. The comparison is <strong>case insensitive</strong>.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.equalsIgnoreCase(null, null)   = true
	 * StringUtils.equalsIgnoreCase(null, "abc")  = false
	 * StringUtils.equalsIgnoreCase("abc", null)  = false
	 * StringUtils.equalsIgnoreCase("abc", "abc") = true
	 * StringUtils.equalsIgnoreCase("abc", "ABC") = true
	 * </pre>
	 *
	 * @param cs1 the first CharSequence, may be {@code null}
	 * @param cs2 the second CharSequence, may be {@code null}
	 * @return {@code true} if the CharSequences are equal (case-insensitive), or
	 *         both {@code null}
	 * @since 3.0 Changed signature from equalsIgnoreCase(String, String) to
	 *        equalsIgnoreCase(CharSequence, CharSequence)
	 * @see #equals(CharSequence, CharSequence)
	 */
	public static boolean equalsIgnoreCase(final CharSequence cs1, final CharSequence cs2) {
		if (cs1 == cs2) {
			return true;
		}
		if (cs1 == null || cs2 == null) {
			return false;
		}
		if (cs1.length() != cs2.length()) {
			return false;
		}
		return CharSequenceUtils.regionMatches(cs1, true, 0, cs2, 0, cs1.length());
	}

	/**
	 * <p>
	 * Returns the first value in the array which is not empty (""), {@code null} or
	 * whitespace only.
	 * </p>
	 *
	 * <p>
	 * Whitespace is defined by {@link Character#isWhitespace(char)}.
	 * </p>
	 *
	 * <p>
	 * If all values are blank or the array is {@code null} or empty then
	 * {@code null} is returned.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.firstNonBlank(null, null, null)     = null
	 * StringUtils.firstNonBlank(null, "", " ")        = null
	 * StringUtils.firstNonBlank("abc")                = "abc"
	 * StringUtils.firstNonBlank(null, "xyz")          = "xyz"
	 * StringUtils.firstNonBlank(null, "", " ", "xyz") = "xyz"
	 * StringUtils.firstNonBlank(null, "xyz", "abc")   = "xyz"
	 * StringUtils.firstNonBlank()                     = null
	 * </pre>
	 *
	 * @param <T>    the specific kind of CharSequence
	 * @param values the values to test, may be {@code null} or empty
	 * @return the first value from {@code values} which is not blank, or
	 *         {@code null} if there are no non-blank values
	 * @since 3.8
	 */
	@SafeVarargs
	public static <T extends CharSequence> T firstNonBlank(final T... values) {
		if (values != null) {
			for (final T val : values) {
				if (isNotBlank(val)) {
					return val;
				}
			}
		}
		return null;
	}

	/**
	 * <p>
	 * Returns the first value in the array which is not empty.
	 * </p>
	 *
	 * <p>
	 * If all values are empty or the array is {@code null} or empty then
	 * {@code null} is returned.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.firstNonEmpty(null, null, null)   = null
	 * StringUtils.firstNonEmpty(null, null, "")     = null
	 * StringUtils.firstNonEmpty(null, "", " ")      = " "
	 * StringUtils.firstNonEmpty("abc")              = "abc"
	 * StringUtils.firstNonEmpty(null, "xyz")        = "xyz"
	 * StringUtils.firstNonEmpty("", "xyz")          = "xyz"
	 * StringUtils.firstNonEmpty(null, "xyz", "abc") = "xyz"
	 * StringUtils.firstNonEmpty()                   = null
	 * </pre>
	 *
	 * @param <T>    the specific kind of CharSequence
	 * @param values the values to test, may be {@code null} or empty
	 * @return the first value from {@code values} which is not empty, or
	 *         {@code null} if there are no non-empty values
	 * @since 3.8
	 */
	@SafeVarargs
	public static <T extends CharSequence> T firstNonEmpty(final T... values) {
		if (values != null) {
			for (final T val : values) {
				if (isNotEmpty(val)) {
					return val;
				}
			}
		}
		return null;
	}

	/**
	 * Calls {@link String#getBytes(Charset)} in a null-safe manner.
	 *
	 * @param string  input string
	 * @param charset The {@link Charset} to encode the {@code String}. If null,
	 *                then use the default Charset.
	 * @return The empty byte[] if {@code string} is null, the result of
	 *         {@link String#getBytes(Charset)} otherwise.
	 * @see String#getBytes(Charset)
	 * @since 3.10
	 */
	public static byte[] getBytes(final String string, final Charset charset) {
		return string == null ? new byte[0] : string.getBytes(Charsets.toCharset(charset));
	}

	/**
	 * Calls {@link String#getBytes(String)} in a null-safe manner.
	 *
	 * @param string  input string
	 * @param charset The {@link Charset} name to encode the {@code String}. If
	 *                null, then use the default Charset.
	 * @return The empty byte[] if {@code string} is null, the result of
	 *         {@link String#getBytes(String)} otherwise.
	 * @throws UnsupportedEncodingException Thrown when the named charset is not
	 *                                      supported.
	 * @see String#getBytes(String)
	 * @since 3.10
	 */
	public static byte[] getBytes(final String string, final String charset) throws UnsupportedEncodingException {
		return string == null ? new byte[0] : string.getBytes(Charsets.toCharsetName(charset));
	}

	/**
	 * <p>
	 * Compares all Strings in an array and returns the initial sequence of
	 * characters that is common to all of them.
	 * </p>
	 *
	 * <p>
	 * For example, {@code getCommonPrefix(new String[] {"i am a machine", "i am a
	 * robot"}) -&gt; "i am a "}
	 * </p>
	 *
	 * <pre>
	 * StringUtils.getCommonPrefix(null) = ""
	 * StringUtils.getCommonPrefix(new String[] {}) = ""
	 * StringUtils.getCommonPrefix(new String[] {"abc"}) = "abc"
	 * StringUtils.getCommonPrefix(new String[] {null, null}) = ""
	 * StringUtils.getCommonPrefix(new String[] {"", ""}) = ""
	 * StringUtils.getCommonPrefix(new String[] {"", null}) = ""
	 * StringUtils.getCommonPrefix(new String[] {"abc", null, null}) = ""
	 * StringUtils.getCommonPrefix(new String[] {null, null, "abc"}) = ""
	 * StringUtils.getCommonPrefix(new String[] {"", "abc"}) = ""
	 * StringUtils.getCommonPrefix(new String[] {"abc", ""}) = ""
	 * StringUtils.getCommonPrefix(new String[] {"abc", "abc"}) = "abc"
	 * StringUtils.getCommonPrefix(new String[] {"abc", "a"}) = "a"
	 * StringUtils.getCommonPrefix(new String[] {"ab", "abxyz"}) = "ab"
	 * StringUtils.getCommonPrefix(new String[] {"abcde", "abxyz"}) = "ab"
	 * StringUtils.getCommonPrefix(new String[] {"abcde", "xyz"}) = ""
	 * StringUtils.getCommonPrefix(new String[] {"xyz", "abcde"}) = ""
	 * StringUtils.getCommonPrefix(new String[] {"i am a machine", "i am a robot"}) = "i am a "
	 * </pre>
	 *
	 * @param strs array of String objects, entries may be null
	 * @return the initial sequence of characters that are common to all Strings in
	 *         the array; empty String if the array is null, the elements are all
	 *         null or if there is no common prefix.
	 * @since 2.4
	 */
	public static String getCommonPrefix(final String... strs) {
		if (strs.length == 0) {
			return EMPTY;
		}
		final int smallestIndexOfDiff = indexOfDifference(strs);
		if (smallestIndexOfDiff == INDEX_NOT_FOUND) {
			// all strings were identical
			if (strs[0] == null) {
				return EMPTY;
			}
			return strs[0];
		} else if (smallestIndexOfDiff == 0) {
			// there were no common initial characters
			return EMPTY;
		} else {
			// we found a common initial character sequence
			return strs[0].substring(0, smallestIndexOfDiff);
		}
	}

	/**
	 * <p>
	 * Checks if a String {@code str} contains Unicode digits, if yes then
	 * concatenate all the digits in {@code str} and return it as a String.
	 * </p>
	 *
	 * <p>
	 * An empty ("") String will be returned if no digits found in {@code str}.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.getDigits(null)  = null
	 * StringUtils.getDigits("")    = ""
	 * StringUtils.getDigits("abc") = ""
	 * StringUtils.getDigits("1000$") = "1000"
	 * StringUtils.getDigits("1123~45") = "112345"
	 * StringUtils.getDigits("(541) 754-3010") = "5417543010"
	 * StringUtils.getDigits("\u0967\u0968\u0969") = "\u0967\u0968\u0969"
	 * </pre>
	 *
	 * @param str the String to extract digits from, may be null
	 * @return String with only digits, or an empty ("") String if no digits found,
	 *         or {@code null} String if {@code str} is null
	 * @since 3.6
	 */
	public static String getDigits(final String str) {
		if (isEmpty(str)) {
			return str;
		}
		final int sz = str.length();
		final StringBuilder strDigits = new StringBuilder(sz);
		for (int i = 0; i < sz; i++) {
			final char tempChar = str.charAt(i);
			if (Character.isDigit(tempChar)) {
				strDigits.append(tempChar);
			}
		}
		return strDigits.toString();
	}

	/**
	 * <p>
	 * Find the Fuzzy Distance which indicates the similarity score between two
	 * Strings.
	 * </p>
	 *
	 * <p>
	 * This string matching algorithm is similar to the algorithms of editors such
	 * as Sublime Text, TextMate, Atom and others. One point is given for every
	 * matched character. Subsequent matches yield two bonus points. A higher score
	 * indicates a higher similarity.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.getFuzzyDistance(null, null, null)                                    = IllegalArgumentException
	 * StringUtils.getFuzzyDistance("", "", Locale.ENGLISH)                              = 0
	 * StringUtils.getFuzzyDistance("Workshop", "b", Locale.ENGLISH)                     = 0
	 * StringUtils.getFuzzyDistance("Room", "o", Locale.ENGLISH)                         = 1
	 * StringUtils.getFuzzyDistance("Workshop", "w", Locale.ENGLISH)                     = 1
	 * StringUtils.getFuzzyDistance("Workshop", "ws", Locale.ENGLISH)                    = 2
	 * StringUtils.getFuzzyDistance("Workshop", "wo", Locale.ENGLISH)                    = 4
	 * StringUtils.getFuzzyDistance("Apache Software Foundation", "asf", Locale.ENGLISH) = 3
	 * </pre>
	 *
	 * @param term   a full term that should be matched against, must not be null
	 * @param query  the query that will be matched against a term, must not be null
	 * @param locale This string matching logic is case insensitive. A locale is
	 *               necessary to normalize both Strings to lower case.
	 * @return result score
	 * @throws IllegalArgumentException if either String input {@code null} or
	 *                                  Locale input {@code null}
	 * @since 3.4
	 * @deprecated as of 3.6, use commons-text <a href=
	 *             "https://commons.apache.org/proper/commons-text/javadocs/api-release/org/apache/commons/text/similarity/FuzzyScore.html">
	 *             FuzzyScore</a> instead
	 */
	@Deprecated
	public static int getFuzzyDistance(final CharSequence term, final CharSequence query, final Locale locale) {
		if (term == null || query == null) {
			throw new IllegalArgumentException("Strings must not be null");
		} else if (locale == null) {
			throw new IllegalArgumentException("Locale must not be null");
		}

		// fuzzy logic is case insensitive. We normalize the Strings to lower
		// case right from the start. Turning characters to lower case
		// via Character.toLowerCase(char) is unfortunately insufficient
		// as it does not accept a locale.
		final String termLowerCase = term.toString().toLowerCase(locale);
		final String queryLowerCase = query.toString().toLowerCase(locale);

		// the resulting score
		int score = 0;

		// the position in the term which will be scanned next for potential
		// query character matches
		int termIndex = 0;

		// index of the previously matched character in the term
		int previousMatchingCharacterIndex = Integer.MIN_VALUE;

		for (int queryIndex = 0; queryIndex < queryLowerCase.length(); queryIndex++) {
			final char queryChar = queryLowerCase.charAt(queryIndex);

			boolean termCharacterMatchFound = false;
			for (; termIndex < termLowerCase.length() && !termCharacterMatchFound; termIndex++) {
				final char termChar = termLowerCase.charAt(termIndex);

				if (queryChar == termChar) {
					// simple character matches result in one point
					score++;

					// subsequent character matches further improve
					// the score.
					if (previousMatchingCharacterIndex + 1 == termIndex) {
						score += 2;
					}

					previousMatchingCharacterIndex = termIndex;

					// we can leave the nested loop. Every character in the
					// query can match at most one character in the term.
					termCharacterMatchFound = true;
				}
			}
		}

		return score;
	}

	/**
	 * <p>
	 * Returns either the passed in CharSequence, or if the CharSequence is
	 * whitespace, empty ("") or {@code null}, the value supplied by
	 * {@code defaultStrSupplier}.
	 * </p>
	 *
	 * <p>
	 * Whitespace is defined by {@link Character#isWhitespace(char)}.
	 * </p>
	 *
	 * <p>
	 * Caller responsible for thread-safety and exception handling of default value
	 * supplier
	 * </p>
	 *
	 * <pre>
	 * {@code
	 * StringUtils.getIfBlank(null, () -> "NULL")   = "NULL"
	 * StringUtils.getIfBlank("", () -> "NULL")     = "NULL"
	 * StringUtils.getIfBlank(" ", () -> "NULL")    = "NULL"
	 * StringUtils.getIfBlank("bat", () -> "NULL")  = "bat"
	 * StringUtils.getIfBlank("", () -> null)       = null
	 * StringUtils.getIfBlank("", null)             = null
	 * }
	 * </pre>
	 * 
	 * @param <T>             the specific kind of CharSequence
	 * @param str             the CharSequence to check, may be null
	 * @param defaultSupplier the supplier of default CharSequence to return if the
	 *                        input is whitespace, empty ("") or {@code null}, may
	 *                        be null
	 * @return the passed in CharSequence, or the default
	 * @see StringUtils#defaultString(String, String)
	 * @since 3.10
	 */
	public static <T extends CharSequence> T getIfBlank(final T str, final Supplier<T> defaultSupplier) {
		return isBlank(str) ? defaultSupplier == null ? null : defaultSupplier.get() : str;
	}

	/**
	 * <p>
	 * Returns either the passed in CharSequence, or if the CharSequence is empty or
	 * {@code null}, the value supplied by {@code defaultStrSupplier}.
	 * </p>
	 *
	 * <p>
	 * Caller responsible for thread-safety and exception handling of default value
	 * supplier
	 * </p>
	 *
	 * <pre>
	 * {@code
	 * StringUtils.getIfEmpty(null, () -> "NULL")    = "NULL"
	 * StringUtils.getIfEmpty("", () -> "NULL")      = "NULL"
	 * StringUtils.getIfEmpty(" ", () -> "NULL")     = " "
	 * StringUtils.getIfEmpty("bat", () -> "NULL")   = "bat"
	 * StringUtils.getIfEmpty("", () -> null)        = null
	 * StringUtils.getIfEmpty("", null)              = null
	 * }
	 * </pre>
	 * 
	 * @param <T>             the specific kind of CharSequence
	 * @param str             the CharSequence to check, may be null
	 * @param defaultSupplier the supplier of default CharSequence to return if the
	 *                        input is empty ("") or {@code null}, may be null
	 * @return the passed in CharSequence, or the default
	 * @see StringUtils#defaultString(String, String)
	 * @since 3.10
	 */
	public static <T extends CharSequence> T getIfEmpty(final T str, final Supplier<T> defaultSupplier) {
		return isEmpty(str) ? defaultSupplier == null ? null : defaultSupplier.get() : str;
	}

	/**
	 * <p>
	 * Find the Jaro Winkler Distance which indicates the similarity score between
	 * two Strings.
	 * </p>
	 *
	 * <p>
	 * The Jaro measure is the weighted sum of percentage of matched characters from
	 * each file and transposed characters. Winkler increased this measure for
	 * matching initial characters.
	 * </p>
	 *
	 * <p>
	 * This implementation is based on the Jaro Winkler similarity algorithm from
	 * <a href=
	 * "http://en.wikipedia.org/wiki/Jaro%E2%80%93Winkler_distance">http://en.wikipedia.org/wiki/Jaro%E2%80%93Winkler_distance</a>.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.getJaroWinklerDistance(null, null)          = IllegalArgumentException
	 * StringUtils.getJaroWinklerDistance("", "")              = 0.0
	 * StringUtils.getJaroWinklerDistance("", "a")             = 0.0
	 * StringUtils.getJaroWinklerDistance("aaapppp", "")       = 0.0
	 * StringUtils.getJaroWinklerDistance("frog", "fog")       = 0.93
	 * StringUtils.getJaroWinklerDistance("fly", "ant")        = 0.0
	 * StringUtils.getJaroWinklerDistance("elephant", "hippo") = 0.44
	 * StringUtils.getJaroWinklerDistance("hippo", "elephant") = 0.44
	 * StringUtils.getJaroWinklerDistance("hippo", "zzzzzzzz") = 0.0
	 * StringUtils.getJaroWinklerDistance("hello", "hallo")    = 0.88
	 * StringUtils.getJaroWinklerDistance("ABC Corporation", "ABC Corp") = 0.93
	 * StringUtils.getJaroWinklerDistance("D N H Enterprises Inc", "D &amp; H Enterprises, Inc.") = 0.95
	 * StringUtils.getJaroWinklerDistance("My Gym Children's Fitness Center", "My Gym. Childrens Fitness") = 0.92
	 * StringUtils.getJaroWinklerDistance("PENNSYLVANIA", "PENNCISYLVNIA") = 0.88
	 * </pre>
	 *
	 * @param first  the first String, must not be null
	 * @param second the second String, must not be null
	 * @return result distance
	 * @throws IllegalArgumentException if either String input {@code null}
	 * @since 3.3
	 * @deprecated as of 3.6, use commons-text <a href=
	 *             "https://commons.apache.org/proper/commons-text/javadocs/api-release/org/apache/commons/text/similarity/JaroWinklerDistance.html">
	 *             JaroWinklerDistance</a> instead
	 */
	@Deprecated
	public static double getJaroWinklerDistance(final CharSequence first, final CharSequence second) {
		final double DEFAULT_SCALING_FACTOR = 0.1;

		if (first == null || second == null) {
			throw new IllegalArgumentException("Strings must not be null");
		}

		final int[] mtp = matches(first, second);
		final double m = mtp[0];
		if (m == 0) {
			return 0D;
		}
		final double j = (m / first.length() + m / second.length() + (m - mtp[1]) / m) / 3;
		final double jw = j < 0.7D ? j : j + Math.min(DEFAULT_SCALING_FACTOR, 1D / mtp[3]) * mtp[2] * (1D - j);
		return Math.round(jw * 100.0D) / 100.0D;
	}

	/**
	 * <p>
	 * Find the Levenshtein distance between two Strings.
	 * </p>
	 *
	 * <p>
	 * This is the number of changes needed to change one String into another, where
	 * each change is a single character modification (deletion, insertion or
	 * substitution).
	 * </p>
	 *
	 * <p>
	 * The implementation uses a single-dimensional array of length s.length() + 1.
	 * See <a href=
	 * "http://blog.softwx.net/2014/12/optimizing-levenshtein-algorithm-in-c.html">
	 * http://blog.softwx.net/2014/12/optimizing-levenshtein-algorithm-in-c.html</a>
	 * for details.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.getLevenshteinDistance(null, *)             = IllegalArgumentException
	 * StringUtils.getLevenshteinDistance(*, null)             = IllegalArgumentException
	 * StringUtils.getLevenshteinDistance("", "")              = 0
	 * StringUtils.getLevenshteinDistance("", "a")             = 1
	 * StringUtils.getLevenshteinDistance("aaapppp", "")       = 7
	 * StringUtils.getLevenshteinDistance("frog", "fog")       = 1
	 * StringUtils.getLevenshteinDistance("fly", "ant")        = 3
	 * StringUtils.getLevenshteinDistance("elephant", "hippo") = 7
	 * StringUtils.getLevenshteinDistance("hippo", "elephant") = 7
	 * StringUtils.getLevenshteinDistance("hippo", "zzzzzzzz") = 8
	 * StringUtils.getLevenshteinDistance("hello", "hallo")    = 1
	 * </pre>
	 *
	 * @param s the first String, must not be null
	 * @param t the second String, must not be null
	 * @return result distance
	 * @throws IllegalArgumentException if either String input {@code null}
	 * @since 3.0 Changed signature from getLevenshteinDistance(String, String) to
	 *        getLevenshteinDistance(CharSequence, CharSequence)
	 * @deprecated as of 3.6, use commons-text <a href=
	 *             "https://commons.apache.org/proper/commons-text/javadocs/api-release/org/apache/commons/text/similarity/LevenshteinDistance.html">
	 *             LevenshteinDistance</a> instead
	 */
	@Deprecated
	public static int getLevenshteinDistance(CharSequence s, CharSequence t) {
		if (s == null || t == null) {
			throw new IllegalArgumentException("Strings must not be null");
		}

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

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

		if (n > m) {
			// swap the input strings to consume less memory
			final CharSequence tmp = s;
			s = t;
			t = tmp;
			n = m;
			m = t.length();
		}

		final int[] p = new int[n + 1];
		// indexes into strings s and t
		int i; // iterates through s
		int j; // iterates through t
		int upper_left;
		int upper;

		char t_j; // jth character of t
		int cost;

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

		for (j = 1; j <= m; j++) {
			upper_left = p[0];
			t_j = t.charAt(j - 1);
			p[0] = j;

			for (i = 1; i <= n; i++) {
				upper = p[i];
				cost = s.charAt(i - 1) == t_j ? 0 : 1;
				// minimum of cell to the left+1, to the top+1, diagonally left and up +cost
				p[i] = Math.min(Math.min(p[i - 1] + 1, p[i] + 1), upper_left + cost);
				upper_left = upper;
			}
		}

		return p[n];
	}

	/**
	 * <p>
	 * Find the Levenshtein distance between two Strings if it's less than or equal
	 * to a given threshold.
	 * </p>
	 *
	 * <p>
	 * This is the number of changes needed to change one String into another, where
	 * each change is a single character modification (deletion, insertion or
	 * substitution).
	 * </p>
	 *
	 * <p>
	 * This implementation follows from Algorithms on Strings, Trees and Sequences
	 * by Dan Gusfield and Chas Emerick's implementation of the Levenshtein distance
	 * algorithm from <a href=
	 * "http://www.merriampark.com/ld.htm">http://www.merriampark.com/ld.htm</a>
	 * </p>
	 *
	 * <pre>
	 * StringUtils.getLevenshteinDistance(null, *, *)             = IllegalArgumentException
	 * StringUtils.getLevenshteinDistance(*, null, *)             = IllegalArgumentException
	 * StringUtils.getLevenshteinDistance(*, *, -1)               = IllegalArgumentException
	 * StringUtils.getLevenshteinDistance("", "", 0)              = 0
	 * StringUtils.getLevenshteinDistance("aaapppp", "", 8)       = 7
	 * StringUtils.getLevenshteinDistance("aaapppp", "", 7)       = 7
	 * StringUtils.getLevenshteinDistance("aaapppp", "", 6))      = -1
	 * StringUtils.getLevenshteinDistance("elephant", "hippo", 7) = 7
	 * StringUtils.getLevenshteinDistance("elephant", "hippo", 6) = -1
	 * StringUtils.getLevenshteinDistance("hippo", "elephant", 7) = 7
	 * StringUtils.getLevenshteinDistance("hippo", "elephant", 6) = -1
	 * </pre>
	 *
	 * @param s         the first String, must not be null
	 * @param t         the second String, must not be null
	 * @param threshold the target threshold, must not be negative
	 * @return result distance, or {@code -1} if the distance would be greater than
	 *         the threshold
	 * @throws IllegalArgumentException if either String input {@code null} or
	 *                                  negative threshold
	 * @deprecated as of 3.6, use commons-text <a href=
	 *             "https://commons.apache.org/proper/commons-text/javadocs/api-release/org/apache/commons/text/similarity/LevenshteinDistance.html">
	 *             LevenshteinDistance</a> instead
	 */
	@Deprecated
	public static int getLevenshteinDistance(CharSequence s, CharSequence t, final int threshold) {
		if (s == null || t == null) {
			throw new IllegalArgumentException("Strings must not be null");
		}
		if (threshold < 0) {
			throw new IllegalArgumentException("Threshold must not be negative");
		}

		/*
		 * This implementation only computes the distance if it's less than or equal to
		 * the threshold value, returning -1 if it's greater. The advantage is
		 * performance: unbounded distance is O(nm), but a bound of k allows us to
		 * reduce it to O(km) time by only computing a diagonal stripe of width 2k + 1
		 * of the cost table. It is also possible to use this to compute the unbounded
		 * Levenshtein distance by starting the threshold at 1 and doubling each time
		 * until the distance is found; this is O(dm), where d is the distance.
		 * 
		 * One subtlety comes from needing to ignore entries on the border of our stripe
		 * eg. p[] = |#|#|#|* d[] = *|#|#|#| We must ignore the entry to the left of the
		 * leftmost member We must ignore the entry above the rightmost member
		 * 
		 * Another subtlety comes from our stripe running off the matrix if the strings
		 * aren't of the same size. Since string s is always swapped to be the shorter
		 * of the two, the stripe will always run off to the upper right instead of the
		 * lower left of the matrix.
		 * 
		 * As a concrete example, suppose s is of length 5, t is of length 7, and our
		 * threshold is 1. In this case we're going to walk a stripe of length 3. The
		 * matrix would look like so:
		 * 
		 * 1 2 3 4 5 1 |#|#| | | | 2 |#|#|#| | | 3 | |#|#|#| | 4 | | |#|#|#| 5 | | |
		 * |#|#| 6 | | | | |#| 7 | | | | | |
		 * 
		 * Note how the stripe leads off the table as there is no possible way to turn a
		 * string of length 5 into one of length 7 in edit distance of 1.
		 * 
		 * Additionally, this implementation decreases memory usage by using two
		 * single-dimensional arrays and swapping them back and forth instead of
		 * allocating an entire n by m matrix. This requires a few minor changes, such
		 * as immediately returning when it's detected that the stripe has run off the
		 * matrix and initially filling the arrays with large values so that entries we
		 * don't compute are ignored.
		 * 
		 * See Algorithms on Strings, Trees and Sequences by Dan Gusfield for some
		 * discussion.
		 */

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

		// if one string is empty, the edit distance is necessarily the length of the
		// other
		if (n == 0) {
			return m <= threshold ? m : -1;
		} else if (m == 0) {
			return n <= threshold ? n : -1;
		} else if (Math.abs(n - m) > threshold) {
			// no need to calculate the distance if the length difference is greater than
			// the threshold
			return -1;
		}

		if (n > m) {
			// swap the two strings to consume less memory
			final CharSequence tmp = s;
			s = t;
			t = tmp;
			n = m;
			m = t.length();
		}

		int[] p = new int[n + 1]; // 'previous' cost array, horizontally
		int[] d = new int[n + 1]; // cost array, horizontally
		int[] _d; // placeholder to assist in swapping p and d

		// fill in starting table values
		final int boundary = Math.min(n, threshold) + 1;
		for (int i = 0; i < boundary; i++) {
			p[i] = i;
		}
		// these fills ensure that the value above the rightmost entry of our
		// stripe will be ignored in following loop iterations
		Arrays.fill(p, boundary, p.length, Integer.MAX_VALUE);
		Arrays.fill(d, Integer.MAX_VALUE);

		// iterates through t
		for (int j = 1; j <= m; j++) {
			final char t_j = t.charAt(j - 1); // jth character of t
			d[0] = j;

			// compute stripe indices, constrain to array size
			final int min = Math.max(1, j - threshold);
			final int max = j > Integer.MAX_VALUE - threshold ? n : Math.min(n, j + threshold);

			// the stripe may lead off of the table if s and t are of different sizes
			if (min > max) {
				return -1;
			}

			// ignore entry left of leftmost
			if (min > 1) {
				d[min - 1] = Integer.MAX_VALUE;
			}

			// iterates through [min, max] in s
			for (int i = min; i <= max; i++) {
				if (s.charAt(i - 1) == t_j) {
					// diagonally left and up
					d[i] = p[i - 1];
				} else {
					// 1 + minimum of cell to the left, to the top, diagonally left and up
					d[i] = 1 + Math.min(Math.min(d[i - 1], p[i]), p[i - 1]);
				}
			}

			// copy current distance counts to 'previous row' distance counts
			_d = p;
			p = d;
			d = _d;
		}

		// if p[n] is greater than the threshold, there's no guarantee on it being the
		// correct
		// distance
		if (p[n] <= threshold) {
			return p[n];
		}
		return -1;
	}

	/**
	 * <p>
	 * Finds the first index within a CharSequence, handling {@code null}. This
	 * method uses {@link String#indexOf(String, int)} if possible.
	 * </p>
	 *
	 * <p>
	 * A {@code null} CharSequence will return {@code -1}.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.indexOf(null, *)          = -1
	 * StringUtils.indexOf(*, null)          = -1
	 * StringUtils.indexOf("", "")           = 0
	 * StringUtils.indexOf("", *)            = -1 (except when * = "")
	 * StringUtils.indexOf("aabaabaa", "a")  = 0
	 * StringUtils.indexOf("aabaabaa", "b")  = 2
	 * StringUtils.indexOf("aabaabaa", "ab") = 1
	 * StringUtils.indexOf("aabaabaa", "")   = 0
	 * </pre>
	 *
	 * @param seq       the CharSequence to check, may be null
	 * @param searchSeq the CharSequence to find, may be null
	 * @return the first index of the search CharSequence, -1 if no match or
	 *         {@code null} string input
	 * @since 2.0
	 * @since 3.0 Changed signature from indexOf(String, String) to
	 *        indexOf(CharSequence, CharSequence)
	 */
	public static int indexOf(final CharSequence seq, final CharSequence searchSeq) {
		if (seq == null || searchSeq == null) {
			return INDEX_NOT_FOUND;
		}
		return CharSequenceUtils.indexOf(seq, searchSeq, 0);
	}

	/**
	 * <p>
	 * Finds the first index within a CharSequence, handling {@code null}. This
	 * method uses {@link String#indexOf(String, int)} if possible.
	 * </p>
	 *
	 * <p>
	 * A {@code null} CharSequence will return {@code -1}. A negative start position
	 * is treated as zero. An empty ("") search CharSequence always matches. A start
	 * position greater than the string length only matches an empty search
	 * CharSequence.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.indexOf(null, *, *)          = -1
	 * StringUtils.indexOf(*, null, *)          = -1
	 * StringUtils.indexOf("", "", 0)           = 0
	 * StringUtils.indexOf("", *, 0)            = -1 (except when * = "")
	 * StringUtils.indexOf("aabaabaa", "a", 0)  = 0
	 * StringUtils.indexOf("aabaabaa", "b", 0)  = 2
	 * StringUtils.indexOf("aabaabaa", "ab", 0) = 1
	 * StringUtils.indexOf("aabaabaa", "b", 3)  = 5
	 * StringUtils.indexOf("aabaabaa", "b", 9)  = -1
	 * StringUtils.indexOf("aabaabaa", "b", -1) = 2
	 * StringUtils.indexOf("aabaabaa", "", 2)   = 2
	 * StringUtils.indexOf("abc", "", 9)        = 3
	 * </pre>
	 *
	 * @param seq       the CharSequence to check, may be null
	 * @param searchSeq the CharSequence to find, may be null
	 * @param startPos  the start position, negative treated as zero
	 * @return the first index of the search CharSequence (always &ge; startPos), -1
	 *         if no match or {@code null} string input
	 * @since 2.0
	 * @since 3.0 Changed signature from indexOf(String, String, int) to
	 *        indexOf(CharSequence, CharSequence, int)
	 */
	public static int indexOf(final CharSequence seq, final CharSequence searchSeq, final int startPos) {
		if (seq == null || searchSeq == null) {
			return INDEX_NOT_FOUND;
		}
		return CharSequenceUtils.indexOf(seq, searchSeq, startPos);
	}

	/**
	 * Returns the index within {@code seq} of the first occurrence of the specified
	 * character. If a character with value {@code searchChar} occurs in the
	 * character sequence represented by {@code seq} {@code CharSequence} object,
	 * then the index (in Unicode code units) of the first such occurrence is
	 * returned. For values of {@code searchChar} in the range from 0 to 0xFFFF
	 * (inclusive), this is the smallest value <i>k</i> such that: <blockquote>
	 * 
	 * <pre>
	 * this.charAt(<i>k</i>) == searchChar
	 * </pre>
	 * 
	 * </blockquote> is true. For other values of {@code searchChar}, it is the
	 * smallest value <i>k</i> such that: <blockquote>
	 * 
	 * <pre>
	 * this.codePointAt(<i>k</i>) == searchChar
	 * </pre>
	 * 
	 * </blockquote> is true. In either case, if no such character occurs in
	 * {@code seq}, then {@code INDEX_NOT_FOUND (-1)} is returned.
	 *
	 * <p>
	 * Furthermore, a {@code null} or empty ("") CharSequence will return
	 * {@code INDEX_NOT_FOUND (-1)}.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.indexOf(null, *)         = -1
	 * StringUtils.indexOf("", *)           = -1
	 * StringUtils.indexOf("aabaabaa", 'a') = 0
	 * StringUtils.indexOf("aabaabaa", 'b') = 2
	 * </pre>
	 *
	 * @param seq        the CharSequence to check, may be null
	 * @param searchChar the character to find
	 * @return the first index of the search character, -1 if no match or
	 *         {@code null} string input
	 * @since 2.0
	 * @since 3.0 Changed signature from indexOf(String, int) to
	 *        indexOf(CharSequence, int)
	 * @since 3.6 Updated {@link CharSequenceUtils} call to behave more like
	 *        {@code String}
	 */
	public static int indexOf(final CharSequence seq, final int searchChar) {
		if (isEmpty(seq)) {
			return INDEX_NOT_FOUND;
		}
		return CharSequenceUtils.indexOf(seq, searchChar, 0);
	}

	/**
	 *
	 * Returns the index within {@code seq} of the first occurrence of the specified
	 * character, starting the search at the specified index.
	 * <p>
	 * If a character with value {@code searchChar} occurs in the character sequence
	 * represented by the {@code seq} {@code CharSequence} object at an index no
	 * smaller than {@code startPos}, then the index of the first such occurrence is
	 * returned. For values of {@code searchChar} in the range from 0 to 0xFFFF
	 * (inclusive), this is the smallest value <i>k</i> such that: <blockquote>
	 * 
	 * <pre>
	 * (this.charAt(<i>k</i>) == searchChar) &amp;&amp; (<i>k</i> &gt;= startPos)
	 * </pre>
	 * 
	 * </blockquote> is true. For other values of {@code searchChar}, it is the
	 * smallest value <i>k</i> such that: <blockquote>
	 * 
	 * <pre>
	 * (this.codePointAt(<i>k</i>) == searchChar) &amp;&amp; (<i>k</i> &gt;= startPos)
	 * </pre>
	 * 
	 * </blockquote> is true. In either case, if no such character occurs in
	 * {@code seq} at or after position {@code startPos}, then {@code -1} is
	 * returned.
	 *
	 * <p>
	 * There is no restriction on the value of {@code startPos}. If it is negative,
	 * it has the same effect as if it were zero: this entire string may be
	 * searched. If it is greater than the length of this string, it has the same
	 * effect as if it were equal to the length of this string:
	 * {@code (INDEX_NOT_FOUND) -1} is returned. Furthermore, a {@code null} or
	 * empty ("") CharSequence will return {@code (INDEX_NOT_FOUND) -1}.
	 *
	 * <p>
	 * All indices are specified in {@code char} values (Unicode code units).
	 *
	 * <pre>
	 * StringUtils.indexOf(null, *, *)          = -1
	 * StringUtils.indexOf("", *, *)            = -1
	 * StringUtils.indexOf("aabaabaa", 'b', 0)  = 2
	 * StringUtils.indexOf("aabaabaa", 'b', 3)  = 5
	 * StringUtils.indexOf("aabaabaa", 'b', 9)  = -1
	 * StringUtils.indexOf("aabaabaa", 'b', -1) = 2
	 * </pre>
	 *
	 * @param seq        the CharSequence to check, may be null
	 * @param searchChar the character to find
	 * @param startPos   the start position, negative treated as zero
	 * @return the first index of the search character (always &ge; startPos), -1 if
	 *         no match or {@code null} string input
	 * @since 2.0
	 * @since 3.0 Changed signature from indexOf(String, int, int) to
	 *        indexOf(CharSequence, int, int)
	 * @since 3.6 Updated {@link CharSequenceUtils} call to behave more like
	 *        {@code String}
	 */
	public static int indexOf(final CharSequence seq, final int searchChar, final int startPos) {
		if (isEmpty(seq)) {
			return INDEX_NOT_FOUND;
		}
		return CharSequenceUtils.indexOf(seq, searchChar, startPos);
	}

	/**
	 * <p>
	 * Search a CharSequence to find the first index of any character in the given
	 * set of characters.
	 * </p>
	 *
	 * <p>
	 * A {@code null} String will return {@code -1}. A {@code null} or zero length
	 * search array will return {@code -1}.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.indexOfAny(null, *)                  = -1
	 * StringUtils.indexOfAny("", *)                    = -1
	 * StringUtils.indexOfAny(*, null)                  = -1
	 * StringUtils.indexOfAny(*, [])                    = -1
	 * StringUtils.indexOfAny("zzabyycdxx", ['z', 'a']) = 0
	 * StringUtils.indexOfAny("zzabyycdxx", ['b', 'y']) = 3
	 * StringUtils.indexOfAny("aba", ['z'])             = -1
	 * </pre>
	 *
	 * @param cs          the CharSequence to check, may be null
	 * @param searchChars the chars to search for, may be null
	 * @return the index of any of the chars, -1 if no match or null input
	 * @since 2.0
	 * @since 3.0 Changed signature from indexOfAny(String, char[]) to
	 *        indexOfAny(CharSequence, char...)
	 */
	public static int indexOfAny(final CharSequence cs, final char... searchChars) {
		if (isEmpty(cs) || searchChars.length == 0) {
			return INDEX_NOT_FOUND;
		}
		final int csLen = cs.length();
		final int csLast = csLen - 1;
		final int searchLen = searchChars.length;
		final int searchLast = searchLen - 1;
		for (int i = 0; i < csLen; i++) {
			final char ch = cs.charAt(i);
			for (int j = 0; j < searchLen; j++) {
				if (searchChars[j] == ch) {
					if (i < csLast && j < searchLast && Character.isHighSurrogate(ch)) {
						// ch is a supplementary character
						if (searchChars[j + 1] == cs.charAt(i + 1)) {
							return i;
						}
					} else {
						return i;
					}
				}
			}
		}
		return INDEX_NOT_FOUND;
	}

	/**
	 * <p>
	 * Find the first index of any of a set of potential substrings.
	 * </p>
	 *
	 * <p>
	 * A {@code null} CharSequence will return {@code -1}. A {@code null} or zero
	 * length search array will return {@code -1}. A {@code null} search array entry
	 * will be ignored, but a search array containing "" will return {@code 0} if
	 * {@code str} is not null. This method uses {@link String#indexOf(String)} if
	 * possible.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.indexOfAny(null, *)                      = -1
	 * StringUtils.indexOfAny(*, null)                      = -1
	 * StringUtils.indexOfAny(*, [])                        = -1
	 * StringUtils.indexOfAny("zzabyycdxx", ["ab", "cd"])   = 2
	 * StringUtils.indexOfAny("zzabyycdxx", ["cd", "ab"])   = 2
	 * StringUtils.indexOfAny("zzabyycdxx", ["mn", "op"])   = -1
	 * StringUtils.indexOfAny("zzabyycdxx", ["zab", "aby"]) = 1
	 * StringUtils.indexOfAny("zzabyycdxx", [""])           = 0
	 * StringUtils.indexOfAny("", [""])                     = 0
	 * StringUtils.indexOfAny("", ["a"])                    = -1
	 * </pre>
	 *
	 * @param str        the CharSequence to check, may be null
	 * @param searchStrs the CharSequences to search for, may be null
	 * @return the first index of any of the searchStrs in str, -1 if no match
	 * @since 3.0 Changed signature from indexOfAny(String, String[]) to
	 *        indexOfAny(CharSequence, CharSequence...)
	 */
	public static int indexOfAny(final CharSequence str, final CharSequence... searchStrs) {
		if (str == null || searchStrs == null) {
			return INDEX_NOT_FOUND;
		}

		// String's can't have a MAX_VALUEth index.
		int ret = Integer.MAX_VALUE;

		int tmp = 0;
		for (final CharSequence search : searchStrs) {
			if (search == null) {
				continue;
			}
			tmp = CharSequenceUtils.indexOf(str, search, 0);
			if (tmp == INDEX_NOT_FOUND) {
				continue;
			}

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

		return ret == Integer.MAX_VALUE ? INDEX_NOT_FOUND : ret;
	}

	/**
	 * <p>
	 * Search a CharSequence to find the first index of any character in the given
	 * set of characters.
	 * </p>
	 *
	 * <p>
	 * A {@code null} String will return {@code -1}. A {@code null} search string
	 * will return {@code -1}.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.indexOfAny(null, *)            = -1
	 * StringUtils.indexOfAny("", *)              = -1
	 * StringUtils.indexOfAny(*, null)            = -1
	 * StringUtils.indexOfAny(*, "")              = -1
	 * StringUtils.indexOfAny("zzabyycdxx", "za") = 0
	 * StringUtils.indexOfAny("zzabyycdxx", "by") = 3
	 * StringUtils.indexOfAny("aba", "z")         = -1
	 * </pre>
	 *
	 * @param cs          the CharSequence to check, may be null
	 * @param searchChars the chars to search for, may be null
	 * @return the index of any of the chars, -1 if no match or null input
	 * @since 2.0
	 * @since 3.0 Changed signature from indexOfAny(String, String) to
	 *        indexOfAny(CharSequence, String)
	 */
	public static int indexOfAny(final CharSequence cs, final String searchChars) {
		if (isEmpty(cs) || isEmpty(searchChars)) {
			return INDEX_NOT_FOUND;
		}
		return indexOfAny(cs, searchChars.toCharArray());
	}

	/**
	 * <p>
	 * Searches a CharSequence to find the first index of any character not in the
	 * given set of characters.
	 * </p>
	 *
	 * <p>
	 * A {@code null} CharSequence will return {@code -1}. A {@code null} or zero
	 * length search array will return {@code -1}.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.indexOfAnyBut(null, *)                              = -1
	 * StringUtils.indexOfAnyBut("", *)                                = -1
	 * StringUtils.indexOfAnyBut(*, null)                              = -1
	 * StringUtils.indexOfAnyBut(*, [])                                = -1
	 * StringUtils.indexOfAnyBut("zzabyycdxx", new char[] {'z', 'a'} ) = 3
	 * StringUtils.indexOfAnyBut("aba", new char[] {'z'} )             = 0
	 * StringUtils.indexOfAnyBut("aba", new char[] {'a', 'b'} )        = -1
	 * 
	 * </pre>
	 *
	 * @param cs          the CharSequence to check, may be null
	 * @param searchChars the chars to search for, may be null
	 * @return the index of any of the chars, -1 if no match or null input
	 * @since 2.0
	 * @since 3.0 Changed signature from indexOfAnyBut(String, char[]) to
	 *        indexOfAnyBut(CharSequence, char...)
	 */
	public static int indexOfAnyBut(final CharSequence cs, final char... searchChars) {
		if (isEmpty(cs) || searchChars.length == 0) {
			return INDEX_NOT_FOUND;
		}
		final int csLen = cs.length();
		final int csLast = csLen - 1;
		final int searchLen = searchChars.length;
		final int searchLast = searchLen - 1;
		outer: for (int i = 0; i < csLen; i++) {
			final char ch = cs.charAt(i);
			for (int j = 0; j < searchLen; j++) {
				if (searchChars[j] == ch) {
					if (i < csLast && j < searchLast && Character.isHighSurrogate(ch)) {
						if (searchChars[j + 1] == cs.charAt(i + 1)) {
							continue outer;
						}
					} else {
						continue outer;
					}
				}
			}
			return i;
		}
		return INDEX_NOT_FOUND;
	}

	/**
	 * <p>
	 * Search a CharSequence to find the first index of any character not in the
	 * given set of characters.
	 * </p>
	 *
	 * <p>
	 * A {@code null} CharSequence will return {@code -1}. A {@code null} or empty
	 * search string will return {@code -1}.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.indexOfAnyBut(null, *)            = -1
	 * StringUtils.indexOfAnyBut("", *)              = -1
	 * StringUtils.indexOfAnyBut(*, null)            = -1
	 * StringUtils.indexOfAnyBut(*, "")              = -1
	 * StringUtils.indexOfAnyBut("zzabyycdxx", "za") = 3
	 * StringUtils.indexOfAnyBut("zzabyycdxx", "")   = -1
	 * StringUtils.indexOfAnyBut("aba", "ab")        = -1
	 * </pre>
	 *
	 * @param seq         the CharSequence to check, may be null
	 * @param searchChars the chars to search for, may be null
	 * @return the index of any of the chars, -1 if no match or null input
	 * @since 2.0
	 * @since 3.0 Changed signature from indexOfAnyBut(String, String) to
	 *        indexOfAnyBut(CharSequence, CharSequence)
	 */
	public static int indexOfAnyBut(final CharSequence seq, final CharSequence searchChars) {
		if (isEmpty(seq) || isEmpty(searchChars)) {
			return INDEX_NOT_FOUND;
		}
		final int strLen = seq.length();
		for (int i = 0; i < strLen; i++) {
			final char ch = seq.charAt(i);
			final boolean chFound = CharSequenceUtils.indexOf(searchChars, ch, 0) >= 0;
			if (i + 1 < strLen && Character.isHighSurrogate(ch)) {
				final char ch2 = seq.charAt(i + 1);
				if (chFound && CharSequenceUtils.indexOf(searchChars, ch2, 0) < 0) {
					return i;
				}
			} else if (!chFound) {
				return i;
			}
		}
		return INDEX_NOT_FOUND;
	}

	/**
	 * <p>
	 * Compares all CharSequences in an array and returns the index at which the
	 * CharSequences begin to differ.
	 * </p>
	 *
	 * <p>
	 * For example, {@code indexOfDifference(new String[] {"i am a machine", "i am a
	 * robot"}) -> 7}
	 * </p>
	 *
	 * <pre>
	 * StringUtils.indexOfDifference(null) = -1
	 * StringUtils.indexOfDifference(new String[] {}) = -1
	 * StringUtils.indexOfDifference(new String[] {"abc"}) = -1
	 * StringUtils.indexOfDifference(new String[] {null, null}) = -1
	 * StringUtils.indexOfDifference(new String[] {"", ""}) = -1
	 * StringUtils.indexOfDifference(new String[] {"", null}) = 0
	 * StringUtils.indexOfDifference(new String[] {"abc", null, null}) = 0
	 * StringUtils.indexOfDifference(new String[] {null, null, "abc"}) = 0
	 * StringUtils.indexOfDifference(new String[] {"", "abc"}) = 0
	 * StringUtils.indexOfDifference(new String[] {"abc", ""}) = 0
	 * StringUtils.indexOfDifference(new String[] {"abc", "abc"}) = -1
	 * StringUtils.indexOfDifference(new String[] {"abc", "a"}) = 1
	 * StringUtils.indexOfDifference(new String[] {"ab", "abxyz"}) = 2
	 * StringUtils.indexOfDifference(new String[] {"abcde", "abxyz"}) = 2
	 * StringUtils.indexOfDifference(new String[] {"abcde", "xyz"}) = 0
	 * StringUtils.indexOfDifference(new String[] {"xyz", "abcde"}) = 0
	 * StringUtils.indexOfDifference(new String[] {"i am a machine", "i am a robot"}) = 7
	 * </pre>
	 *
	 * @param css array of CharSequences, entries may be null
	 * @return the index where the strings begin to differ; -1 if they are all equal
	 * @since 2.4
	 * @since 3.0 Changed signature from indexOfDifference(String...) to
	 *        indexOfDifference(CharSequence...)
	 */
	public static int indexOfDifference(final CharSequence... css) {
		if (css.length <= 1) {
			return INDEX_NOT_FOUND;
		}
		boolean anyStringNull = false;
		boolean allStringsNull = true;
		final int arrayLen = css.length;
		int shortestStrLen = Integer.MAX_VALUE;
		int longestStrLen = 0;

		// find the min and max string lengths; this avoids checking to make
		// sure we are not exceeding the length of the string each time through
		// the bottom loop.
		for (final CharSequence cs : css) {
			if (cs == null) {
				anyStringNull = true;
				shortestStrLen = 0;
			} else {
				allStringsNull = false;
				shortestStrLen = Math.min(cs.length(), shortestStrLen);
				longestStrLen = Math.max(cs.length(), longestStrLen);
			}
		}

		// handle lists containing all nulls or all empty strings
		if (allStringsNull || longestStrLen == 0 && !anyStringNull) {
			return INDEX_NOT_FOUND;
		}

		// handle lists containing some nulls or some empty strings
		if (shortestStrLen == 0) {
			return 0;
		}

		// find the position with the first difference across all strings
		int firstDiff = -1;
		for (int stringPos = 0; stringPos < shortestStrLen; stringPos++) {
			final char comparisonChar = css[0].charAt(stringPos);
			for (int arrayPos = 1; arrayPos < arrayLen; arrayPos++) {
				if (css[arrayPos].charAt(stringPos) != comparisonChar) {
					firstDiff = stringPos;
					break;
				}
			}
			if (firstDiff != -1) {
				break;
			}
		}

		if (firstDiff == -1 && shortestStrLen != longestStrLen) {
			// we compared all of the characters up to the length of the
			// shortest string and didn't find a match, but the string lengths
			// vary, so return the length of the shortest string.
			return shortestStrLen;
		}
		return firstDiff;
	}

	/**
	 * <p>
	 * Compares two CharSequences, and returns the index at which the CharSequences
	 * begin to differ.
	 * </p>
	 *
	 * <p>
	 * For example, {@code indexOfDifference("i am a machine", "i am a robot") -> 7}
	 * </p>
	 *
	 * <pre>
	 * StringUtils.indexOfDifference(null, null) = -1
	 * StringUtils.indexOfDifference("", "") = -1
	 * StringUtils.indexOfDifference("", "abc") = 0
	 * StringUtils.indexOfDifference("abc", "") = 0
	 * StringUtils.indexOfDifference("abc", "abc") = -1
	 * StringUtils.indexOfDifference("ab", "abxyz") = 2
	 * StringUtils.indexOfDifference("abcde", "abxyz") = 2
	 * StringUtils.indexOfDifference("abcde", "xyz") = 0
	 * </pre>
	 *
	 * @param cs1 the first CharSequence, may be null
	 * @param cs2 the second CharSequence, may be null
	 * @return the index where cs1 and cs2 begin to differ; -1 if they are equal
	 * @since 2.0
	 * @since 3.0 Changed signature from indexOfDifference(String, String) to
	 *        indexOfDifference(CharSequence, CharSequence)
	 */
	public static int indexOfDifference(final CharSequence cs1, final CharSequence cs2) {
		if (cs1 == cs2) {
			return INDEX_NOT_FOUND;
		}
		if (cs1 == null || cs2 == null) {
			return 0;
		}
		int i;
		for (i = 0; i < cs1.length() && i < cs2.length(); ++i) {
			if (cs1.charAt(i) != cs2.charAt(i)) {
				break;
			}
		}
		if (i < cs2.length() || i < cs1.length()) {
			return i;
		}
		return INDEX_NOT_FOUND;
	}

	/**
	 * <p>
	 * Case in-sensitive find of the first index within a CharSequence.
	 * </p>
	 *
	 * <p>
	 * A {@code null} CharSequence will return {@code -1}. A negative start position
	 * is treated as zero. An empty ("") search CharSequence always matches. A start
	 * position greater than the string length only matches an empty search
	 * CharSequence.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.indexOfIgnoreCase(null, *)          = -1
	 * StringUtils.indexOfIgnoreCase(*, null)          = -1
	 * StringUtils.indexOfIgnoreCase("", "")           = 0
	 * StringUtils.indexOfIgnoreCase("aabaabaa", "a")  = 0
	 * StringUtils.indexOfIgnoreCase("aabaabaa", "b")  = 2
	 * StringUtils.indexOfIgnoreCase("aabaabaa", "ab") = 1
	 * </pre>
	 *
	 * @param str       the CharSequence to check, may be null
	 * @param searchStr the CharSequence to find, may be null
	 * @return the first index of the search CharSequence, -1 if no match or
	 *         {@code null} string input
	 * @since 2.5
	 * @since 3.0 Changed signature from indexOfIgnoreCase(String, String) to
	 *        indexOfIgnoreCase(CharSequence, CharSequence)
	 */
	public static int indexOfIgnoreCase(final CharSequence str, final CharSequence searchStr) {
		return indexOfIgnoreCase(str, searchStr, 0);
	}

	/**
	 * <p>
	 * Case in-sensitive find of the first index within a CharSequence from the
	 * specified position.
	 * </p>
	 *
	 * <p>
	 * A {@code null} CharSequence will return {@code -1}. A negative start position
	 * is treated as zero. An empty ("") search CharSequence always matches. A start
	 * position greater than the string length only matches an empty search
	 * CharSequence.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.indexOfIgnoreCase(null, *, *)          = -1
	 * StringUtils.indexOfIgnoreCase(*, null, *)          = -1
	 * StringUtils.indexOfIgnoreCase("", "", 0)           = 0
	 * StringUtils.indexOfIgnoreCase("aabaabaa", "A", 0)  = 0
	 * StringUtils.indexOfIgnoreCase("aabaabaa", "B", 0)  = 2
	 * StringUtils.indexOfIgnoreCase("aabaabaa", "AB", 0) = 1
	 * StringUtils.indexOfIgnoreCase("aabaabaa", "B", 3)  = 5
	 * StringUtils.indexOfIgnoreCase("aabaabaa", "B", 9)  = -1
	 * StringUtils.indexOfIgnoreCase("aabaabaa", "B", -1) = 2
	 * StringUtils.indexOfIgnoreCase("aabaabaa", "", 2)   = 2
	 * StringUtils.indexOfIgnoreCase("abc", "", 9)        = -1
	 * </pre>
	 *
	 * @param str       the CharSequence to check, may be null
	 * @param searchStr the CharSequence to find, may be null
	 * @param startPos  the start position, negative treated as zero
	 * @return the first index of the search CharSequence (always &ge; startPos), -1
	 *         if no match or {@code null} string input
	 * @since 2.5
	 * @since 3.0 Changed signature from indexOfIgnoreCase(String, String, int) to
	 *        indexOfIgnoreCase(CharSequence, CharSequence, int)
	 */
	public static int indexOfIgnoreCase(final CharSequence str, final CharSequence searchStr, int startPos) {
		if (str == null || searchStr == null) {
			return INDEX_NOT_FOUND;
		}
		if (startPos < 0) {
			startPos = 0;
		}
		final int endLimit = str.length() - searchStr.length() + 1;
		if (startPos > endLimit) {
			return INDEX_NOT_FOUND;
		}
		if (searchStr.length() == 0) {
			return startPos;
		}
		for (int i = startPos; i < endLimit; i++) {
			if (CharSequenceUtils.regionMatches(str, true, i, searchStr, 0, searchStr.length())) {
				return i;
			}
		}
		return INDEX_NOT_FOUND;
	}

	/**
	 * <p>
	 * Checks if all of the CharSequences are empty (""), null or whitespace only.
	 * </p>
	 *
	 * <p>
	 * Whitespace is defined by {@link Character#isWhitespace(char)}.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.isAllBlank(null)             = true
	 * StringUtils.isAllBlank(null, "foo")      = false
	 * StringUtils.isAllBlank(null, null)       = true
	 * StringUtils.isAllBlank("", "bar")        = false
	 * StringUtils.isAllBlank("bob", "")        = false
	 * StringUtils.isAllBlank("  bob  ", null)  = false
	 * StringUtils.isAllBlank(" ", "bar")       = false
	 * StringUtils.isAllBlank("foo", "bar")     = false
	 * StringUtils.isAllBlank(new String[] {})  = true
	 * </pre>
	 *
	 * @param css the CharSequences to check, may be null or empty
	 * @return {@code true} if all of the CharSequences are empty or null or
	 *         whitespace only
	 * @since 3.6
	 */
	public static boolean isAllBlank(final CharSequence... css) {
		if (css.length == 0) {
			return true;
		}
		for (final CharSequence cs : css) {
			if (isNotBlank(cs)) {
				return false;
			}
		}
		return true;
	}

	/**
	 * <p>
	 * Checks if all of the CharSequences are empty ("") or null.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.isAllEmpty(null)             = true
	 * StringUtils.isAllEmpty(null, "")         = true
	 * StringUtils.isAllEmpty(new String[] {})  = true
	 * StringUtils.isAllEmpty(null, "foo")      = false
	 * StringUtils.isAllEmpty("", "bar")        = false
	 * StringUtils.isAllEmpty("bob", "")        = false
	 * StringUtils.isAllEmpty("  bob  ", null)  = false
	 * StringUtils.isAllEmpty(" ", "bar")       = false
	 * StringUtils.isAllEmpty("foo", "bar")     = false
	 * </pre>
	 *
	 * @param css the CharSequences to check, may be null or empty
	 * @return {@code true} if all of the CharSequences are empty or null
	 * @since 3.6
	 */
	public static boolean isAllEmpty(final CharSequence... css) {
		if (css.length == 0) {
			return true;
		}
		for (final CharSequence cs : css) {
			if (isNotEmpty(cs)) {
				return false;
			}
		}
		return true;
	}

	/**
	 * <p>
	 * Checks if the CharSequence contains only lowercase characters.
	 * </p>
	 *
	 * <p>
	 * {@code null} will return {@code false}. An empty CharSequence (length()=0)
	 * will return {@code false}.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.isAllLowerCase(null)   = false
	 * StringUtils.isAllLowerCase("")     = false
	 * StringUtils.isAllLowerCase("  ")   = false
	 * StringUtils.isAllLowerCase("abc")  = true
	 * StringUtils.isAllLowerCase("abC")  = false
	 * StringUtils.isAllLowerCase("ab c") = false
	 * StringUtils.isAllLowerCase("ab1c") = false
	 * StringUtils.isAllLowerCase("ab/c") = false
	 * </pre>
	 *
	 * @param cs the CharSequence to check, may be null
	 * @return {@code true} if only contains lowercase characters, and is non-null
	 * @since 2.5
	 * @since 3.0 Changed signature from isAllLowerCase(String) to
	 *        isAllLowerCase(CharSequence)
	 */
	public static boolean isAllLowerCase(final CharSequence cs) {
		if (isEmpty(cs)) {
			return false;
		}
		final int sz = cs.length();
		for (int i = 0; i < sz; i++) {
			if (!Character.isLowerCase(cs.charAt(i))) {
				return false;
			}
		}
		return true;
	}

	/**
	 * <p>
	 * Checks if the CharSequence contains only uppercase characters.
	 * </p>
	 *
	 * <p>
	 * {@code null} will return {@code false}. An empty String (length()=0) will
	 * return {@code false}.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.isAllUpperCase(null)   = false
	 * StringUtils.isAllUpperCase("")     = false
	 * StringUtils.isAllUpperCase("  ")   = false
	 * StringUtils.isAllUpperCase("ABC")  = true
	 * StringUtils.isAllUpperCase("aBC")  = false
	 * StringUtils.isAllUpperCase("A C")  = false
	 * StringUtils.isAllUpperCase("A1C")  = false
	 * StringUtils.isAllUpperCase("A/C")  = false
	 * </pre>
	 *
	 * @param cs the CharSequence to check, may be null
	 * @return {@code true} if only contains uppercase characters, and is non-null
	 * @since 2.5
	 * @since 3.0 Changed signature from isAllUpperCase(String) to
	 *        isAllUpperCase(CharSequence)
	 */
	public static boolean isAllUpperCase(final CharSequence cs) {
		if (isEmpty(cs)) {
			return false;
		}
		final int sz = cs.length();
		for (int i = 0; i < sz; i++) {
			if (!Character.isUpperCase(cs.charAt(i))) {
				return false;
			}
		}
		return true;
	}

	/**
	 * <p>
	 * Checks if the CharSequence contains only Unicode letters.
	 * </p>
	 *
	 * <p>
	 * {@code null} will return {@code false}. An empty CharSequence (length()=0)
	 * will return {@code false}.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.isAlpha(null)   = false
	 * StringUtils.isAlpha("")     = false
	 * StringUtils.isAlpha("  ")   = false
	 * StringUtils.isAlpha("abc")  = true
	 * StringUtils.isAlpha("ab2c") = false
	 * StringUtils.isAlpha("ab-c") = false
	 * </pre>
	 *
	 * @param cs the CharSequence to check, may be null
	 * @return {@code true} if only contains letters, and is non-null
	 * @since 3.0 Changed signature from isAlpha(String) to isAlpha(CharSequence)
	 * @since 3.0 Changed "" to return false and not true
	 */
	public static boolean isAlpha(final CharSequence cs) {
		if (isEmpty(cs)) {
			return false;
		}
		final int sz = cs.length();
		for (int i = 0; i < sz; i++) {
			if (!Character.isLetter(cs.charAt(i))) {
				return false;
			}
		}
		return true;
	}

	/**
	 * <p>
	 * Checks if the CharSequence contains only Unicode letters or digits.
	 * </p>
	 *
	 * <p>
	 * {@code null} will return {@code false}. An empty CharSequence (length()=0)
	 * will return {@code false}.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.isAlphanumeric(null)   = false
	 * StringUtils.isAlphanumeric("")     = false
	 * StringUtils.isAlphanumeric("  ")   = false
	 * StringUtils.isAlphanumeric("abc")  = true
	 * StringUtils.isAlphanumeric("ab c") = false
	 * StringUtils.isAlphanumeric("ab2c") = true
	 * StringUtils.isAlphanumeric("ab-c") = false
	 * </pre>
	 *
	 * @param cs the CharSequence to check, may be null
	 * @return {@code true} if only contains letters or digits, and is non-null
	 * @since 3.0 Changed signature from isAlphanumeric(String) to
	 *        isAlphanumeric(CharSequence)
	 * @since 3.0 Changed "" to return false and not true
	 */
	public static boolean isAlphanumeric(final CharSequence cs) {
		if (isEmpty(cs)) {
			return false;
		}
		final int sz = cs.length();
		for (int i = 0; i < sz; i++) {
			if (!Character.isLetterOrDigit(cs.charAt(i))) {
				return false;
			}
		}
		return true;
	}

	/**
	 * <p>
	 * Checks if the CharSequence contains only Unicode letters, digits or space
	 * ({@code ' '}).
	 * </p>
	 *
	 * <p>
	 * {@code null} will return {@code false}. An empty CharSequence (length()=0)
	 * will return {@code true}.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.isAlphanumericSpace(null)   = false
	 * StringUtils.isAlphanumericSpace("")     = true
	 * StringUtils.isAlphanumericSpace("  ")   = true
	 * StringUtils.isAlphanumericSpace("abc")  = true
	 * StringUtils.isAlphanumericSpace("ab c") = true
	 * StringUtils.isAlphanumericSpace("ab2c") = true
	 * StringUtils.isAlphanumericSpace("ab-c") = false
	 * </pre>
	 *
	 * @param cs the CharSequence to check, may be null
	 * @return {@code true} if only contains letters, digits or space, and is
	 *         non-null
	 * @since 3.0 Changed signature from isAlphanumericSpace(String) to
	 *        isAlphanumericSpace(CharSequence)
	 */
	public static boolean isAlphanumericSpace(final CharSequence cs) {
		if (cs == null) {
			return false;
		}
		final int sz = cs.length();
		for (int i = 0; i < sz; i++) {
			final char nowChar = cs.charAt(i);
			if (nowChar != ' ' && !Character.isLetterOrDigit(nowChar)) {
				return false;
			}
		}
		return true;
	}

	/**
	 * <p>
	 * Checks if the CharSequence contains only Unicode letters and space (' ').
	 * </p>
	 *
	 * <p>
	 * {@code null} will return {@code false} An empty CharSequence (length()=0)
	 * will return {@code true}.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.isAlphaSpace(null)   = false
	 * StringUtils.isAlphaSpace("")     = true
	 * StringUtils.isAlphaSpace("  ")   = true
	 * StringUtils.isAlphaSpace("abc")  = true
	 * StringUtils.isAlphaSpace("ab c") = true
	 * StringUtils.isAlphaSpace("ab2c") = false
	 * StringUtils.isAlphaSpace("ab-c") = false
	 * </pre>
	 *
	 * @param cs the CharSequence to check, may be null
	 * @return {@code true} if only contains letters and space, and is non-null
	 * @since 3.0 Changed signature from isAlphaSpace(String) to
	 *        isAlphaSpace(CharSequence)
	 */
	public static boolean isAlphaSpace(final CharSequence cs) {
		if (cs == null) {
			return false;
		}
		final int sz = cs.length();
		for (int i = 0; i < sz; i++) {
			final char nowChar = cs.charAt(i);
			if (nowChar != ' ' && !Character.isLetter(nowChar)) {
				return false;
			}
		}
		return true;
	}

	/**
	 * <p>
	 * Checks if any of the CharSequences are empty ("") or null or whitespace only.
	 * </p>
	 *
	 * <p>
	 * Whitespace is defined by {@link Character#isWhitespace(char)}.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.isAnyBlank((String) null)    = true
	 * StringUtils.isAnyBlank((String[]) null)  = false
	 * StringUtils.isAnyBlank(null, "foo")      = true
	 * StringUtils.isAnyBlank(null, null)       = true
	 * StringUtils.isAnyBlank("", "bar")        = true
	 * StringUtils.isAnyBlank("bob", "")        = true
	 * StringUtils.isAnyBlank("  bob  ", null)  = true
	 * StringUtils.isAnyBlank(" ", "bar")       = true
	 * StringUtils.isAnyBlank(new String[] {})  = false
	 * StringUtils.isAnyBlank(new String[]{""}) = true
	 * StringUtils.isAnyBlank("foo", "bar")     = false
	 * </pre>
	 *
	 * @param css the CharSequences to check, may be null or empty
	 * @return {@code true} if any of the CharSequences are empty or null or
	 *         whitespace only
	 * @since 3.2
	 */
	public static boolean isAnyBlank(final CharSequence... css) {
		if (css.length == 0) {
			return false;
		}
		for (final CharSequence cs : css) {
			if (isBlank(cs)) {
				return true;
			}
		}
		return false;
	}

	/**
	 * <p>
	 * Checks if any of the CharSequences are empty ("") or null.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.isAnyEmpty((String) null)    = true
	 * StringUtils.isAnyEmpty((String[]) null)  = false
	 * StringUtils.isAnyEmpty(null, "foo")      = true
	 * StringUtils.isAnyEmpty("", "bar")        = true
	 * StringUtils.isAnyEmpty("bob", "")        = true
	 * StringUtils.isAnyEmpty("  bob  ", null)  = true
	 * StringUtils.isAnyEmpty(" ", "bar")       = false
	 * StringUtils.isAnyEmpty("foo", "bar")     = false
	 * StringUtils.isAnyEmpty(new String[]{})   = false
	 * StringUtils.isAnyEmpty(new String[]{""}) = true
	 * </pre>
	 *
	 * @param css the CharSequences to check, may be null or empty
	 * @return {@code true} if any of the CharSequences are empty or null
	 * @since 3.2
	 */
	public static boolean isAnyEmpty(final CharSequence... css) {
		if (css.length == 0) {
			return false;
		}
		for (final CharSequence cs : css) {
			if (isEmpty(cs)) {
				return true;
			}
		}
		return false;
	}

	/**
	 * <p>
	 * Checks if the CharSequence contains only ASCII printable characters.
	 * </p>
	 *
	 * <p>
	 * {@code null} will return {@code false}. An empty CharSequence (length()=0)
	 * will return {@code true}.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.isAsciiPrintable(null)     = false
	 * StringUtils.isAsciiPrintable("")       = true
	 * StringUtils.isAsciiPrintable(" ")      = true
	 * StringUtils.isAsciiPrintable("Ceki")   = true
	 * StringUtils.isAsciiPrintable("ab2c")   = true
	 * StringUtils.isAsciiPrintable("!ab-c~") = true
	 * StringUtils.isAsciiPrintable("\u0020") = true
	 * StringUtils.isAsciiPrintable("\u0021") = true
	 * StringUtils.isAsciiPrintable("\u007e") = true
	 * StringUtils.isAsciiPrintable("\u007f") = false
	 * StringUtils.isAsciiPrintable("Ceki G\u00fclc\u00fc") = false
	 * </pre>
	 *
	 * @param cs the CharSequence to check, may be null
	 * @return {@code true} if every character is in the range 32 thru 126
	 * @since 2.1
	 * @since 3.0 Changed signature from isAsciiPrintable(String) to
	 *        isAsciiPrintable(CharSequence)
	 */
	public static boolean isAsciiPrintable(final CharSequence cs) {
		if (cs == null) {
			return false;
		}
		final int sz = cs.length();
		for (int i = 0; i < sz; i++) {
			if (!CharUtils.isAsciiPrintable(cs.charAt(i))) {
				return false;
			}
		}
		return true;
	}

	/**
	 * <p>
	 * Checks if a CharSequence is empty (""), null or whitespace only.
	 * </p>
	 *
	 * <p>
	 * Whitespace is defined by {@link Character#isWhitespace(char)}.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.isBlank(null)      = true
	 * StringUtils.isBlank("")        = true
	 * StringUtils.isBlank(" ")       = true
	 * StringUtils.isBlank("bob")     = false
	 * StringUtils.isBlank("  bob  ") = false
	 * </pre>
	 *
	 * @param cs the CharSequence to check, may be null
	 * @return {@code true} if the CharSequence is null, empty or whitespace only
	 * @since 2.0
	 * @since 3.0 Changed signature from isBlank(String) to isBlank(CharSequence)
	 */
	public static boolean isBlank(final CharSequence cs) {
		final int strLen = length(cs);
		if (strLen == 0) {
			return true;
		}
		for (int i = 0; i < strLen; i++) {
			if (!Character.isWhitespace(cs.charAt(i))) {
				return false;
			}
		}
		return true;
	}

	/**
	 * <p>
	 * Checks if a CharSequence is empty ("") or null.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.isEmpty(null)      = true
	 * StringUtils.isEmpty("")        = true
	 * StringUtils.isEmpty(" ")       = false
	 * StringUtils.isEmpty("bob")     = false
	 * StringUtils.isEmpty("  bob  ") = false
	 * </pre>
	 *
	 * <p>
	 * NOTE: This method changed in Lang version 2.0. It no longer trims the
	 * CharSequence. That functionality is available in isBlank().
	 * </p>
	 *
	 * @param cs the CharSequence to check, may be null
	 * @return {@code true} if the CharSequence is empty or null
	 * @since 3.0 Changed signature from isEmpty(String) to isEmpty(CharSequence)
	 */
	public static boolean isEmpty(final CharSequence cs) {
		return cs == null || cs.length() == 0;
	}

	/**
	 * <p>
	 * Checks if the CharSequence contains mixed casing of both uppercase and
	 * lowercase characters.
	 * </p>
	 *
	 * <p>
	 * {@code null} will return {@code false}. An empty CharSequence
	 * ({@code length()=0}) will return {@code false}.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.isMixedCase(null)    = false
	 * StringUtils.isMixedCase("")      = false
	 * StringUtils.isMixedCase("ABC")   = false
	 * StringUtils.isMixedCase("abc")   = false
	 * StringUtils.isMixedCase("aBc")   = true
	 * StringUtils.isMixedCase("A c")   = true
	 * StringUtils.isMixedCase("A1c")   = true
	 * StringUtils.isMixedCase("a/C")   = true
	 * StringUtils.isMixedCase("aC\t")  = true
	 * </pre>
	 *
	 * @param cs the CharSequence to check, may be null
	 * @return {@code true} if the CharSequence contains both uppercase and
	 *         lowercase characters
	 * @since 3.5
	 */
	public static boolean isMixedCase(final CharSequence cs) {
		if (isEmpty(cs) || cs.length() == 1) {
			return false;
		}
		boolean containsUppercase = false;
		boolean containsLowercase = false;
		final int sz = cs.length();
		for (int i = 0; i < sz; i++) {
			if (containsUppercase && containsLowercase) {
				return true;
			} else if (Character.isUpperCase(cs.charAt(i))) {
				containsUppercase = true;
			} else if (Character.isLowerCase(cs.charAt(i))) {
				containsLowercase = true;
			}
		}
		return containsUppercase && containsLowercase;
	}

	/**
	 * <p>
	 * Checks if none of the CharSequences are empty (""), null or whitespace only.
	 * </p>
	 *
	 * <p>
	 * Whitespace is defined by {@link Character#isWhitespace(char)}.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.isNoneBlank((String) null)    = false
	 * StringUtils.isNoneBlank((String[]) null)  = true
	 * StringUtils.isNoneBlank(null, "foo")      = false
	 * StringUtils.isNoneBlank(null, null)       = false
	 * StringUtils.isNoneBlank("", "bar")        = false
	 * StringUtils.isNoneBlank("bob", "")        = false
	 * StringUtils.isNoneBlank("  bob  ", null)  = false
	 * StringUtils.isNoneBlank(" ", "bar")       = false
	 * StringUtils.isNoneBlank(new String[] {})  = true
	 * StringUtils.isNoneBlank(new String[]{""}) = false
	 * StringUtils.isNoneBlank("foo", "bar")     = true
	 * </pre>
	 *
	 * @param css the CharSequences to check, may be null or empty
	 * @return {@code true} if none of the CharSequences are empty or null or
	 *         whitespace only
	 * @since 3.2
	 */
	public static boolean isNoneBlank(final CharSequence... css) {
		return !isAnyBlank(css);
	}

	/**
	 * <p>
	 * Checks if none of the CharSequences are empty ("") or null.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.isNoneEmpty((String) null)    = false
	 * StringUtils.isNoneEmpty((String[]) null)  = true
	 * StringUtils.isNoneEmpty(null, "foo")      = false
	 * StringUtils.isNoneEmpty("", "bar")        = false
	 * StringUtils.isNoneEmpty("bob", "")        = false
	 * StringUtils.isNoneEmpty("  bob  ", null)  = false
	 * StringUtils.isNoneEmpty(new String[] {})  = true
	 * StringUtils.isNoneEmpty(new String[]{""}) = false
	 * StringUtils.isNoneEmpty(" ", "bar")       = true
	 * StringUtils.isNoneEmpty("foo", "bar")     = true
	 * </pre>
	 *
	 * @param css the CharSequences to check, may be null or empty
	 * @return {@code true} if none of the CharSequences are empty or null
	 * @since 3.2
	 */
	public static boolean isNoneEmpty(final CharSequence... css) {
		return !isAnyEmpty(css);
	}

	/**
	 * <p>
	 * Checks if a CharSequence is not empty (""), not null and not whitespace only.
	 * </p>
	 *
	 * <p>
	 * Whitespace is defined by {@link Character#isWhitespace(char)}.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.isNotBlank(null)      = false
	 * StringUtils.isNotBlank("")        = false
	 * StringUtils.isNotBlank(" ")       = false
	 * StringUtils.isNotBlank("bob")     = true
	 * StringUtils.isNotBlank("  bob  ") = true
	 * </pre>
	 *
	 * @param cs the CharSequence to check, may be null
	 * @return {@code true} if the CharSequence is not empty and not null and not
	 *         whitespace only
	 * @since 2.0
	 * @since 3.0 Changed signature from isNotBlank(String) to
	 *        isNotBlank(CharSequence)
	 */
	public static boolean isNotBlank(final CharSequence cs) {
		return !isBlank(cs);
	}

	/**
	 * <p>
	 * Checks if a CharSequence is not empty ("") and not null.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.isNotEmpty(null)      = false
	 * StringUtils.isNotEmpty("")        = false
	 * StringUtils.isNotEmpty(" ")       = true
	 * StringUtils.isNotEmpty("bob")     = true
	 * StringUtils.isNotEmpty("  bob  ") = true
	 * </pre>
	 *
	 * @param cs the CharSequence to check, may be null
	 * @return {@code true} if the CharSequence is not empty and not null
	 * @since 3.0 Changed signature from isNotEmpty(String) to
	 *        isNotEmpty(CharSequence)
	 */
	public static boolean isNotEmpty(final CharSequence cs) {
		return !isEmpty(cs);
	}

	/**
	 * <p>
	 * Checks if the CharSequence contains only Unicode digits. A decimal point is
	 * not a Unicode digit and returns false.
	 * </p>
	 *
	 * <p>
	 * {@code null} will return {@code false}. An empty CharSequence (length()=0)
	 * will return {@code false}.
	 * </p>
	 *
	 * <p>
	 * Note that the method does not allow for a leading sign, either positive or
	 * negative. Also, if a String passes the numeric test, it may still generate a
	 * NumberFormatException when parsed by Integer.parseInt or Long.parseLong, e.g.
	 * if the value is outside the range for int or long respectively.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.isNumeric(null)   = false
	 * StringUtils.isNumeric("")     = false
	 * StringUtils.isNumeric("  ")   = false
	 * StringUtils.isNumeric("123")  = true
	 * StringUtils.isNumeric("\u0967\u0968\u0969")  = true
	 * StringUtils.isNumeric("12 3") = false
	 * StringUtils.isNumeric("ab2c") = false
	 * StringUtils.isNumeric("12-3") = false
	 * StringUtils.isNumeric("12.3") = false
	 * StringUtils.isNumeric("-123") = false
	 * StringUtils.isNumeric("+123") = false
	 * </pre>
	 *
	 * @param cs the CharSequence to check, may be null
	 * @return {@code true} if only contains digits, and is non-null
	 * @since 3.0 Changed signature from isNumeric(String) to
	 *        isNumeric(CharSequence)
	 * @since 3.0 Changed "" to return false and not true
	 */
	public static boolean isNumeric(final CharSequence cs) {
		if (isEmpty(cs)) {
			return false;
		}
		final int sz = cs.length();
		for (int i = 0; i < sz; i++) {
			if (!Character.isDigit(cs.charAt(i))) {
				return false;
			}
		}
		return true;
	}

	/**
	 * <p>
	 * Checks if the CharSequence contains only Unicode digits or space
	 * ({@code ' '}). A decimal point is not a Unicode digit and returns false.
	 * </p>
	 *
	 * <p>
	 * {@code null} will return {@code false}. An empty CharSequence (length()=0)
	 * will return {@code true}.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.isNumericSpace(null)   = false
	 * StringUtils.isNumericSpace("")     = true
	 * StringUtils.isNumericSpace("  ")   = true
	 * StringUtils.isNumericSpace("123")  = true
	 * StringUtils.isNumericSpace("12 3") = true
	 * StringUtils.isNumericSpace("\u0967\u0968\u0969")  = true
	 * StringUtils.isNumericSpace("\u0967\u0968 \u0969")  = true
	 * StringUtils.isNumericSpace("ab2c") = false
	 * StringUtils.isNumericSpace("12-3") = false
	 * StringUtils.isNumericSpace("12.3") = false
	 * </pre>
	 *
	 * @param cs the CharSequence to check, may be null
	 * @return {@code true} if only contains digits or space, and is non-null
	 * @since 3.0 Changed signature from isNumericSpace(String) to
	 *        isNumericSpace(CharSequence)
	 */
	public static boolean isNumericSpace(final CharSequence cs) {
		if (cs == null) {
			return false;
		}
		final int sz = cs.length();
		for (int i = 0; i < sz; i++) {
			final char nowChar = cs.charAt(i);
			if (nowChar != ' ' && !Character.isDigit(nowChar)) {
				return false;
			}
		}
		return true;
	}

	/**
	 * <p>
	 * Checks if the CharSequence contains only whitespace.
	 * </p>
	 *
	 * <p>
	 * Whitespace is defined by {@link Character#isWhitespace(char)}.
	 * </p>
	 *
	 * <p>
	 * {@code null} will return {@code false}. An empty CharSequence (length()=0)
	 * will return {@code true}.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.isWhitespace(null)   = false
	 * StringUtils.isWhitespace("")     = true
	 * StringUtils.isWhitespace("  ")   = true
	 * StringUtils.isWhitespace("abc")  = false
	 * StringUtils.isWhitespace("ab2c") = false
	 * StringUtils.isWhitespace("ab-c") = false
	 * </pre>
	 *
	 * @param cs the CharSequence to check, may be null
	 * @return {@code true} if only contains whitespace, and is non-null
	 * @since 2.0
	 * @since 3.0 Changed signature from isWhitespace(String) to
	 *        isWhitespace(CharSequence)
	 */
	public static boolean isWhitespace(final CharSequence cs) {
		if (cs == null) {
			return false;
		}
		final int sz = cs.length();
		for (int i = 0; i < sz; i++) {
			if (!Character.isWhitespace(cs.charAt(i))) {
				return false;
			}
		}
		return true;
	}

	/**
	 * <p>
	 * Joins the elements of the provided array into a single String containing the
	 * provided list of elements.
	 * </p>
	 *
	 * <p>
	 * No delimiter is added before or after the list. Null objects or empty strings
	 * within the array are represented by empty strings.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.join(null, *)              = null
	 * StringUtils.join([], *)                = ""
	 * StringUtils.join([null], *)            = ""
	 * StringUtils.join([false, false], ';')  = "false;false"
	 * </pre>
	 *
	 * @param array     the array of values to join together, may be null
	 * @param delimiter the separator character to use
	 * @return the joined String, {@code null} if null array input
	 * @since 3.12.0
	 */
	public static String join(final boolean[] array, final char delimiter) {
		if (array == null) {
			return null;
		}
		return join(array, delimiter, 0, array.length);
	}

	/**
	 * <p>
	 * Joins the elements of the provided array into a single String containing the
	 * provided list of elements.
	 * </p>
	 *
	 * <p>
	 * No delimiter is added before or after the list. Null objects or empty strings
	 * within the array are represented by empty strings.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.join(null, *)                   = null
	 * StringUtils.join([], *)                     = ""
	 * StringUtils.join([null], *)                 = ""
	 * StringUtils.join([true, false, true], ';')  = "true;false;true"
	 * </pre>
	 *
	 * @param array      the array of values to join together, may be null
	 * @param delimiter  the separator character to use
	 * @param startIndex the first index to start joining from. It is an error to
	 *                   pass in a start index past the end of the array
	 * @param endIndex   the index to stop joining from (exclusive). It is an error
	 *                   to pass in an end index past the end of the array
	 * @return the joined String, {@code null} if null array input
	 * @since 3.12.0
	 */
	public static String join(final boolean[] array, final char delimiter, final int startIndex, final int endIndex) {
		if (array == null) {
			return null;
		}
		if (endIndex - startIndex <= 0) {
			return EMPTY;
		}
		final StringJoiner joiner = newStringJoiner(delimiter);
		for (int i = startIndex; i < endIndex; i++) {
			joiner.add(String.valueOf(array[i]));
		}
		return joiner.toString();
	}

	/**
	 * <p>
	 * Joins the elements of the provided array into a single String containing the
	 * provided list of elements.
	 * </p>
	 *
	 * <p>
	 * No delimiter is added before or after the list. Null objects or empty strings
	 * within the array are represented by empty strings.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.join(null, *)               = null
	 * StringUtils.join([], *)                 = ""
	 * StringUtils.join([null], *)             = ""
	 * StringUtils.join([1, 2, 3], ';')  = "1;2;3"
	 * StringUtils.join([1, 2, 3], null) = "123"
	 * </pre>
	 *
	 * @param array     the array of values to join together, may be null
	 * @param delimiter the separator character to use
	 * @return the joined String, {@code null} if null array input
	 * @since 3.2
	 */
	public static String join(final byte[] array, final char delimiter) {
		if (array == null) {
			return null;
		}
		return join(array, delimiter, 0, array.length);
	}

	/**
	 * <p>
	 * Joins the elements of the provided array into a single String containing the
	 * provided list of elements.
	 * </p>
	 *
	 * <p>
	 * No delimiter is added before or after the list. Null objects or empty strings
	 * within the array are represented by empty strings.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.join(null, *)               = null
	 * StringUtils.join([], *)                 = ""
	 * StringUtils.join([null], *)             = ""
	 * StringUtils.join([1, 2, 3], ';')  = "1;2;3"
	 * StringUtils.join([1, 2, 3], null) = "123"
	 * </pre>
	 *
	 * @param array      the array of values to join together, may be null
	 * @param delimiter  the separator character to use
	 * @param startIndex the first index to start joining from. It is an error to
	 *                   pass in a start index past the end of the array
	 * @param endIndex   the index to stop joining from (exclusive). It is an error
	 *                   to pass in an end index past the end of the array
	 * @return the joined String, {@code null} if null array input
	 * @since 3.2
	 */
	public static String join(final byte[] array, final char delimiter, final int startIndex, final int endIndex) {
		if (array == null) {
			return null;
		}
		if (endIndex - startIndex <= 0) {
			return EMPTY;
		}
		final StringJoiner joiner = newStringJoiner(delimiter);
		for (int i = startIndex; i < endIndex; i++) {
			joiner.add(String.valueOf(array[i]));
		}
		return joiner.toString();
	}

	/**
	 * <p>
	 * Joins the elements of the provided array into a single String containing the
	 * provided list of elements.
	 * </p>
	 *
	 * <p>
	 * No delimiter is added before or after the list. Null objects or empty strings
	 * within the array are represented by empty strings.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.join(null, *)               = null
	 * StringUtils.join([], *)                 = ""
	 * StringUtils.join([null], *)             = ""
	 * StringUtils.join([1, 2, 3], ';')  = "1;2;3"
	 * StringUtils.join([1, 2, 3], null) = "123"
	 * </pre>
	 *
	 * @param array     the array of values to join together, may be null
	 * @param delimiter the separator character to use
	 * @return the joined String, {@code null} if null array input
	 * @since 3.2
	 */
	public static String join(final char[] array, final char delimiter) {
		if (array == null) {
			return null;
		}
		return join(array, delimiter, 0, array.length);
	}

	/**
	 * <p>
	 * Joins the elements of the provided array into a single String containing the
	 * provided list of elements.
	 * </p>
	 *
	 * <p>
	 * No delimiter is added before or after the list. Null objects or empty strings
	 * within the array are represented by empty strings.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.join(null, *)               = null
	 * StringUtils.join([], *)                 = ""
	 * StringUtils.join([null], *)             = ""
	 * StringUtils.join([1, 2, 3], ';')  = "1;2;3"
	 * StringUtils.join([1, 2, 3], null) = "123"
	 * </pre>
	 *
	 * @param array      the array of values to join together, may be null
	 * @param delimiter  the separator character to use
	 * @param startIndex the first index to start joining from. It is an error to
	 *                   pass in a start index past the end of the array
	 * @param endIndex   the index to stop joining from (exclusive). It is an error
	 *                   to pass in an end index past the end of the array
	 * @return the joined String, {@code null} if null array input
	 * @since 3.2
	 */
	public static String join(final char[] array, final char delimiter, final int startIndex, final int endIndex) {
		if (array == null) {
			return null;
		}
		if (endIndex - startIndex <= 0) {
			return EMPTY;
		}
		final StringJoiner joiner = newStringJoiner(delimiter);
		for (int i = startIndex; i < endIndex; i++) {
			joiner.add(String.valueOf(array[i]));
		}
		return joiner.toString();
	}

	/**
	 * <p>
	 * Joins the elements of the provided array into a single String containing the
	 * provided list of elements.
	 * </p>
	 *
	 * <p>
	 * No delimiter is added before or after the list. Null objects or empty strings
	 * within the array are represented by empty strings.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.join(null, *)               = null
	 * StringUtils.join([], *)                 = ""
	 * StringUtils.join([null], *)             = ""
	 * StringUtils.join([1, 2, 3], ';')  = "1;2;3"
	 * StringUtils.join([1, 2, 3], null) = "123"
	 * </pre>
	 *
	 * @param array     the array of values to join together, may be null
	 * @param delimiter the separator character to use
	 * @return the joined String, {@code null} if null array input
	 * @since 3.2
	 */
	public static String join(final double[] array, final char delimiter) {
		if (array == null) {
			return null;
		}
		return join(array, delimiter, 0, array.length);
	}

	/**
	 * <p>
	 * Joins the elements of the provided array into a single String containing the
	 * provided list of elements.
	 * </p>
	 *
	 * <p>
	 * No delimiter is added before or after the list. Null objects or empty strings
	 * within the array are represented by empty strings.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.join(null, *)               = null
	 * StringUtils.join([], *)                 = ""
	 * StringUtils.join([null], *)             = ""
	 * StringUtils.join([1, 2, 3], ';')  = "1;2;3"
	 * StringUtils.join([1, 2, 3], null) = "123"
	 * </pre>
	 *
	 * @param array      the array of values to join together, may be null
	 * @param delimiter  the separator character to use
	 * @param startIndex the first index to start joining from. It is an error to
	 *                   pass in a start index past the end of the array
	 * @param endIndex   the index to stop joining from (exclusive). It is an error
	 *                   to pass in an end index past the end of the array
	 * @return the joined String, {@code null} if null array input
	 * @since 3.2
	 */
	public static String join(final double[] array, final char delimiter, final int startIndex, final int endIndex) {
		if (array == null) {
			return null;
		}
		if (endIndex - startIndex <= 0) {
			return EMPTY;
		}
		final StringJoiner joiner = newStringJoiner(delimiter);
		for (int i = startIndex; i < endIndex; i++) {
			joiner.add(String.valueOf(array[i]));
		}
		return joiner.toString();
	}

	/**
	 * <p>
	 * Joins the elements of the provided array into a single String containing the
	 * provided list of elements.
	 * </p>
	 *
	 * <p>
	 * No delimiter is added before or after the list. Null objects or empty strings
	 * within the array are represented by empty strings.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.join(null, *)               = null
	 * StringUtils.join([], *)                 = ""
	 * StringUtils.join([null], *)             = ""
	 * StringUtils.join([1, 2, 3], ';')  = "1;2;3"
	 * StringUtils.join([1, 2, 3], null) = "123"
	 * </pre>
	 *
	 * @param array     the array of values to join together, may be null
	 * @param delimiter the separator character to use
	 * @return the joined String, {@code null} if null array input
	 * @since 3.2
	 */
	public static String join(final float[] array, final char delimiter) {
		if (array == null) {
			return null;
		}
		return join(array, delimiter, 0, array.length);
	}

	/**
	 * <p>
	 * Joins the elements of the provided array into a single String containing the
	 * provided list of elements.
	 * </p>
	 *
	 * <p>
	 * No delimiter is added before or after the list. Null objects or empty strings
	 * within the array are represented by empty strings.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.join(null, *)               = null
	 * StringUtils.join([], *)                 = ""
	 * StringUtils.join([null], *)             = ""
	 * StringUtils.join([1, 2, 3], ';')  = "1;2;3"
	 * StringUtils.join([1, 2, 3], null) = "123"
	 * </pre>
	 *
	 * @param array      the array of values to join together, may be null
	 * @param delimiter  the separator character to use
	 * @param startIndex the first index to start joining from. It is an error to
	 *                   pass in a start index past the end of the array
	 * @param endIndex   the index to stop joining from (exclusive). It is an error
	 *                   to pass in an end index past the end of the array
	 * @return the joined String, {@code null} if null array input
	 * @since 3.2
	 */
	public static String join(final float[] array, final char delimiter, final int startIndex, final int endIndex) {
		if (array == null) {
			return null;
		}
		if (endIndex - startIndex <= 0) {
			return EMPTY;
		}
		final StringJoiner joiner = newStringJoiner(delimiter);
		for (int i = startIndex; i < endIndex; i++) {
			joiner.add(String.valueOf(array[i]));
		}
		return joiner.toString();
	}

	/**
	 * <p>
	 * Joins the elements of the provided array into a single String containing the
	 * provided list of elements.
	 * </p>
	 *
	 * <p>
	 * No delimiter is added before or after the list. Null objects or empty strings
	 * within the array are represented by empty strings.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.join(null, *)               = null
	 * StringUtils.join([], *)                 = ""
	 * StringUtils.join([null], *)             = ""
	 * StringUtils.join([1, 2, 3], ';')  = "1;2;3"
	 * StringUtils.join([1, 2, 3], null) = "123"
	 * </pre>
	 *
	 * @param array     the array of values to join together, may be null
	 * @param separator the separator character to use
	 * @return the joined String, {@code null} if null array input
	 * @since 3.2
	 */
	public static String join(final int[] array, final char separator) {
		if (array == null) {
			return null;
		}
		return join(array, separator, 0, array.length);
	}

	/**
	 * <p>
	 * Joins the elements of the provided array into a single String containing the
	 * provided list of elements.
	 * </p>
	 *
	 * <p>
	 * No delimiter is added before or after the list. Null objects or empty strings
	 * within the array are represented by empty strings.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.join(null, *)               = null
	 * StringUtils.join([], *)                 = ""
	 * StringUtils.join([null], *)             = ""
	 * StringUtils.join([1, 2, 3], ';')  = "1;2;3"
	 * StringUtils.join([1, 2, 3], null) = "123"
	 * </pre>
	 *
	 * @param array      the array of values to join together, may be null
	 * @param delimiter  the separator character to use
	 * @param startIndex the first index to start joining from. It is an error to
	 *                   pass in a start index past the end of the array
	 * @param endIndex   the index to stop joining from (exclusive). It is an error
	 *                   to pass in an end index past the end of the array
	 * @return the joined String, {@code null} if null array input
	 * @since 3.2
	 */
	public static String join(final int[] array, final char delimiter, final int startIndex, final int endIndex) {
		if (array == null) {
			return null;
		}
		if (endIndex - startIndex <= 0) {
			return EMPTY;
		}
		final StringJoiner joiner = newStringJoiner(delimiter);
		for (int i = startIndex; i < endIndex; i++) {
			joiner.add(String.valueOf(array[i]));
		}
		return joiner.toString();
	}

	/**
	 * <p>
	 * Joins the elements of the provided {@code Iterable} into a single String
	 * containing the provided elements.
	 * </p>
	 *
	 * <p>
	 * No delimiter is added before or after the list. Null objects or empty strings
	 * within the iteration are represented by empty strings.
	 * </p>
	 *
	 * <p>
	 * See the examples here: {@link #join(Object[],char)}.
	 * </p>
	 *
	 * @param iterable  the {@code Iterable} providing the values to join together,
	 *                  may be null
	 * @param separator the separator character to use
	 * @return the joined String, {@code null} if null iterator input
	 * @since 2.3
	 */
	public static String join(final Iterable<?> iterable, final char separator) {
		if (iterable == null) {
			return null;
		}
		return join(iterable.iterator(), separator);
	}

	/**
	 * <p>
	 * Joins the elements of the provided {@code Iterable} into a single String
	 * containing the provided elements.
	 * </p>
	 *
	 * <p>
	 * No delimiter is added before or after the list. A {@code null} separator is
	 * the same as an empty String ("").
	 * </p>
	 *
	 * <p>
	 * See the examples here: {@link #join(Object[],String)}.
	 * </p>
	 *
	 * @param iterable  the {@code Iterable} providing the values to join together,
	 *                  may be null
	 * @param separator the separator character to use, null treated as ""
	 * @return the joined String, {@code null} if null iterator input
	 * @since 2.3
	 */
	public static String join(final Iterable<?> iterable, final String separator) {
		if (iterable == null) {
			return null;
		}
		return join(iterable.iterator(), separator);
	}

	/**
	 * <p>
	 * Joins the elements of the provided {@code Iterator} into a single String
	 * containing the provided elements.
	 * </p>
	 *
	 * <p>
	 * No delimiter is added before or after the list. Null objects or empty strings
	 * within the iteration are represented by empty strings.
	 * </p>
	 *
	 * <p>
	 * See the examples here: {@link #join(Object[],char)}.
	 * </p>
	 *
	 * @param iterator  the {@code Iterator} of values to join together, may be null
	 * @param separator the separator character to use
	 * @return the joined String, {@code null} if null iterator input
	 * @since 2.0
	 */
	public static String join(final Iterator<?> iterator, final char separator) {

		// handle null, zero and one elements before building a buffer
		if (iterator == null) {
			return null;
		}
		if (!iterator.hasNext()) {
			return EMPTY;
		}
		final Object first = iterator.next();
		if (!iterator.hasNext()) {
			return toStringOrEmpty(first);
		}

		// two or more elements
		final StringBuilder buf = new StringBuilder(STRING_BUILDER_SIZE); // Java default is 16, probably too small
		if (first != null) {
			buf.append(first);
		}

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

		return buf.toString();
	}

	/**
	 * <p>
	 * Joins the elements of the provided {@code Iterator} into a single String
	 * containing the provided elements.
	 * </p>
	 *
	 * <p>
	 * No delimiter is added before or after the list. A {@code null} separator is
	 * the same as an empty String ("").
	 * </p>
	 *
	 * <p>
	 * See the examples here: {@link #join(Object[],String)}.
	 * </p>
	 *
	 * @param iterator  the {@code Iterator} of values to join together, may be null
	 * @param separator the separator character to use, null treated as ""
	 * @return the joined String, {@code null} if null iterator input
	 */
	public static String join(final Iterator<?> iterator, final String separator) {

		// handle null, zero and one elements before building a buffer
		if (iterator == null) {
			return null;
		}
		if (!iterator.hasNext()) {
			return EMPTY;
		}
		final Object first = iterator.next();
		if (!iterator.hasNext()) {
			return Objects.toString(first, "");
		}

		// two or more elements
		final StringBuilder buf = new StringBuilder(STRING_BUILDER_SIZE); // Java default is 16, probably too small
		if (first != null) {
			buf.append(first);
		}

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

	/**
	 * <p>
	 * Joins the elements of the provided {@code List} into a single String
	 * containing the provided list of elements.
	 * </p>
	 *
	 * <p>
	 * No delimiter is added before or after the list. Null objects or empty strings
	 * within the array are represented by empty strings.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.join(null, *)               = null
	 * StringUtils.join([], *)                 = ""
	 * StringUtils.join([null], *)             = ""
	 * StringUtils.join(["a", "b", "c"], ';')  = "a;b;c"
	 * StringUtils.join(["a", "b", "c"], null) = "abc"
	 * StringUtils.join([null, "", "a"], ';')  = ";;a"
	 * </pre>
	 *
	 * @param list       the {@code List} of values to join together, may be null
	 * @param separator  the separator character to use
	 * @param startIndex the first index to start joining from. It is an error to
	 *                   pass in a start index past the end of the list
	 * @param endIndex   the index to stop joining from (exclusive). It is an error
	 *                   to pass in an end index past the end of the list
	 * @return the joined String, {@code null} if null list input
	 * @since 3.8
	 */
	public static String join(final List<?> list, final char separator, final int startIndex, final int endIndex) {
		if (list == null) {
			return null;
		}
		final int noOfItems = endIndex - startIndex;
		if (noOfItems <= 0) {
			return EMPTY;
		}
		final List<?> subList = list.subList(startIndex, endIndex);
		return join(subList.iterator(), separator);
	}

	/**
	 * <p>
	 * Joins the elements of the provided {@code List} into a single String
	 * containing the provided list of elements.
	 * </p>
	 *
	 * <p>
	 * No delimiter is added before or after the list. Null objects or empty strings
	 * within the array are represented by empty strings.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.join(null, *)               = null
	 * StringUtils.join([], *)                 = ""
	 * StringUtils.join([null], *)             = ""
	 * StringUtils.join(["a", "b", "c"], ';')  = "a;b;c"
	 * StringUtils.join(["a", "b", "c"], null) = "abc"
	 * StringUtils.join([null, "", "a"], ';')  = ";;a"
	 * </pre>
	 *
	 * @param list       the {@code List} of values to join together, may be null
	 * @param separator  the separator character to use
	 * @param startIndex the first index to start joining from. It is an error to
	 *                   pass in a start index past the end of the list
	 * @param endIndex   the index to stop joining from (exclusive). It is an error
	 *                   to pass in an end index past the end of the list
	 * @return the joined String, {@code null} if null list input
	 * @since 3.8
	 */
	public static String join(final List<?> list, final String separator, final int startIndex, final int endIndex) {
		if (list == null) {
			return null;
		}
		final int noOfItems = endIndex - startIndex;
		if (noOfItems <= 0) {
			return EMPTY;
		}
		final List<?> subList = list.subList(startIndex, endIndex);
		return join(subList.iterator(), separator);
	}

	/**
	 * <p>
	 * Joins the elements of the provided array into a single String containing the
	 * provided list of elements.
	 * </p>
	 *
	 * <p>
	 * No delimiter is added before or after the list. Null objects or empty strings
	 * within the array are represented by empty strings.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.join(null, *)               = null
	 * StringUtils.join([], *)                 = ""
	 * StringUtils.join([null], *)             = ""
	 * StringUtils.join([1, 2, 3], ';')  = "1;2;3"
	 * StringUtils.join([1, 2, 3], null) = "123"
	 * </pre>
	 *
	 * @param array     the array of values to join together, may be null
	 * @param separator the separator character to use
	 * @return the joined String, {@code null} if null array input
	 * @since 3.2
	 */
	public static String join(final long[] array, final char separator) {
		if (array == null) {
			return null;
		}
		return join(array, separator, 0, array.length);
	}

	/**
	 * <p>
	 * Joins the elements of the provided array into a single String containing the
	 * provided list of elements.
	 * </p>
	 *
	 * <p>
	 * No delimiter is added before or after the list. Null objects or empty strings
	 * within the array are represented by empty strings.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.join(null, *)               = null
	 * StringUtils.join([], *)                 = ""
	 * StringUtils.join([null], *)             = ""
	 * StringUtils.join([1, 2, 3], ';')  = "1;2;3"
	 * StringUtils.join([1, 2, 3], null) = "123"
	 * </pre>
	 *
	 * @param array      the array of values to join together, may be null
	 * @param delimiter  the separator character to use
	 * @param startIndex the first index to start joining from. It is an error to
	 *                   pass in a start index past the end of the array
	 * @param endIndex   the index to stop joining from (exclusive). It is an error
	 *                   to pass in an end index past the end of the array
	 * @return the joined String, {@code null} if null array input
	 * @since 3.2
	 */
	public static String join(final long[] array, final char delimiter, final int startIndex, final int endIndex) {
		if (array == null) {
			return null;
		}
		if (endIndex - startIndex <= 0) {
			return EMPTY;
		}
		final StringJoiner joiner = newStringJoiner(delimiter);
		for (int i = startIndex; i < endIndex; i++) {
			joiner.add(String.valueOf(array[i]));
		}
		return joiner.toString();
	}

	/**
	 * <p>
	 * Joins the elements of the provided array into a single String containing the
	 * provided list of elements.
	 * </p>
	 *
	 * <p>
	 * No delimiter is added before or after the list. Null objects or empty strings
	 * within the array are represented by empty strings.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.join(null, *)               = null
	 * StringUtils.join([], *)                 = ""
	 * StringUtils.join([null], *)             = ""
	 * StringUtils.join(["a", "b", "c"], ';')  = "a;b;c"
	 * StringUtils.join(["a", "b", "c"], null) = "abc"
	 * StringUtils.join([null, "", "a"], ';')  = ";;a"
	 * </pre>
	 *
	 * @param array     the array of values to join together, may be null
	 * @param delimiter the separator character to use
	 * @return the joined String, {@code null} if null array input
	 * @since 2.0
	 */
	public static String join(final Object[] array, final char delimiter) {
		if (array == null) {
			return null;
		}
		return join(array, delimiter, 0, array.length);
	}

	/**
	 * <p>
	 * Joins the elements of the provided array into a single String containing the
	 * provided list of elements.
	 * </p>
	 *
	 * <p>
	 * No delimiter is added before or after the list. Null objects or empty strings
	 * within the array are represented by empty strings.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.join(null, *)               = null
	 * StringUtils.join([], *)                 = ""
	 * StringUtils.join([null], *)             = ""
	 * StringUtils.join(["a", "b", "c"], ';')  = "a;b;c"
	 * StringUtils.join(["a", "b", "c"], null) = "abc"
	 * StringUtils.join([null, "", "a"], ';')  = ";;a"
	 * </pre>
	 *
	 * @param array      the array of values to join together, may be null
	 * @param delimiter  the separator character to use
	 * @param startIndex the first index to start joining from. It is an error to
	 *                   pass in a start index past the end of the array
	 * @param endIndex   the index to stop joining from (exclusive). It is an error
	 *                   to pass in an end index past the end of the array
	 * @return the joined String, {@code null} if null array input
	 * @since 2.0
	 */
	public static String join(final Object[] array, final char delimiter, final int startIndex, final int endIndex) {
		if (array == null) {
			return null;
		}
		if (endIndex - startIndex <= 0) {
			return EMPTY;
		}
		final StringJoiner joiner = newStringJoiner(delimiter);
		for (int i = startIndex; i < endIndex; i++) {
			joiner.add(toStringOrEmpty(array[i]));
		}
		return joiner.toString();
	}

	/**
	 * <p>
	 * Joins the elements of the provided array into a single String containing the
	 * provided list of elements.
	 * </p>
	 *
	 * <p>
	 * No delimiter is added before or after the list. A {@code null} separator is
	 * the same as an empty String (""). Null objects or empty strings within the
	 * array are represented by empty strings.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.join(null, *)                = null
	 * StringUtils.join([], *)                  = ""
	 * StringUtils.join([null], *)              = ""
	 * StringUtils.join(["a", "b", "c"], "--")  = "a--b--c"
	 * StringUtils.join(["a", "b", "c"], null)  = "abc"
	 * StringUtils.join(["a", "b", "c"], "")    = "abc"
	 * StringUtils.join([null, "", "a"], ',')   = ",,a"
	 * </pre>
	 *
	 * @param array     the array of values to join together, may be null
	 * @param delimiter the separator character to use, null treated as ""
	 * @return the joined String, {@code null} if null array input
	 */
	public static String join(final Object[] array, final String delimiter) {
		if (array == null) {
			return null;
		}
		return join(array, delimiter, 0, array.length);
	}

	/**
	 * <p>
	 * Joins the elements of the provided array into a single String containing the
	 * provided list of elements.
	 * </p>
	 *
	 * <p>
	 * No delimiter is added before or after the list. A {@code null} separator is
	 * the same as an empty String (""). Null objects or empty strings within the
	 * array are represented by empty strings.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.join(null, *, *, *)                = null
	 * StringUtils.join([], *, *, *)                  = ""
	 * StringUtils.join([null], *, *, *)              = ""
	 * StringUtils.join(["a", "b", "c"], "--", 0, 3)  = "a--b--c"
	 * StringUtils.join(["a", "b", "c"], "--", 1, 3)  = "b--c"
	 * StringUtils.join(["a", "b", "c"], "--", 2, 3)  = "c"
	 * StringUtils.join(["a", "b", "c"], "--", 2, 2)  = ""
	 * StringUtils.join(["a", "b", "c"], null, 0, 3)  = "abc"
	 * StringUtils.join(["a", "b", "c"], "", 0, 3)    = "abc"
	 * StringUtils.join([null, "", "a"], ',', 0, 3)   = ",,a"
	 * </pre>
	 *
	 * @param array      the array of values to join together, may be null
	 * @param delimiter  the separator character to use, null treated as ""
	 * @param startIndex the first index to start joining from.
	 * @param endIndex   the index to stop joining from (exclusive).
	 * @return the joined String, {@code null} if null array input; or the empty
	 *         string if {@code endIndex - startIndex <= 0}. The number of joined
	 *         entries is given by {@code endIndex - startIndex}
	 * @throws ArrayIndexOutOfBoundsException ife<br>
	 *                                        {@code startIndex < 0} or <br>
	 *                                        {@code startIndex >= array.length()}
	 *                                        or <br>
	 *                                        {@code endIndex < 0} or <br>
	 *                                        {@code endIndex > array.length()}
	 */
	public static String join(final Object[] array, final String delimiter, final int startIndex, final int endIndex) {
		if (array == null) {
			return null;
		}
		if (endIndex - startIndex <= 0) {
			return EMPTY;
		}
		final StringJoiner joiner = new StringJoiner(toStringOrEmpty(delimiter));
		for (int i = startIndex; i < endIndex; i++) {
			joiner.add(toStringOrEmpty(array[i]));
		}
		return joiner.toString();
	}

	/**
	 * <p>
	 * Joins the elements of the provided array into a single String containing the
	 * provided list of elements.
	 * </p>
	 *
	 * <p>
	 * No delimiter is added before or after the list. Null objects or empty strings
	 * within the array are represented by empty strings.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.join(null, *)               = null
	 * StringUtils.join([], *)                 = ""
	 * StringUtils.join([null], *)             = ""
	 * StringUtils.join([1, 2, 3], ';')  = "1;2;3"
	 * StringUtils.join([1, 2, 3], null) = "123"
	 * </pre>
	 *
	 * @param array     the array of values to join together, may be null
	 * @param delimiter the separator character to use
	 * @return the joined String, {@code null} if null array input
	 * @since 3.2
	 */
	public static String join(final short[] array, final char delimiter) {
		if (array == null) {
			return null;
		}
		return join(array, delimiter, 0, array.length);
	}

	/**
	 * <p>
	 * Joins the elements of the provided array into a single String containing the
	 * provided list of elements.
	 * </p>
	 *
	 * <p>
	 * No delimiter is added before or after the list. Null objects or empty strings
	 * within the array are represented by empty strings.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.join(null, *)               = null
	 * StringUtils.join([], *)                 = ""
	 * StringUtils.join([null], *)             = ""
	 * StringUtils.join([1, 2, 3], ';')  = "1;2;3"
	 * StringUtils.join([1, 2, 3], null) = "123"
	 * </pre>
	 *
	 * @param array      the array of values to join together, may be null
	 * @param delimiter  the separator character to use
	 * @param startIndex the first index to start joining from. It is an error to
	 *                   pass in a start index past the end of the array
	 * @param endIndex   the index to stop joining from (exclusive). It is an error
	 *                   to pass in an end index past the end of the array
	 * @return the joined String, {@code null} if null array input
	 * @since 3.2
	 */
	public static String join(final short[] array, final char delimiter, final int startIndex, final int endIndex) {
		if (array == null) {
			return null;
		}
		if (endIndex - startIndex <= 0) {
			return EMPTY;
		}
		final StringJoiner joiner = newStringJoiner(delimiter);
		for (int i = startIndex; i < endIndex; i++) {
			joiner.add(String.valueOf(array[i]));
		}
		return joiner.toString();
	}

	/**
	 * <p>
	 * Joins the elements of the provided array into a single String containing the
	 * provided list of elements.
	 * </p>
	 *
	 * <p>
	 * No separator is added to the joined String. Null objects or empty strings
	 * within the array are represented by empty strings.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.join(null)            = null
	 * StringUtils.join([])              = ""
	 * StringUtils.join([null])          = ""
	 * StringUtils.join(["a", "b", "c"]) = "abc"
	 * StringUtils.join([null, "", "a"]) = "a"
	 * </pre>
	 *
	 * @param <T>      the specific type of values to join together
	 * @param elements the values to join together, may be null
	 * @return the joined String, {@code null} if null array input
	 * @since 2.0
	 * @since 3.0 Changed signature to use varargs
	 */
	@SafeVarargs
	public static <T> String join(final T... elements) {
		return join(elements, null);
	}

	/**
	 * <p>
	 * Joins the elements of the provided varargs into a single String containing
	 * the provided elements.
	 * </p>
	 *
	 * <p>
	 * No delimiter is added before or after the list. {@code null} elements and
	 * separator are treated as empty Strings ("").
	 * </p>
	 *
	 * <pre>
	 * StringUtils.joinWith(",", {"a", "b"})        = "a,b"
	 * StringUtils.joinWith(",", {"a", "b",""})     = "a,b,"
	 * StringUtils.joinWith(",", {"a", null, "b"})  = "a,,b"
	 * StringUtils.joinWith(null, {"a", "b"})       = "ab"
	 * </pre>
	 *
	 * @param delimiter the separator character to use, null treated as ""
	 * @param array     the varargs providing the values to join together.
	 *                  {@code null} elements are treated as ""
	 * @return the joined String.
	 * @throws java.lang.IllegalArgumentException if a null varargs is provided
	 * @since 3.5
	 */
	public static String joinWith(final String delimiter, final Object... array) {
		if (array == null) {
			throw new IllegalArgumentException("Object varargs must not be null");
		}
		return join(array, delimiter);
	}

	/**
	 * <p>
	 * Finds the last index within a CharSequence, handling {@code null}. This
	 * method uses {@link String#lastIndexOf(String)} if possible.
	 * </p>
	 *
	 * <p>
	 * A {@code null} CharSequence will return {@code -1}.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.lastIndexOf(null, *)          = -1
	 * StringUtils.lastIndexOf(*, null)          = -1
	 * StringUtils.lastIndexOf("", "")           = 0
	 * StringUtils.lastIndexOf("aabaabaa", "a")  = 7
	 * StringUtils.lastIndexOf("aabaabaa", "b")  = 5
	 * StringUtils.lastIndexOf("aabaabaa", "ab") = 4
	 * StringUtils.lastIndexOf("aabaabaa", "")   = 8
	 * </pre>
	 *
	 * @param seq       the CharSequence to check, may be null
	 * @param searchSeq the CharSequence to find, may be null
	 * @return the last index of the search String, -1 if no match or {@code null}
	 *         string input
	 * @since 2.0
	 * @since 3.0 Changed signature from lastIndexOf(String, String) to
	 *        lastIndexOf(CharSequence, CharSequence)
	 */
	public static int lastIndexOf(final CharSequence seq, final CharSequence searchSeq) {
		if (seq == null) {
			return INDEX_NOT_FOUND;
		}
		return CharSequenceUtils.lastIndexOf(seq, searchSeq, seq.length());
	}

	/**
	 * <p>
	 * Finds the last index within a CharSequence, handling {@code null}. This
	 * method uses {@link String#lastIndexOf(String, int)} if possible.
	 * </p>
	 *
	 * <p>
	 * A {@code null} CharSequence will return {@code -1}. A negative start position
	 * returns {@code -1}. An empty ("") search CharSequence always matches unless
	 * the start position is negative. A start position greater than the string
	 * length searches the whole string. The search starts at the startPos and works
	 * backwards; matches starting after the start position are ignored.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.lastIndexOf(null, *, *)          = -1
	 * StringUtils.lastIndexOf(*, null, *)          = -1
	 * StringUtils.lastIndexOf("aabaabaa", "a", 8)  = 7
	 * StringUtils.lastIndexOf("aabaabaa", "b", 8)  = 5
	 * StringUtils.lastIndexOf("aabaabaa", "ab", 8) = 4
	 * StringUtils.lastIndexOf("aabaabaa", "b", 9)  = 5
	 * StringUtils.lastIndexOf("aabaabaa", "b", -1) = -1
	 * StringUtils.lastIndexOf("aabaabaa", "a", 0)  = 0
	 * StringUtils.lastIndexOf("aabaabaa", "b", 0)  = -1
	 * StringUtils.lastIndexOf("aabaabaa", "b", 1)  = -1
	 * StringUtils.lastIndexOf("aabaabaa", "b", 2)  = 2
	 * StringUtils.lastIndexOf("aabaabaa", "ba", 2)  = 2
	 * </pre>
	 *
	 * @param seq       the CharSequence to check, may be null
	 * @param searchSeq the CharSequence to find, may be null
	 * @param startPos  the start position, negative treated as zero
	 * @return the last index of the search CharSequence (always &le; startPos), -1
	 *         if no match or {@code null} string input
	 * @since 2.0
	 * @since 3.0 Changed signature from lastIndexOf(String, String, int) to
	 *        lastIndexOf(CharSequence, CharSequence, int)
	 */
	public static int lastIndexOf(final CharSequence seq, final CharSequence searchSeq, final int startPos) {
		return CharSequenceUtils.lastIndexOf(seq, searchSeq, startPos);
	}

	/**
	 * Returns the index within {@code seq} of the last occurrence of the specified
	 * character. For values of {@code searchChar} in the range from 0 to 0xFFFF
	 * (inclusive), the index (in Unicode code units) returned is the largest value
	 * <i>k</i> such that: <blockquote>
	 * 
	 * <pre>
	 * this.charAt(<i>k</i>) == searchChar
	 * </pre>
	 * 
	 * </blockquote> is true. For other values of {@code searchChar}, it is the
	 * largest value <i>k</i> such that: <blockquote>
	 * 
	 * <pre>
	 * this.codePointAt(<i>k</i>) == searchChar
	 * </pre>
	 * 
	 * </blockquote> is true. In either case, if no such character occurs in this
	 * string, then {@code -1} is returned. Furthermore, a {@code null} or empty
	 * ("") {@code CharSequence} will return {@code -1}. The {@code seq}
	 * {@code CharSequence} object is searched backwards starting at the last
	 * character.
	 *
	 * <pre>
	 * StringUtils.lastIndexOf(null, *)         = -1
	 * StringUtils.lastIndexOf("", *)           = -1
	 * StringUtils.lastIndexOf("aabaabaa", 'a') = 7
	 * StringUtils.lastIndexOf("aabaabaa", 'b') = 5
	 * </pre>
	 *
	 * @param seq        the {@code CharSequence} to check, may be null
	 * @param searchChar the character to find
	 * @return the last index of the search character, -1 if no match or
	 *         {@code null} string input
	 * @since 2.0
	 * @since 3.0 Changed signature from lastIndexOf(String, int) to
	 *        lastIndexOf(CharSequence, int)
	 * @since 3.6 Updated {@link CharSequenceUtils} call to behave more like
	 *        {@code String}
	 */
	public static int lastIndexOf(final CharSequence seq, final int searchChar) {
		if (isEmpty(seq)) {
			return INDEX_NOT_FOUND;
		}
		return CharSequenceUtils.lastIndexOf(seq, searchChar, seq.length());
	}

	/**
	 * Returns the index within {@code seq} of the last occurrence of the specified
	 * character, searching backward starting at the specified index. For values of
	 * {@code searchChar} in the range from 0 to 0xFFFF (inclusive), the index
	 * returned is the largest value <i>k</i> such that: <blockquote>
	 * 
	 * <pre>
	 * (this.charAt(<i>k</i>) == searchChar) &amp;&amp; (<i>k</i> &lt;= startPos)
	 * </pre>
	 * 
	 * </blockquote> is true. For other values of {@code searchChar}, it is the
	 * largest value <i>k</i> such that: <blockquote>
	 * 
	 * <pre>
	 * (this.codePointAt(<i>k</i>) == searchChar) &amp;&amp; (<i>k</i> &lt;= startPos)
	 * </pre>
	 * 
	 * </blockquote> is true. In either case, if no such character occurs in
	 * {@code seq} at or before position {@code startPos}, then {@code -1} is
	 * returned. Furthermore, a {@code null} or empty ("") {@code CharSequence} will
	 * return {@code -1}. A start position greater than the string length searches
	 * the whole string. The search starts at the {@code startPos} and works
	 * backwards; matches starting after the start position are ignored.
	 *
	 * <p>
	 * All indices are specified in {@code char} values (Unicode code units).
	 *
	 * <pre>
	 * StringUtils.lastIndexOf(null, *, *)          = -1
	 * StringUtils.lastIndexOf("", *,  *)           = -1
	 * StringUtils.lastIndexOf("aabaabaa", 'b', 8)  = 5
	 * StringUtils.lastIndexOf("aabaabaa", 'b', 4)  = 2
	 * StringUtils.lastIndexOf("aabaabaa", 'b', 0)  = -1
	 * StringUtils.lastIndexOf("aabaabaa", 'b', 9)  = 5
	 * StringUtils.lastIndexOf("aabaabaa", 'b', -1) = -1
	 * StringUtils.lastIndexOf("aabaabaa", 'a', 0)  = 0
	 * </pre>
	 *
	 * @param seq        the CharSequence to check, may be null
	 * @param searchChar the character to find
	 * @param startPos   the start position
	 * @return the last index of the search character (always &le; startPos), -1 if
	 *         no match or {@code null} string input
	 * @since 2.0
	 * @since 3.0 Changed signature from lastIndexOf(String, int, int) to
	 *        lastIndexOf(CharSequence, int, int)
	 */
	public static int lastIndexOf(final CharSequence seq, final int searchChar, final int startPos) {
		if (isEmpty(seq)) {
			return INDEX_NOT_FOUND;
		}
		return CharSequenceUtils.lastIndexOf(seq, searchChar, startPos);
	}

	/**
	 * <p>
	 * Find the latest index of any substring in a set of potential substrings.
	 * </p>
	 *
	 * <p>
	 * A {@code null} CharSequence will return {@code -1}. A {@code null} search
	 * array will return {@code -1}. A {@code null} or zero length search array
	 * entry will be ignored, but a search array containing "" will return the
	 * length of {@code str} if {@code str} is not null. This method uses
	 * {@link String#indexOf(String)} if possible
	 * </p>
	 *
	 * <pre>
	 * StringUtils.lastIndexOfAny(null, *)                    = -1
	 * StringUtils.lastIndexOfAny(*, null)                    = -1
	 * StringUtils.lastIndexOfAny(*, [])                      = -1
	 * StringUtils.lastIndexOfAny(*, [null])                  = -1
	 * StringUtils.lastIndexOfAny("zzabyycdxx", ["ab", "cd"]) = 6
	 * StringUtils.lastIndexOfAny("zzabyycdxx", ["cd", "ab"]) = 6
	 * StringUtils.lastIndexOfAny("zzabyycdxx", ["mn", "op"]) = -1
	 * StringUtils.lastIndexOfAny("zzabyycdxx", ["mn", "op"]) = -1
	 * StringUtils.lastIndexOfAny("zzabyycdxx", ["mn", ""])   = 10
	 * </pre>
	 *
	 * @param str        the CharSequence to check, may be null
	 * @param searchStrs the CharSequences to search for, may be null
	 * @return the last index of any of the CharSequences, -1 if no match
	 * @since 3.0 Changed signature from lastIndexOfAny(String, String[]) to
	 *        lastIndexOfAny(CharSequence, CharSequence)
	 */
	public static int lastIndexOfAny(final CharSequence str, final CharSequence... searchStrs) {
		if (str == null || searchStrs == null) {
			return INDEX_NOT_FOUND;
		}
		int ret = INDEX_NOT_FOUND;
		int tmp = 0;
		for (final CharSequence search : searchStrs) {
			if (search == null) {
				continue;
			}
			tmp = CharSequenceUtils.lastIndexOf(str, search, str.length());
			if (tmp > ret) {
				ret = tmp;
			}
		}
		return ret;
	}

	/**
	 * <p>
	 * Case in-sensitive find of the last index within a CharSequence.
	 * </p>
	 *
	 * <p>
	 * A {@code null} CharSequence will return {@code -1}. A negative start position
	 * returns {@code -1}. An empty ("") search CharSequence always matches unless
	 * the start position is negative. A start position greater than the string
	 * length searches the whole string.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.lastIndexOfIgnoreCase(null, *)          = -1
	 * StringUtils.lastIndexOfIgnoreCase(*, null)          = -1
	 * StringUtils.lastIndexOfIgnoreCase("aabaabaa", "A")  = 7
	 * StringUtils.lastIndexOfIgnoreCase("aabaabaa", "B")  = 5
	 * StringUtils.lastIndexOfIgnoreCase("aabaabaa", "AB") = 4
	 * </pre>
	 *
	 * @param str       the CharSequence to check, may be null
	 * @param searchStr the CharSequence to find, may be null
	 * @return the first index of the search CharSequence, -1 if no match or
	 *         {@code null} string input
	 * @since 2.5
	 * @since 3.0 Changed signature from lastIndexOfIgnoreCase(String, String) to
	 *        lastIndexOfIgnoreCase(CharSequence, CharSequence)
	 */
	public static int lastIndexOfIgnoreCase(final CharSequence str, final CharSequence searchStr) {
		if (str == null || searchStr == null) {
			return INDEX_NOT_FOUND;
		}
		return lastIndexOfIgnoreCase(str, searchStr, str.length());
	}

	/**
	 * <p>
	 * Case in-sensitive find of the last index within a CharSequence from the
	 * specified position.
	 * </p>
	 *
	 * <p>
	 * A {@code null} CharSequence will return {@code -1}. A negative start position
	 * returns {@code -1}. An empty ("") search CharSequence always matches unless
	 * the start position is negative. A start position greater than the string
	 * length searches the whole string. The search starts at the startPos and works
	 * backwards; matches starting after the start position are ignored.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.lastIndexOfIgnoreCase(null, *, *)          = -1
	 * StringUtils.lastIndexOfIgnoreCase(*, null, *)          = -1
	 * StringUtils.lastIndexOfIgnoreCase("aabaabaa", "A", 8)  = 7
	 * StringUtils.lastIndexOfIgnoreCase("aabaabaa", "B", 8)  = 5
	 * StringUtils.lastIndexOfIgnoreCase("aabaabaa", "AB", 8) = 4
	 * StringUtils.lastIndexOfIgnoreCase("aabaabaa", "B", 9)  = 5
	 * StringUtils.lastIndexOfIgnoreCase("aabaabaa", "B", -1) = -1
	 * StringUtils.lastIndexOfIgnoreCase("aabaabaa", "A", 0)  = 0
	 * StringUtils.lastIndexOfIgnoreCase("aabaabaa", "B", 0)  = -1
	 * </pre>
	 *
	 * @param str       the CharSequence to check, may be null
	 * @param searchStr the CharSequence to find, may be null
	 * @param startPos  the start position
	 * @return the last index of the search CharSequence (always &le; startPos), -1
	 *         if no match or {@code null} input
	 * @since 2.5
	 * @since 3.0 Changed signature from lastIndexOfIgnoreCase(String, String, int)
	 *        to lastIndexOfIgnoreCase(CharSequence, CharSequence, int)
	 */
	public static int lastIndexOfIgnoreCase(final CharSequence str, final CharSequence searchStr, int startPos) {
		if (str == null || searchStr == null) {
			return INDEX_NOT_FOUND;
		}
		final int searchStrLength = searchStr.length();
		final int strLength = str.length();
		if (startPos > strLength - searchStrLength) {
			startPos = strLength - searchStrLength;
		}
		if (startPos < 0) {
			return INDEX_NOT_FOUND;
		}
		if (searchStrLength == 0) {
			return startPos;
		}

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

	/**
	 * <p>
	 * Finds the n-th last index within a String, handling {@code null}. This method
	 * uses {@link String#lastIndexOf(String)}.
	 * </p>
	 *
	 * <p>
	 * A {@code null} String will return {@code -1}.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.lastOrdinalIndexOf(null, *, *)          = -1
	 * StringUtils.lastOrdinalIndexOf(*, null, *)          = -1
	 * StringUtils.lastOrdinalIndexOf("", "", *)           = 0
	 * StringUtils.lastOrdinalIndexOf("aabaabaa", "a", 1)  = 7
	 * StringUtils.lastOrdinalIndexOf("aabaabaa", "a", 2)  = 6
	 * StringUtils.lastOrdinalIndexOf("aabaabaa", "b", 1)  = 5
	 * StringUtils.lastOrdinalIndexOf("aabaabaa", "b", 2)  = 2
	 * StringUtils.lastOrdinalIndexOf("aabaabaa", "ab", 1) = 4
	 * StringUtils.lastOrdinalIndexOf("aabaabaa", "ab", 2) = 1
	 * StringUtils.lastOrdinalIndexOf("aabaabaa", "", 1)   = 8
	 * StringUtils.lastOrdinalIndexOf("aabaabaa", "", 2)   = 8
	 * </pre>
	 *
	 * <p>
	 * Note that 'tail(CharSequence str, int n)' may be implemented as:
	 * </p>
	 *
	 * <pre>
	 * str.substring(lastOrdinalIndexOf(str, "\n", n) + 1)
	 * </pre>
	 *
	 * @param str       the CharSequence to check, may be null
	 * @param searchStr the CharSequence to find, may be null
	 * @param ordinal   the n-th last {@code searchStr} to find
	 * @return the n-th last index of the search CharSequence, {@code -1}
	 *         ({@code INDEX_NOT_FOUND}) if no match or {@code null} string input
	 * @since 2.5
	 * @since 3.0 Changed signature from lastOrdinalIndexOf(String, String, int) to
	 *        lastOrdinalIndexOf(CharSequence, CharSequence, int)
	 */
	public static int lastOrdinalIndexOf(final CharSequence str, final CharSequence searchStr, final int ordinal) {
		return ordinalIndexOf(str, searchStr, ordinal, true);
	}

	/**
	 * <p>
	 * Gets the leftmost {@code len} characters of a String.
	 * </p>
	 *
	 * <p>
	 * If {@code len} characters are not available, or the String is {@code null},
	 * the String will be returned without an exception. An empty String is returned
	 * if len is negative.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.left(null, *)    = null
	 * StringUtils.left(*, -ve)     = ""
	 * StringUtils.left("", *)      = ""
	 * StringUtils.left("abc", 0)   = ""
	 * StringUtils.left("abc", 2)   = "ab"
	 * StringUtils.left("abc", 4)   = "abc"
	 * </pre>
	 *
	 * @param str the String to get the leftmost characters from, may be null
	 * @param len the length of the required String
	 * @return the leftmost characters, {@code null} if null String input
	 */
	public static String left(final String str, final int len) {
		if (str == null) {
			return null;
		}
		if (len < 0) {
			return EMPTY;
		}
		if (str.length() <= len) {
			return str;
		}
		return str.substring(0, len);
	}

	/**
	 * <p>
	 * Left pad a String with spaces (' ').
	 * </p>
	 *
	 * <p>
	 * The String is padded to the size of {@code size}.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.leftPad(null, *)   = null
	 * StringUtils.leftPad("", 3)     = "   "
	 * StringUtils.leftPad("bat", 3)  = "bat"
	 * StringUtils.leftPad("bat", 5)  = "  bat"
	 * StringUtils.leftPad("bat", 1)  = "bat"
	 * StringUtils.leftPad("bat", -1) = "bat"
	 * </pre>
	 *
	 * @param str  the String to pad out, may be null
	 * @param size the size to pad to
	 * @return left padded String or original String if no padding is necessary,
	 *         {@code null} if null String input
	 */
	public static String leftPad(final String str, final int size) {
		return leftPad(str, size, ' ');
	}

	/**
	 * <p>
	 * Left pad a String with a specified character.
	 * </p>
	 *
	 * <p>
	 * Pad to a size of {@code size}.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.leftPad(null, *, *)     = null
	 * StringUtils.leftPad("", 3, 'z')     = "zzz"
	 * StringUtils.leftPad("bat", 3, 'z')  = "bat"
	 * StringUtils.leftPad("bat", 5, 'z')  = "zzbat"
	 * StringUtils.leftPad("bat", 1, 'z')  = "bat"
	 * StringUtils.leftPad("bat", -1, 'z') = "bat"
	 * </pre>
	 *
	 * @param str     the String to pad out, may be null
	 * @param size    the size to pad to
	 * @param padChar the character to pad with
	 * @return left padded String or original String if no padding is necessary,
	 *         {@code null} if null String input
	 * @since 2.0
	 */
	public static String leftPad(final String str, final int size, final char padChar) {
		if (str == null) {
			return null;
		}
		final int pads = size - str.length();
		if (pads <= 0) {
			return str; // returns original String when possible
		}
		if (pads > PAD_LIMIT) {
			return leftPad(str, size, String.valueOf(padChar));
		}
		return repeat(padChar, pads).concat(str);
	}

	/**
	 * <p>
	 * Left pad a String with a specified String.
	 * </p>
	 *
	 * <p>
	 * Pad to a size of {@code size}.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.leftPad(null, *, *)      = null
	 * StringUtils.leftPad("", 3, "z")      = "zzz"
	 * StringUtils.leftPad("bat", 3, "yz")  = "bat"
	 * StringUtils.leftPad("bat", 5, "yz")  = "yzbat"
	 * StringUtils.leftPad("bat", 8, "yz")  = "yzyzybat"
	 * StringUtils.leftPad("bat", 1, "yz")  = "bat"
	 * StringUtils.leftPad("bat", -1, "yz") = "bat"
	 * StringUtils.leftPad("bat", 5, null)  = "  bat"
	 * StringUtils.leftPad("bat", 5, "")    = "  bat"
	 * </pre>
	 *
	 * @param str    the String to pad out, may be null
	 * @param size   the size to pad to
	 * @param padStr the String to pad with, null or empty treated as single space
	 * @return left padded String or original String if no padding is necessary,
	 *         {@code null} if null String input
	 */
	public static String leftPad(final String str, final int size, String padStr) {
		if (str == null) {
			return null;
		}
		if (isEmpty(padStr)) {
			padStr = SPACE;
		}
		final int padLen = padStr.length();
		final int strLen = str.length();
		final int pads = size - strLen;
		if (pads <= 0) {
			return str; // returns original String when possible
		}
		if (padLen == 1 && pads <= PAD_LIMIT) {
			return leftPad(str, size, padStr.charAt(0));
		}

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

	/**
	 * 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}.
	 * @since 2.4
	 * @since 3.0 Changed signature from length(String) to length(CharSequence)
	 */
	public static int length(final CharSequence cs) {
		return cs == null ? 0 : cs.length();
	}

	/**
	 * <p>
	 * Converts a String to lower case as per {@link String#toLowerCase()}.
	 * </p>
	 *
	 * <p>
	 * A {@code null} input String returns {@code null}.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.lowerCase(null)  = null
	 * StringUtils.lowerCase("")    = ""
	 * StringUtils.lowerCase("aBc") = "abc"
	 * </pre>
	 *
	 * <p>
	 * <strong>Note:</strong> As described in the documentation for
	 * {@link String#toLowerCase()}, the result of this method is affected by the
	 * current locale. For platform-independent case transformations, the method
	 * {@link #lowerCase(String, Locale)} should be used with a specific locale
	 * (e.g. {@link Locale#ENGLISH}).
	 * </p>
	 *
	 * @param str the String to lower case, may be null
	 * @return the lower cased String, {@code null} if null String input
	 */
	public static String lowerCase(final String str) {
		if (str == null) {
			return null;
		}
		return str.toLowerCase();
	}

	/**
	 * <p>
	 * Converts a String to lower case as per {@link String#toLowerCase(Locale)}.
	 * </p>
	 *
	 * <p>
	 * A {@code null} input String returns {@code null}.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.lowerCase(null, Locale.ENGLISH)  = null
	 * StringUtils.lowerCase("", Locale.ENGLISH)    = ""
	 * StringUtils.lowerCase("aBc", Locale.ENGLISH) = "abc"
	 * </pre>
	 *
	 * @param str    the String to lower case, may be null
	 * @param locale the locale that defines the case transformation rules, must not
	 *               be null
	 * @return the lower cased String, {@code null} if null String input
	 * @since 2.5
	 */
	public static String lowerCase(final String str, final Locale locale) {
		if (str == null) {
			return null;
		}
		return str.toLowerCase(LocaleUtils.toLocale(locale));
	}

	private static int[] matches(final CharSequence first, final CharSequence second) {
		final CharSequence max;
		final CharSequence min;
		if (first.length() > second.length()) {
			max = first;
			min = second;
		} else {
			max = second;
			min = first;
		}
		final int range = Math.max(max.length() / 2 - 1, 0);
		final int[] matchIndexes = new int[min.length()];
		Arrays.fill(matchIndexes, -1);
		final boolean[] matchFlags = new boolean[max.length()];
		int matches = 0;
		for (int mi = 0; mi < min.length(); mi++) {
			final char c1 = min.charAt(mi);
			for (int xi = Math.max(mi - range, 0), xn = Math.min(mi + range + 1, max.length()); xi < xn; xi++) {
				if (!matchFlags[xi] && c1 == max.charAt(xi)) {
					matchIndexes[mi] = xi;
					matchFlags[xi] = true;
					matches++;
					break;
				}
			}
		}
		final char[] ms1 = new char[matches];
		final char[] ms2 = new char[matches];
		for (int i = 0, si = 0; i < min.length(); i++) {
			if (matchIndexes[i] != -1) {
				ms1[si] = min.charAt(i);
				si++;
			}
		}
		for (int i = 0, si = 0; i < max.length(); i++) {
			if (matchFlags[i]) {
				ms2[si] = max.charAt(i);
				si++;
			}
		}
		int transpositions = 0;
		for (int mi = 0; mi < ms1.length; mi++) {
			if (ms1[mi] != ms2[mi]) {
				transpositions++;
			}
		}
		int prefix = 0;
		for (int mi = 0; mi < min.length(); mi++) {
			if (first.charAt(mi) == second.charAt(mi)) {
				prefix++;
			} else {
				break;
			}
		}
		return new int[] { matches, transpositions / 2, prefix, max.length() };
	}

	/**
	 * <p>
	 * Gets {@code len} characters from the middle of a String.
	 * </p>
	 *
	 * <p>
	 * If {@code len} characters are not available, the remainder of the String will
	 * be returned without an exception. If the String is {@code null}, {@code null}
	 * will be returned. An empty String is returned if len is negative or exceeds
	 * the length of {@code str}.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.mid(null, *, *)    = null
	 * StringUtils.mid(*, *, -ve)     = ""
	 * StringUtils.mid("", 0, *)      = ""
	 * StringUtils.mid("abc", 0, 2)   = "ab"
	 * StringUtils.mid("abc", 0, 4)   = "abc"
	 * StringUtils.mid("abc", 2, 4)   = "c"
	 * StringUtils.mid("abc", 4, 2)   = ""
	 * StringUtils.mid("abc", -2, 2)  = "ab"
	 * </pre>
	 *
	 * @param str the String to get the characters from, may be null
	 * @param pos the position to start from, negative treated as zero
	 * @param len the length of the required String
	 * @return the middle characters, {@code null} if null String input
	 */
	public static String mid(final String str, int pos, final int len) {
		if (str == null) {
			return null;
		}
		if (len < 0 || pos > str.length()) {
			return EMPTY;
		}
		if (pos < 0) {
			pos = 0;
		}
		if (str.length() <= pos + len) {
			return str.substring(pos);
		}
		return str.substring(pos, pos + len);
	}

	private static StringJoiner newStringJoiner(final char delimiter) {
		return new StringJoiner(String.valueOf(delimiter));
	}

	/**
	 * <p>
	 * Similar to <a href=
	 * "http://www.w3.org/TR/xpath/#function-normalize-space">http://www.w3.org/TR/xpath/#function-normalize
	 * -space</a>
	 * </p>
	 * <p>
	 * The function returns the argument string with whitespace normalized by using
	 * {@code {@link #trim(String)}} to remove leading and trailing whitespace and
	 * then replacing sequences of whitespace characters by a single space.
	 * </p>
	 * In XML Whitespace characters are the same as those allowed by the
	 * <a href="http://www.w3.org/TR/REC-xml/#NT-S">S</a> production, which is S ::=
	 * (#x20 | #x9 | #xD | #xA)+
	 * <p>
	 * Java's regexp pattern \s defines whitespace as [ \t\n\x0B\f\r]
	 *
	 * <p>
	 * For reference:
	 * </p>
	 * <ul>
	 * <li>\x0B = vertical tab</li>
	 * <li>\f = #xC = form feed</li>
	 * <li>#x20 = space</li>
	 * <li>#x9 = \t</li>
	 * <li>#xA = \n</li>
	 * <li>#xD = \r</li>
	 * </ul>
	 *
	 * <p>
	 * The difference is that Java's whitespace includes vertical tab and form feed,
	 * which this functional will also normalize. Additionally {@code {@link
	 * #trim(String)}} removes control characters (char &lt;= 32) from both ends of
	 * this String.
	 * </p>
	 *
	 * @see Pattern
	 * @see #trim(String)
	 * @see <a href=
	 *      "http://www.w3.org/TR/xpath/#function-normalize-space">http://www.w3.org/TR/xpath/#function-normalize-space</a>
	 * @param str the source String to normalize whitespaces from, may be null
	 * @return the modified string with whitespace normalized, {@code null} if null
	 *         String input
	 *
	 * @since 3.0
	 */
	public static String normalizeSpace(final String str) {
		// LANG-1020: Improved performance significantly by normalizing manually instead
		// of using regex
		// See https://github.com/librucha/commons-lang-normalizespaces-benchmark for
		// performance test
		if (isEmpty(str)) {
			return str;
		}
		final int size = str.length();
		final char[] newChars = new char[size];
		int count = 0;
		int whitespacesCount = 0;
		boolean startWhitespaces = true;
		for (int i = 0; i < size; i++) {
			final char actualChar = str.charAt(i);
			final boolean isWhitespace = Character.isWhitespace(actualChar);
			if (isWhitespace) {
				if (whitespacesCount == 0 && !startWhitespaces) {
					newChars[count++] = SPACE.charAt(0);
				}
				whitespacesCount++;
			} else {
				startWhitespaces = false;
				newChars[count++] = (actualChar == 160 ? 32 : actualChar);
				whitespacesCount = 0;
			}
		}
		if (startWhitespaces) {
			return EMPTY;
		}
		return new String(newChars, 0, count - (whitespacesCount > 0 ? 1 : 0)).trim();
	}

	/**
	 * <p>
	 * Finds the n-th index within a CharSequence, handling {@code null}. This
	 * method uses {@link String#indexOf(String)} if possible.
	 * </p>
	 * <p>
	 * <b>Note:</b> The code starts looking for a match at the start of the target,
	 * incrementing the starting index by one after each successful match (unless
	 * {@code searchStr} is an empty string in which case the position is never
	 * incremented and {@code 0} is returned immediately). This means that matches
	 * may overlap.
	 * </p>
	 * <p>
	 * A {@code null} CharSequence will return {@code -1}.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.ordinalIndexOf(null, *, *)          = -1
	 * StringUtils.ordinalIndexOf(*, null, *)          = -1
	 * StringUtils.ordinalIndexOf("", "", *)           = 0
	 * StringUtils.ordinalIndexOf("aabaabaa", "a", 1)  = 0
	 * StringUtils.ordinalIndexOf("aabaabaa", "a", 2)  = 1
	 * StringUtils.ordinalIndexOf("aabaabaa", "b", 1)  = 2
	 * StringUtils.ordinalIndexOf("aabaabaa", "b", 2)  = 5
	 * StringUtils.ordinalIndexOf("aabaabaa", "ab", 1) = 1
	 * StringUtils.ordinalIndexOf("aabaabaa", "ab", 2) = 4
	 * StringUtils.ordinalIndexOf("aabaabaa", "", 1)   = 0
	 * StringUtils.ordinalIndexOf("aabaabaa", "", 2)   = 0
	 * </pre>
	 *
	 * <p>
	 * Matches may overlap:
	 * </p>
	 * 
	 * <pre>
	 * StringUtils.ordinalIndexOf("ababab", "aba", 1)   = 0
	 * StringUtils.ordinalIndexOf("ababab", "aba", 2)   = 2
	 * StringUtils.ordinalIndexOf("ababab", "aba", 3)   = -1
	 *
	 * StringUtils.ordinalIndexOf("abababab", "abab", 1) = 0
	 * StringUtils.ordinalIndexOf("abababab", "abab", 2) = 2
	 * StringUtils.ordinalIndexOf("abababab", "abab", 3) = 4
	 * StringUtils.ordinalIndexOf("abababab", "abab", 4) = -1
	 * </pre>
	 *
	 * <p>
	 * Note that 'head(CharSequence str, int n)' may be implemented as:
	 * </p>
	 *
	 * <pre>
	 * str.substring(0, lastOrdinalIndexOf(str, "\n", n))
	 * </pre>
	 *
	 * @param str       the CharSequence to check, may be null
	 * @param searchStr the CharSequence to find, may be null
	 * @param ordinal   the n-th {@code searchStr} to find
	 * @return the n-th index of the search CharSequence, {@code -1}
	 *         ({@code INDEX_NOT_FOUND}) if no match or {@code null} string input
	 * @since 2.1
	 * @since 3.0 Changed signature from ordinalIndexOf(String, String, int) to
	 *        ordinalIndexOf(CharSequence, CharSequence, int)
	 */
	public static int ordinalIndexOf(final CharSequence str, final CharSequence searchStr, final int ordinal) {
		return ordinalIndexOf(str, searchStr, ordinal, false);
	}

	/**
	 * <p>
	 * Finds the n-th index within a String, handling {@code null}. This method uses
	 * {@link String#indexOf(String)} if possible.
	 * </p>
	 * <p>
	 * Note that matches may overlap
	 * <p>
	 *
	 * <p>
	 * A {@code null} CharSequence will return {@code -1}.
	 * </p>
	 *
	 * @param str       the CharSequence to check, may be null
	 * @param searchStr the CharSequence to find, may be null
	 * @param ordinal   the n-th {@code searchStr} to find, overlapping matches are
	 *                  allowed.
	 * @param lastIndex true if lastOrdinalIndexOf() otherwise false if
	 *                  ordinalIndexOf()
	 * @return the n-th index of the search CharSequence, {@code -1}
	 *         ({@code INDEX_NOT_FOUND}) if no match or {@code null} string input
	 */
	// Shared code between ordinalIndexOf(String, String, int) and
	// lastOrdinalIndexOf(String, String, int)
	private static int ordinalIndexOf(final CharSequence str, final CharSequence searchStr, final int ordinal,
			final boolean lastIndex) {
		if (str == null || searchStr == null || ordinal <= 0) {
			return INDEX_NOT_FOUND;
		}
		if (searchStr.length() == 0) {
			return lastIndex ? str.length() : 0;
		}
		int found = 0;
		// set the initial index beyond the end of the string
		// this is to allow for the initial index decrement/increment
		int index = lastIndex ? str.length() : INDEX_NOT_FOUND;
		do {
			if (lastIndex) {
				index = CharSequenceUtils.lastIndexOf(str, searchStr, index - 1); // step backwards thru string
			} else {
				index = CharSequenceUtils.indexOf(str, searchStr, index + 1); // step forwards through string
			}
			if (index < 0) {
				return index;
			}
			found++;
		} while (found < ordinal);
		return index;
	}

	/**
	 * <p>
	 * Overlays part of a String with another String.
	 * </p>
	 *
	 * <p>
	 * A {@code null} string input returns {@code null}. A negative index is treated
	 * as zero. An index greater than the string length is treated as the string
	 * length. The start index is always the smaller of the two indices.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.overlay(null, *, *, *)            = null
	 * StringUtils.overlay("", "abc", 0, 0)          = "abc"
	 * StringUtils.overlay("abcdef", null, 2, 4)     = "abef"
	 * StringUtils.overlay("abcdef", "", 2, 4)       = "abef"
	 * StringUtils.overlay("abcdef", "", 4, 2)       = "abef"
	 * StringUtils.overlay("abcdef", "zzzz", 2, 4)   = "abzzzzef"
	 * StringUtils.overlay("abcdef", "zzzz", 4, 2)   = "abzzzzef"
	 * StringUtils.overlay("abcdef", "zzzz", -1, 4)  = "zzzzef"
	 * StringUtils.overlay("abcdef", "zzzz", 2, 8)   = "abzzzz"
	 * StringUtils.overlay("abcdef", "zzzz", -2, -3) = "zzzzabcdef"
	 * StringUtils.overlay("abcdef", "zzzz", 8, 10)  = "abcdefzzzz"
	 * </pre>
	 *
	 * @param str     the String to do overlaying in, may be null
	 * @param overlay the String to overlay, may be null
	 * @param start   the position to start overlaying at
	 * @param end     the position to stop overlaying before
	 * @return overlayed String, {@code null} if null String input
	 * @since 2.0
	 */
	public static String overlay(final String str, String overlay, int start, int end) {
		if (str == null) {
			return null;
		}
		if (overlay == null) {
			overlay = EMPTY;
		}
		final 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) {
			final int temp = start;
			start = end;
			end = temp;
		}
		return str.substring(0, start) + overlay + str.substring(end);
	}

	/**
	 * Prepends the prefix to the start of the string if the string does not already
	 * start with any of the prefixes.
	 *
	 * @param str        The string.
	 * @param prefix     The prefix to prepend to the start of the string.
	 * @param ignoreCase Indicates whether the compare should ignore case.
	 * @param prefixes   Additional prefixes that are valid (optional).
	 *
	 * @return A new String if prefix was prepended, the same string otherwise.
	 */
	private static String prependIfMissing(final String str, final CharSequence prefix, final boolean ignoreCase,
			final CharSequence... prefixes) {
		if (str == null || isEmpty(prefix) || startsWith(str, prefix, ignoreCase)) {
			return str;
		}
		if (prefixes.length > 0) {
			for (final CharSequence p : prefixes) {
				if (startsWith(str, p, ignoreCase)) {
					return str;
				}
			}
		}
		return prefix.toString() + str;
	}

	/**
	 * Prepends the prefix to the start of the string if the string does not already
	 * start with any of the prefixes.
	 *
	 * <pre>
	 * StringUtils.prependIfMissing(null, null) = null
	 * StringUtils.prependIfMissing("abc", null) = "abc"
	 * StringUtils.prependIfMissing("", "xyz") = "xyz"
	 * StringUtils.prependIfMissing("abc", "xyz") = "xyzabc"
	 * StringUtils.prependIfMissing("xyzabc", "xyz") = "xyzabc"
	 * StringUtils.prependIfMissing("XYZabc", "xyz") = "xyzXYZabc"
	 * </pre>
	 * <p>
	 * With additional prefixes,
	 * </p>
	 * 
	 * <pre>
	 * StringUtils.prependIfMissing(null, null, null) = null
	 * StringUtils.prependIfMissing("abc", null, null) = "abc"
	 * StringUtils.prependIfMissing("", "xyz", null) = "xyz"
	 * StringUtils.prependIfMissing("abc", "xyz", new CharSequence[]{null}) = "xyzabc"
	 * StringUtils.prependIfMissing("abc", "xyz", "") = "abc"
	 * StringUtils.prependIfMissing("abc", "xyz", "mno") = "xyzabc"
	 * StringUtils.prependIfMissing("xyzabc", "xyz", "mno") = "xyzabc"
	 * StringUtils.prependIfMissing("mnoabc", "xyz", "mno") = "mnoabc"
	 * StringUtils.prependIfMissing("XYZabc", "xyz", "mno") = "xyzXYZabc"
	 * StringUtils.prependIfMissing("MNOabc", "xyz", "mno") = "xyzMNOabc"
	 * </pre>
	 *
	 * @param str      The string.
	 * @param prefix   The prefix to prepend to the start of the string.
	 * @param prefixes Additional prefixes that are valid.
	 *
	 * @return A new String if prefix was prepended, the same string otherwise.
	 *
	 * @since 3.2
	 */
	public static String prependIfMissing(final String str, final CharSequence prefix, final CharSequence... prefixes) {
		return prependIfMissing(str, prefix, false, prefixes);
	}

	/**
	 * Prepends the prefix to the start of the string if the string does not already
	 * start, case insensitive, with any of the prefixes.
	 *
	 * <pre>
	 * StringUtils.prependIfMissingIgnoreCase(null, null) = null
	 * StringUtils.prependIfMissingIgnoreCase("abc", null) = "abc"
	 * StringUtils.prependIfMissingIgnoreCase("", "xyz") = "xyz"
	 * StringUtils.prependIfMissingIgnoreCase("abc", "xyz") = "xyzabc"
	 * StringUtils.prependIfMissingIgnoreCase("xyzabc", "xyz") = "xyzabc"
	 * StringUtils.prependIfMissingIgnoreCase("XYZabc", "xyz") = "XYZabc"
	 * </pre>
	 * <p>
	 * With additional prefixes,
	 * </p>
	 * 
	 * <pre>
	 * StringUtils.prependIfMissingIgnoreCase(null, null, null) = null
	 * StringUtils.prependIfMissingIgnoreCase("abc", null, null) = "abc"
	 * StringUtils.prependIfMissingIgnoreCase("", "xyz", null) = "xyz"
	 * StringUtils.prependIfMissingIgnoreCase("abc", "xyz", new CharSequence[]{null}) = "xyzabc"
	 * StringUtils.prependIfMissingIgnoreCase("abc", "xyz", "") = "abc"
	 * StringUtils.prependIfMissingIgnoreCase("abc", "xyz", "mno") = "xyzabc"
	 * StringUtils.prependIfMissingIgnoreCase("xyzabc", "xyz", "mno") = "xyzabc"
	 * StringUtils.prependIfMissingIgnoreCase("mnoabc", "xyz", "mno") = "mnoabc"
	 * StringUtils.prependIfMissingIgnoreCase("XYZabc", "xyz", "mno") = "XYZabc"
	 * StringUtils.prependIfMissingIgnoreCase("MNOabc", "xyz", "mno") = "MNOabc"
	 * </pre>
	 *
	 * @param str      The string.
	 * @param prefix   The prefix to prepend to the start of the string.
	 * @param prefixes Additional prefixes that are valid (optional).
	 *
	 * @return A new String if prefix was prepended, the same string otherwise.
	 *
	 * @since 3.2
	 */
	public static String prependIfMissingIgnoreCase(final String str, final CharSequence prefix,
			final CharSequence... prefixes) {
		return prependIfMissing(str, prefix, true, prefixes);
	}

	/**
	 * <p>
	 * Removes all occurrences of a character from within the source string.
	 * </p>
	 *
	 * <p>
	 * A {@code null} source string will return {@code null}. An empty ("") source
	 * string will return the empty string.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.remove(null, *)       = null
	 * StringUtils.remove("", *)         = ""
	 * StringUtils.remove("queued", 'u') = "qeed"
	 * StringUtils.remove("queued", 'z') = "queued"
	 * </pre>
	 *
	 * @param str    the source String to search, may be null
	 * @param remove the char to search for and remove, may be null
	 * @return the substring with the char removed if found, {@code null} if null
	 *         String input
	 * @since 2.1
	 */
	public static String remove(final String str, final char remove) {
		if (isEmpty(str) || str.indexOf(remove) == INDEX_NOT_FOUND) {
			return str;
		}
		final 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);
	}

	/**
	 * <p>
	 * Removes all occurrences of a substring from within the source string.
	 * </p>
	 *
	 * <p>
	 * A {@code null} source string will return {@code null}. An empty ("") source
	 * string will return the empty string. A {@code null} remove string will return
	 * the source string. An empty ("") remove string will return the source string.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.remove(null, *)        = null
	 * StringUtils.remove("", *)          = ""
	 * StringUtils.remove(*, null)        = *
	 * StringUtils.remove(*, "")          = *
	 * StringUtils.remove("queued", "ue") = "qd"
	 * StringUtils.remove("queued", "zz") = "queued"
	 * </pre>
	 *
	 * @param str    the source String to search, may be null
	 * @param remove the String to search for and remove, may be null
	 * @return the substring with the string removed if found, {@code null} if null
	 *         String input
	 * @since 2.1
	 */
	public static String remove(final String str, final String remove) {
		if (isEmpty(str) || isEmpty(remove)) {
			return str;
		}
		return replace(str, remove, EMPTY, -1);
	}

	/**
	 * <p>
	 * Removes each substring of the text String that matches the given regular
	 * expression.
	 * </p>
	 *
	 * This method is a {@code null} safe equivalent to:
	 * <ul>
	 * <li>{@code text.replaceAll(regex, StringUtils.EMPTY)}</li>
	 * <li>{@code Pattern.compile(regex).matcher(text).replaceAll(StringUtils.EMPTY)}</li>
	 * </ul>
	 *
	 * <p>
	 * A {@code null} reference passed to this method is a no-op.
	 * </p>
	 *
	 * <p>
	 * Unlike in the {@link #removePattern(String, String)} method, the
	 * {@link Pattern#DOTALL} option is NOT automatically added. To use the DOTALL
	 * option prepend {@code "(?s)"} to the regex. DOTALL is also known as
	 * single-line mode in Perl.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.removeAll(null, *)      = null
	 * StringUtils.removeAll("any", (String) null)  = "any"
	 * StringUtils.removeAll("any", "")    = "any"
	 * StringUtils.removeAll("any", ".*")  = ""
	 * StringUtils.removeAll("any", ".+")  = ""
	 * StringUtils.removeAll("abc", ".?")  = ""
	 * StringUtils.removeAll("A&lt;__&gt;\n&lt;__&gt;B", "&lt;.*&gt;")      = "A\nB"
	 * StringUtils.removeAll("A&lt;__&gt;\n&lt;__&gt;B", "(?s)&lt;.*&gt;")  = "AB"
	 * StringUtils.removeAll("ABCabc123abc", "[a-z]")     = "ABC123"
	 * </pre>
	 *
	 * @param text  text to remove from, may be null
	 * @param regex the regular expression to which this string is to be matched
	 * @return the text with any removes processed, {@code null} if null String
	 *         input
	 *
	 * @throws java.util.regex.PatternSyntaxException if the regular expression's
	 *                                                syntax is invalid
	 *
	 * @see #replaceAll(String, String, String)
	 * @see #removePattern(String, String)
	 * @see String#replaceAll(String, String)
	 * @see java.util.regex.Pattern
	 * @see java.util.regex.Pattern#DOTALL
	 * @since 3.5
	 *
	 * @deprecated Moved to RegExUtils.
	 */
	@Deprecated
	public static String removeAll(final String text, final String regex) {
		return RegExUtils.removeAll(text, regex);
	}

	/**
	 * <p>
	 * Removes a substring only if it is at the end of a source string, otherwise
	 * returns the source string.
	 * </p>
	 *
	 * <p>
	 * A {@code null} source string will return {@code null}. An empty ("") source
	 * string will return the empty string. A {@code null} search string will return
	 * the source string.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.removeEnd(null, *)      = null
	 * StringUtils.removeEnd("", *)        = ""
	 * StringUtils.removeEnd(*, null)      = *
	 * StringUtils.removeEnd("www.domain.com", ".com.")  = "www.domain.com"
	 * StringUtils.removeEnd("www.domain.com", ".com")   = "www.domain"
	 * StringUtils.removeEnd("www.domain.com", "domain") = "www.domain.com"
	 * StringUtils.removeEnd("abc", "")    = "abc"
	 * </pre>
	 *
	 * @param str    the source String to search, may be null
	 * @param remove the String to search for and remove, may be null
	 * @return the substring with the string removed if found, {@code null} if null
	 *         String input
	 * @since 2.1
	 */
	public static String removeEnd(final String str, final String remove) {
		if (isEmpty(str) || isEmpty(remove)) {
			return str;
		}
		if (str.endsWith(remove)) {
			return str.substring(0, str.length() - remove.length());
		}
		return str;
	}

	/**
	 * <p>
	 * Case insensitive removal of a substring if it is at the end of a source
	 * string, otherwise returns the source string.
	 * </p>
	 *
	 * <p>
	 * A {@code null} source string will return {@code null}. An empty ("") source
	 * string will return the empty string. A {@code null} search string will return
	 * the source string.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.removeEndIgnoreCase(null, *)      = null
	 * StringUtils.removeEndIgnoreCase("", *)        = ""
	 * StringUtils.removeEndIgnoreCase(*, null)      = *
	 * StringUtils.removeEndIgnoreCase("www.domain.com", ".com.")  = "www.domain.com"
	 * StringUtils.removeEndIgnoreCase("www.domain.com", ".com")   = "www.domain"
	 * StringUtils.removeEndIgnoreCase("www.domain.com", "domain") = "www.domain.com"
	 * StringUtils.removeEndIgnoreCase("abc", "")    = "abc"
	 * StringUtils.removeEndIgnoreCase("www.domain.com", ".COM") = "www.domain")
	 * StringUtils.removeEndIgnoreCase("www.domain.COM", ".com") = "www.domain")
	 * </pre>
	 *
	 * @param str    the source String to search, may be null
	 * @param remove the String to search for (case insensitive) and remove, may be
	 *               null
	 * @return the substring with the string removed if found, {@code null} if null
	 *         String input
	 * @since 2.4
	 */
	public static String removeEndIgnoreCase(final String str, final String remove) {
		if (isEmpty(str) || isEmpty(remove)) {
			return str;
		}
		if (endsWithIgnoreCase(str, remove)) {
			return str.substring(0, str.length() - remove.length());
		}
		return str;
	}

	/**
	 * <p>
	 * Removes the first substring of the text string that matches the given regular
	 * expression.
	 * </p>
	 *
	 * This method is a {@code null} safe equivalent to:
	 * <ul>
	 * <li>{@code text.replaceFirst(regex, StringUtils.EMPTY)}</li>
	 * <li>{@code Pattern.compile(regex).matcher(text).replaceFirst(StringUtils.EMPTY)}</li>
	 * </ul>
	 *
	 * <p>
	 * A {@code null} reference passed to this method is a no-op.
	 * </p>
	 *
	 * <p>
	 * The {@link Pattern#DOTALL} option is NOT automatically added. To use the
	 * DOTALL option prepend {@code "(?s)"} to the regex. DOTALL is also known as
	 * single-line mode in Perl.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.removeFirst(null, *)      = null
	 * StringUtils.removeFirst("any", (String) null)  = "any"
	 * StringUtils.removeFirst("any", "")    = "any"
	 * StringUtils.removeFirst("any", ".*")  = ""
	 * StringUtils.removeFirst("any", ".+")  = ""
	 * StringUtils.removeFirst("abc", ".?")  = "bc"
	 * StringUtils.removeFirst("A&lt;__&gt;\n&lt;__&gt;B", "&lt;.*&gt;")      = "A\n&lt;__&gt;B"
	 * StringUtils.removeFirst("A&lt;__&gt;\n&lt;__&gt;B", "(?s)&lt;.*&gt;")  = "AB"
	 * StringUtils.removeFirst("ABCabc123", "[a-z]")          = "ABCbc123"
	 * StringUtils.removeFirst("ABCabc123abc", "[a-z]+")      = "ABC123abc"
	 * </pre>
	 *
	 * @param text  text to remove from, may be null
	 * @param regex the regular expression to which this string is to be matched
	 * @return the text with the first replacement processed, {@code null} if null
	 *         String input
	 *
	 * @throws java.util.regex.PatternSyntaxException if the regular expression's
	 *                                                syntax is invalid
	 *
	 * @see #replaceFirst(String, String, String)
	 * @see String#replaceFirst(String, String)
	 * @see java.util.regex.Pattern
	 * @see java.util.regex.Pattern#DOTALL
	 * @since 3.5
	 *
	 * @deprecated Moved to RegExUtils.
	 */
	@Deprecated
	public static String removeFirst(final String text, final String regex) {
		return replaceFirst(text, regex, EMPTY);
	}

	/**
	 * <p>
	 * Case insensitive removal of all occurrences of a substring from within the
	 * source string.
	 * </p>
	 *
	 * <p>
	 * A {@code null} source string will return {@code null}. An empty ("") source
	 * string will return the empty string. A {@code null} remove string will return
	 * the source string. An empty ("") remove string will return the source string.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.removeIgnoreCase(null, *)        = null
	 * StringUtils.removeIgnoreCase("", *)          = ""
	 * StringUtils.removeIgnoreCase(*, null)        = *
	 * StringUtils.removeIgnoreCase(*, "")          = *
	 * StringUtils.removeIgnoreCase("queued", "ue") = "qd"
	 * StringUtils.removeIgnoreCase("queued", "zz") = "queued"
	 * StringUtils.removeIgnoreCase("quEUed", "UE") = "qd"
	 * StringUtils.removeIgnoreCase("queued", "zZ") = "queued"
	 * </pre>
	 *
	 * @param str    the source String to search, may be null
	 * @param remove the String to search for (case insensitive) and remove, may be
	 *               null
	 * @return the substring with the string removed if found, {@code null} if null
	 *         String input
	 * @since 3.5
	 */
	public static String removeIgnoreCase(final String str, final String remove) {
		return replaceIgnoreCase(str, remove, EMPTY, -1);
	}

	/**
	 * <p>
	 * Removes each substring of the source String that matches the given regular
	 * expression using the DOTALL option.
	 * </p>
	 *
	 * This call is a {@code null} safe equivalent to:
	 * <ul>
	 * <li>{@code source.replaceAll(&quot;(?s)&quot; + regex, StringUtils.EMPTY)}</li>
	 * <li>{@code Pattern.compile(regex, Pattern.DOTALL).matcher(source).replaceAll(StringUtils.EMPTY)}</li>
	 * </ul>
	 *
	 * <p>
	 * A {@code null} reference passed to this method is a no-op.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.removePattern(null, *)       = null
	 * StringUtils.removePattern("any", (String) null)   = "any"
	 * StringUtils.removePattern("A&lt;__&gt;\n&lt;__&gt;B", "&lt;.*&gt;")  = "AB"
	 * StringUtils.removePattern("ABCabc123", "[a-z]")    = "ABC123"
	 * </pre>
	 *
	 * @param source the source string
	 * @param regex  the regular expression to which this string is to be matched
	 * @return The resulting {@code String}
	 * @see #replacePattern(String, String, String)
	 * @see String#replaceAll(String, String)
	 * @see Pattern#DOTALL
	 * @since 3.2
	 * @since 3.5 Changed {@code null} reference passed to this method is a no-op.
	 *
	 * @deprecated Moved to RegExUtils.
	 */
	@Deprecated
	public static String removePattern(final String source, final String regex) {
		return RegExUtils.removePattern(source, regex);
	}

	/**
	 * <p>
	 * Removes a substring only if it is at the beginning of a source string,
	 * otherwise returns the source string.
	 * </p>
	 *
	 * <p>
	 * A {@code null} source string will return {@code null}. An empty ("") source
	 * string will return the empty string. A {@code null} search string will return
	 * the source string.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.removeStart(null, *)      = null
	 * StringUtils.removeStart("", *)        = ""
	 * StringUtils.removeStart(*, null)      = *
	 * StringUtils.removeStart("www.domain.com", "www.")   = "domain.com"
	 * StringUtils.removeStart("domain.com", "www.")       = "domain.com"
	 * StringUtils.removeStart("www.domain.com", "domain") = "www.domain.com"
	 * StringUtils.removeStart("abc", "")    = "abc"
	 * </pre>
	 *
	 * @param str    the source String to search, may be null
	 * @param remove the String to search for and remove, may be null
	 * @return the substring with the string removed if found, {@code null} if null
	 *         String input
	 * @since 2.1
	 */
	public static String removeStart(final String str, final String remove) {
		if (isEmpty(str) || isEmpty(remove)) {
			return str;
		}
		if (str.startsWith(remove)) {
			return str.substring(remove.length());
		}
		return str;
	}

	/**
	 * <p>
	 * Case insensitive removal of a substring if it is at the beginning of a source
	 * string, otherwise returns the source string.
	 * </p>
	 *
	 * <p>
	 * A {@code null} source string will return {@code null}. An empty ("") source
	 * string will return the empty string. A {@code null} search string will return
	 * the source string.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.removeStartIgnoreCase(null, *)      = null
	 * StringUtils.removeStartIgnoreCase("", *)        = ""
	 * StringUtils.removeStartIgnoreCase(*, null)      = *
	 * StringUtils.removeStartIgnoreCase("www.domain.com", "www.")   = "domain.com"
	 * StringUtils.removeStartIgnoreCase("www.domain.com", "WWW.")   = "domain.com"
	 * StringUtils.removeStartIgnoreCase("domain.com", "www.")       = "domain.com"
	 * StringUtils.removeStartIgnoreCase("www.domain.com", "domain") = "www.domain.com"
	 * StringUtils.removeStartIgnoreCase("abc", "")    = "abc"
	 * </pre>
	 *
	 * @param str    the source String to search, may be null
	 * @param remove the String to search for (case insensitive) and remove, may be
	 *               null
	 * @return the substring with the string removed if found, {@code null} if null
	 *         String input
	 * @since 2.4
	 */
	public static String removeStartIgnoreCase(final String str, final String remove) {
		if (str != null && startsWithIgnoreCase(str, remove)) {
			return str.substring(length(remove));
		}
		return str;
	}

	/**
	 * <p>
	 * Returns padding using the specified delimiter repeated to a given length.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.repeat('e', 0)  = ""
	 * StringUtils.repeat('e', 3)  = "eee"
	 * StringUtils.repeat('e', -2) = ""
	 * </pre>
	 *
	 * <p>
	 * Note: this method does not support padding with
	 * <a href="http://www.unicode.org/glossary/#supplementary_character">Unicode
	 * Supplementary Characters</a> as they require a pair of {@code char}s to be
	 * represented. If you are needing to support full I18N of your applications
	 * consider using {@link #repeat(String, int)} instead.
	 * </p>
	 *
	 * @param ch     character to repeat
	 * @param repeat number of times to repeat char, negative treated as zero
	 * @return String with repeated character
	 * @see #repeat(String, int)
	 */
	public static String repeat(final char ch, final int repeat) {
		if (repeat <= 0) {
			return EMPTY;
		}
		final char[] buf = new char[repeat];
		Arrays.fill(buf, ch);
		return new String(buf);
	}

	/**
	 * <p>
	 * Repeat a String {@code repeat} times to form a new String.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.repeat(null, 2) = null
	 * StringUtils.repeat("", 0)   = ""
	 * StringUtils.repeat("", 2)   = ""
	 * StringUtils.repeat("a", 3)  = "aaa"
	 * StringUtils.repeat("ab", 2) = "abab"
	 * StringUtils.repeat("a", -2) = ""
	 * </pre>
	 *
	 * @param str    the String to repeat, may be null
	 * @param repeat number of times to repeat str, negative treated as zero
	 * @return a new String consisting of the original String repeated, {@code null}
	 *         if null String input
	 */
	public static String repeat(final String str, final int repeat) {
		// Performance tuned for 2.0 (JDK1.4)
		if (str == null) {
			return null;
		}
		if (repeat <= 0) {
			return EMPTY;
		}
		final int inputLength = str.length();
		if (repeat == 1 || inputLength == 0) {
			return str;
		}
		if (inputLength == 1 && repeat <= PAD_LIMIT) {
			return repeat(str.charAt(0), repeat);
		}

		final int outputLength = inputLength * repeat;
		switch (inputLength) {
		case 1:
			return repeat(str.charAt(0), repeat);
		case 2:
			final char ch0 = str.charAt(0);
			final char ch1 = str.charAt(1);
			final char[] output2 = new char[outputLength];
			for (int i = repeat * 2 - 2; i >= 0; i--, i--) {
				output2[i] = ch0;
				output2[i + 1] = ch1;
			}
			return new String(output2);
		default:
			final StringBuilder buf = new StringBuilder(outputLength);
			for (int i = 0; i < repeat; i++) {
				buf.append(str);
			}
			return buf.toString();
		}
	}

	/**
	 * <p>
	 * Repeat a String {@code repeat} times to form a new String, with a String
	 * separator injected each time.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.repeat(null, null, 2) = null
	 * StringUtils.repeat(null, "x", 2)  = null
	 * StringUtils.repeat("", null, 0)   = ""
	 * StringUtils.repeat("", "", 2)     = ""
	 * StringUtils.repeat("", "x", 3)    = "xxx"
	 * StringUtils.repeat("?", ", ", 3)  = "?, ?, ?"
	 * </pre>
	 *
	 * @param str       the String to repeat, may be null
	 * @param separator the String to inject, may be null
	 * @param repeat    number of times to repeat str, negative treated as zero
	 * @return a new String consisting of the original String repeated, {@code null}
	 *         if null String input
	 * @since 2.5
	 */
	public static String repeat(final String str, final String separator, final int repeat) {
		if (str == null || separator == null) {
			return repeat(str, repeat);
		}
		// given that repeat(String, int) is quite optimized, better to rely on it than
		// try and splice this into it
		final String result = repeat(str + separator, repeat);
		return removeEnd(result, separator);
	}

	/**
	 * <p>
	 * Replaces all occurrences of a String within another String.
	 * </p>
	 *
	 * <p>
	 * A {@code null} reference passed to this method is a no-op.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.replace(null, *, *)        = null
	 * StringUtils.replace("", *, *)          = ""
	 * StringUtils.replace("any", null, *)    = "any"
	 * StringUtils.replace("any", *, null)    = "any"
	 * StringUtils.replace("any", "", *)      = "any"
	 * StringUtils.replace("aba", "a", null)  = "aba"
	 * StringUtils.replace("aba", "a", "")    = "b"
	 * StringUtils.replace("aba", "a", "z")   = "zbz"
	 * </pre>
	 *
	 * @see #replace(String text, String searchString, String replacement, int max)
	 * @param text         text to search and replace in, may be null
	 * @param searchString the String to search for, may be null
	 * @param replacement  the String to replace it with, may be null
	 * @return the text with any replacements processed, {@code null} if null String
	 *         input
	 */
	public static String replace(final String text, final String searchString, final String replacement) {
		return replace(text, searchString, replacement, -1);
	}

	/**
	 * <p>
	 * Replaces a String with another String inside a larger String, for the first
	 * {@code max} values of the search String.
	 * </p>
	 *
	 * <p>
	 * A {@code null} reference passed to this method is a no-op.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.replace(null, *, *, *)         = null
	 * StringUtils.replace("", *, *, *)           = ""
	 * StringUtils.replace("any", null, *, *)     = "any"
	 * StringUtils.replace("any", *, null, *)     = "any"
	 * StringUtils.replace("any", "", *, *)       = "any"
	 * StringUtils.replace("any", *, *, 0)        = "any"
	 * StringUtils.replace("abaa", "a", null, -1) = "abaa"
	 * StringUtils.replace("abaa", "a", "", -1)   = "b"
	 * StringUtils.replace("abaa", "a", "z", 0)   = "abaa"
	 * StringUtils.replace("abaa", "a", "z", 1)   = "zbaa"
	 * StringUtils.replace("abaa", "a", "z", 2)   = "zbza"
	 * StringUtils.replace("abaa", "a", "z", -1)  = "zbzz"
	 * </pre>
	 *
	 * @param text         text to search and replace in, may be null
	 * @param searchString the String to search for, may be null
	 * @param replacement  the String to replace it with, may be null
	 * @param max          maximum number of values to replace, or {@code -1} if no
	 *                     maximum
	 * @return the text with any replacements processed, {@code null} if null String
	 *         input
	 */
	public static String replace(final String text, final String searchString, final String replacement,
			final int max) {
		return replace(text, searchString, replacement, max, false);
	}

	/**
	 * <p>
	 * Replaces a String with another String inside a larger String, for the first
	 * {@code max} values of the search String, case sensitively/insensitively based
	 * on {@code ignoreCase} value.
	 * </p>
	 *
	 * <p>
	 * A {@code null} reference passed to this method is a no-op.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.replace(null, *, *, *, false)         = null
	 * StringUtils.replace("", *, *, *, false)           = ""
	 * StringUtils.replace("any", null, *, *, false)     = "any"
	 * StringUtils.replace("any", *, null, *, false)     = "any"
	 * StringUtils.replace("any", "", *, *, false)       = "any"
	 * StringUtils.replace("any", *, *, 0, false)        = "any"
	 * StringUtils.replace("abaa", "a", null, -1, false) = "abaa"
	 * StringUtils.replace("abaa", "a", "", -1, false)   = "b"
	 * StringUtils.replace("abaa", "a", "z", 0, false)   = "abaa"
	 * StringUtils.replace("abaa", "A", "z", 1, false)   = "abaa"
	 * StringUtils.replace("abaa", "A", "z", 1, true)   = "zbaa"
	 * StringUtils.replace("abAa", "a", "z", 2, true)   = "zbza"
	 * StringUtils.replace("abAa", "a", "z", -1, true)  = "zbzz"
	 * </pre>
	 *
	 * @param text         text to search and replace in, may be null
	 * @param searchString the String to search for (case insensitive), may be null
	 * @param replacement  the String to replace it with, may be null
	 * @param max          maximum number of values to replace, or {@code -1} if no
	 *                     maximum
	 * @param ignoreCase   if true replace is case insensitive, otherwise case
	 *                     sensitive
	 * @return the text with any replacements processed, {@code null} if null String
	 *         input
	 */
	private static String replace(final String text, String searchString, final String replacement, int max,
			final boolean ignoreCase) {
		if (isEmpty(text) || isEmpty(searchString) || replacement == null || max == 0) {
			return text;
		}
		if (ignoreCase) {
			searchString = searchString.toLowerCase();
		}
		int start = 0;
		int end = ignoreCase ? indexOfIgnoreCase(text, searchString, start) : indexOf(text, searchString, start);
		if (end == INDEX_NOT_FOUND) {
			return text;
		}
		final int replLength = searchString.length();
		int increase = Math.max(replacement.length() - replLength, 0);
		increase *= max < 0 ? 16 : Math.min(max, 64);
		final StringBuilder buf = new StringBuilder(text.length() + increase);
		while (end != INDEX_NOT_FOUND) {
			buf.append(text, start, end).append(replacement);
			start = end + replLength;
			if (--max == 0) {
				break;
			}
			end = ignoreCase ? indexOfIgnoreCase(text, searchString, start) : indexOf(text, searchString, start);
		}
		buf.append(text, start, text.length());
		return buf.toString();
	}

	/**
	 * <p>
	 * Replaces each substring of the text String that matches the given regular
	 * expression with the given replacement.
	 * </p>
	 *
	 * This method is a {@code null} safe equivalent to:
	 * <ul>
	 * <li>{@code text.replaceAll(regex, replacement)}</li>
	 * <li>{@code Pattern.compile(regex).matcher(text).replaceAll(replacement)}</li>
	 * </ul>
	 *
	 * <p>
	 * A {@code null} reference passed to this method is a no-op.
	 * </p>
	 *
	 * <p>
	 * Unlike in the {@link #replacePattern(String, String, String)} method, the
	 * {@link Pattern#DOTALL} option is NOT automatically added. To use the DOTALL
	 * option prepend {@code "(?s)"} to the regex. DOTALL is also known as
	 * single-line mode in Perl.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.replaceAll(null, *, *)       = null
	 * StringUtils.replaceAll("any", (String) null, *)   = "any"
	 * StringUtils.replaceAll("any", *, null)   = "any"
	 * StringUtils.replaceAll("", "", "zzz")    = "zzz"
	 * StringUtils.replaceAll("", ".*", "zzz")  = "zzz"
	 * StringUtils.replaceAll("", ".+", "zzz")  = ""
	 * StringUtils.replaceAll("abc", "", "ZZ")  = "ZZaZZbZZcZZ"
	 * StringUtils.replaceAll("&lt;__&gt;\n&lt;__&gt;", "&lt;.*&gt;", "z")      = "z\nz"
	 * StringUtils.replaceAll("&lt;__&gt;\n&lt;__&gt;", "(?s)&lt;.*&gt;", "z")  = "z"
	 * StringUtils.replaceAll("ABCabc123", "[a-z]", "_")       = "ABC___123"
	 * StringUtils.replaceAll("ABCabc123", "[^A-Z0-9]+", "_")  = "ABC_123"
	 * StringUtils.replaceAll("ABCabc123", "[^A-Z0-9]+", "")   = "ABC123"
	 * StringUtils.replaceAll("Lorem ipsum  dolor   sit", "( +)([a-z]+)", "_$2")  = "Lorem_ipsum_dolor_sit"
	 * </pre>
	 *
	 * @param text        text to search and replace in, may be null
	 * @param regex       the regular expression to which this string is to be
	 *                    matched
	 * @param replacement the string to be substituted for each match
	 * @return the text with any replacements processed, {@code null} if null String
	 *         input
	 *
	 * @throws java.util.regex.PatternSyntaxException if the regular expression's
	 *                                                syntax is invalid
	 *
	 * @see #replacePattern(String, String, String)
	 * @see String#replaceAll(String, String)
	 * @see java.util.regex.Pattern
	 * @see java.util.regex.Pattern#DOTALL
	 * @since 3.5
	 *
	 * @deprecated Moved to RegExUtils.
	 */
	@Deprecated
	public static String replaceAll(final String text, final String regex, final String replacement) {
		return RegExUtils.replaceAll(text, regex, replacement);
	}

	/**
	 * <p>
	 * Replaces all occurrences of a character in a String with another. This is a
	 * null-safe version of {@link String#replace(char, char)}.
	 * </p>
	 *
	 * <p>
	 * A {@code null} string input returns {@code null}. An empty ("") string input
	 * returns an empty string.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.replaceChars(null, *, *)        = null
	 * StringUtils.replaceChars("", *, *)          = ""
	 * StringUtils.replaceChars("abcba", 'b', 'y') = "aycya"
	 * StringUtils.replaceChars("abcba", 'z', 'y') = "abcba"
	 * </pre>
	 *
	 * @param str         String to replace characters in, may be null
	 * @param searchChar  the character to search for, may be null
	 * @param replaceChar the character to replace, may be null
	 * @return modified String, {@code null} if null string input
	 * @since 2.0
	 */
	public static String replaceChars(final String str, final char searchChar, final char replaceChar) {
		if (str == null) {
			return null;
		}
		return str.replace(searchChar, replaceChar);
	}

	/**
	 * <p>
	 * Replaces multiple characters in a String in one go. This method can also be
	 * used to delete characters.
	 * </p>
	 *
	 * <p>
	 * For example:<br>
	 * {@code replaceChars(&quot;hello&quot;, &quot;ho&quot;, &quot;jy&quot;) = jelly}.
	 * </p>
	 *
	 * <p>
	 * A {@code null} string input returns {@code null}. An empty ("") string input
	 * returns an empty string. A null or empty set of search characters returns the
	 * input string.
	 * </p>
	 *
	 * <p>
	 * The length of the search characters should normally equal the length of the
	 * replace characters. If the search characters is longer, then the extra search
	 * characters are deleted. If the search characters is shorter, then the extra
	 * replace characters are ignored.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.replaceChars(null, *, *)           = null
	 * StringUtils.replaceChars("", *, *)             = ""
	 * StringUtils.replaceChars("abc", null, *)       = "abc"
	 * StringUtils.replaceChars("abc", "", *)         = "abc"
	 * StringUtils.replaceChars("abc", "b", null)     = "ac"
	 * StringUtils.replaceChars("abc", "b", "")       = "ac"
	 * StringUtils.replaceChars("abcba", "bc", "yz")  = "ayzya"
	 * StringUtils.replaceChars("abcba", "bc", "y")   = "ayya"
	 * StringUtils.replaceChars("abcba", "bc", "yzx") = "ayzya"
	 * </pre>
	 *
	 * @param str          String to replace characters in, may be null
	 * @param searchChars  a set of characters to search for, may be null
	 * @param replaceChars a set of characters to replace, may be null
	 * @return modified String, {@code null} if null string input
	 * @since 2.0
	 */
	public static String replaceChars(final String str, final String searchChars, String replaceChars) {
		if (isEmpty(str) || isEmpty(searchChars)) {
			return str;
		}
		if (replaceChars == null) {
			replaceChars = EMPTY;
		}
		boolean modified = false;
		final int replaceCharsLength = replaceChars.length();
		final int strLength = str.length();
		final StringBuilder buf = new StringBuilder(strLength);
		for (int i = 0; i < strLength; i++) {
			final char ch = str.charAt(i);
			final int index = searchChars.indexOf(ch);
			if (index >= 0) {
				modified = true;
				if (index < replaceCharsLength) {
					buf.append(replaceChars.charAt(index));
				}
			} else {
				buf.append(ch);
			}
		}
		if (modified) {
			return buf.toString();
		}
		return str;
	}

	/**
	 * <p>
	 * Replaces all occurrences of Strings within another String.
	 * </p>
	 *
	 * <p>
	 * A {@code null} reference passed to this method is a no-op, or if any "search
	 * string" or "string to replace" is null, that replace will be ignored. This
	 * will not repeat. For repeating replaces, call the overloaded method.
	 * </p>
	 *
	 * <pre>
	 *  StringUtils.replaceEach(null, *, *)        = null
	 *  StringUtils.replaceEach("", *, *)          = ""
	 *  StringUtils.replaceEach("aba", null, null) = "aba"
	 *  StringUtils.replaceEach("aba", new String[0], null) = "aba"
	 *  StringUtils.replaceEach("aba", null, new String[0]) = "aba"
	 *  StringUtils.replaceEach("aba", new String[]{"a"}, null)  = "aba"
	 *  StringUtils.replaceEach("aba", new String[]{"a"}, new String[]{""})  = "b"
	 *  StringUtils.replaceEach("aba", new String[]{null}, new String[]{"a"})  = "aba"
	 *  StringUtils.replaceEach("abcde", new String[]{"ab", "d"}, new String[]{"w", "t"})  = "wcte"
	 *  (example of how it does not repeat)
	 *  StringUtils.replaceEach("abcde", new String[]{"ab", "d"}, new String[]{"d", "t"})  = "dcte"
	 * </pre>
	 *
	 * @param text            text to search and replace in, no-op if null
	 * @param searchList      the Strings to search for, no-op if null
	 * @param replacementList the Strings to replace them with, no-op if null
	 * @return the text with any replacements processed, {@code null} if null String
	 *         input
	 * @throws IllegalArgumentException if the lengths of the arrays are not the
	 *                                  same (null is ok, and/or size 0)
	 * @since 2.4
	 */
	public static String replaceEach(final String text, final String[] searchList, final String[] replacementList) {
		return replaceEach(text, searchList, replacementList, false, 0);
	}

	/**
	 * <p>
	 * Replace all occurrences of Strings within another String. This is a private
	 * recursive helper method for
	 * {@link #replaceEachRepeatedly(String, String[], String[])} and
	 * {@link #replaceEach(String, String[], String[])}
	 * </p>
	 *
	 * <p>
	 * A {@code null} reference passed to this method is a no-op, or if any "search
	 * string" or "string to replace" is null, that replace will be ignored.
	 * </p>
	 *
	 * <pre>
	 *  StringUtils.replaceEach(null, *, *, *, *) = null
	 *  StringUtils.replaceEach("", *, *, *, *) = ""
	 *  StringUtils.replaceEach("aba", null, null, *, *) = "aba"
	 *  StringUtils.replaceEach("aba", new String[0], null, *, *) = "aba"
	 *  StringUtils.replaceEach("aba", null, new String[0], *, *) = "aba"
	 *  StringUtils.replaceEach("aba", new String[]{"a"}, null, *, *) = "aba"
	 *  StringUtils.replaceEach("aba", new String[]{"a"}, new String[]{""}, *, >=0) = "b"
	 *  StringUtils.replaceEach("aba", new String[]{null}, new String[]{"a"}, *, >=0) = "aba"
	 *  StringUtils.replaceEach("abcde", new String[]{"ab", "d"}, new String[]{"w", "t"}, *, >=0) = "wcte"
	 *  (example of how it repeats)
	 *  StringUtils.replaceEach("abcde", new String[]{"ab", "d"}, new String[]{"d", "t"}, false, >=0) = "dcte"
	 *  StringUtils.replaceEach("abcde", new String[]{"ab", "d"}, new String[]{"d", "t"}, true, >=2) = "tcte"
	 *  StringUtils.replaceEach("abcde", new String[]{"ab", "d"}, new String[]{"d", "ab"}, *, *) = IllegalStateException
	 * </pre>
	 *
	 * @param text            text to search and replace in, no-op if null
	 * @param searchList      the Strings to search for, no-op if null
	 * @param replacementList the Strings to replace them with, no-op if null
	 * @param repeat          if true, then replace repeatedly until there are no
	 *                        more possible replacements or timeToLive < 0
	 * @param timeToLive      if less than 0 then there is a circular reference and
	 *                        endless loop
	 * @return the text with any replacements processed, {@code null} if null String
	 *         input
	 * @throws IllegalStateException    if the search is repeating and there is an
	 *                                  endless loop due to outputs of one being
	 *                                  inputs to another
	 * @throws IllegalArgumentException if the lengths of the arrays are not the
	 *                                  same (null is ok, and/or size 0)
	 * @since 2.4
	 */
	private static String replaceEach(final String text, final String[] searchList, final String[] replacementList,
			final boolean repeat, final int timeToLive) {

		// mchyzer Performance note: This creates very few new objects (one major goal)
		// let me know if there are performance requests, we can create a harness to
		// measure

		// if recursing, this shouldn't be less than 0
		if (timeToLive < 0) {
			final Set<String> searchSet = new HashSet<>(Arrays.asList(searchList));
			final Set<String> replacementSet = new HashSet<>(Arrays.asList(replacementList));
			searchSet.retainAll(replacementSet);
			if (!searchSet.isEmpty()) {
				throw new IllegalStateException("Aborting to protect against StackOverflowError - "
						+ "output of one loop is the input of another");
			}
		}

		if (isEmpty(text) || searchList.length == 0 || replacementList.length == 0
				|| (searchList.length > 0 && timeToLive == -1)) {
			return text;
		}

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

		// make sure lengths are ok, these need to be equal
		if (searchLength != replacementLength) {
			throw new IllegalArgumentException(
					"Search and Replace array lengths don't match: " + searchLength + " vs " + replacementLength);
		}

		// keep track of which still have matches
		final boolean[] noMoreMatchesForReplIndex = new boolean[searchLength];

		// index on index that the match was found
		int textIndex = -1;
		int replaceIndex = -1;
		int tempIndex = -1;

		// index of replace array that will replace the search string found
		// NOTE: logic duplicated below START
		for (int i = 0; i < searchLength; i++) {
			if (noMoreMatchesForReplIndex[i] || isEmpty(searchList[i]) || replacementList[i] == null) {
				continue;
			}
			tempIndex = text.indexOf(searchList[i]);

			// see if we need to keep searching for this
			if (tempIndex == -1) {
				noMoreMatchesForReplIndex[i] = true;
			} else if (textIndex == -1 || tempIndex < textIndex) {
				textIndex = tempIndex;
				replaceIndex = i;
			}
		}
		// NOTE: logic mostly below END

		// no search strings found, we are done
		if (textIndex == -1) {
			return text;
		}

		int start = 0;

		// get a good guess on the size of the result buffer so it doesn't have to
		// double if it goes over a bit
		int increase = 0;

		// count the replacement text elements that are larger than their corresponding
		// text being replaced
		for (int i = 0; i < searchList.length; i++) {
			if (searchList[i] == null || replacementList[i] == null) {
				continue;
			}
			final int greater = replacementList[i].length() - searchList[i].length();
			if (greater > 0) {
				increase += 3 * greater; // assume 3 matches
			}
		}
		// have upper-bound at 20% increase, then let Java take over
		increase = Math.min(increase, text.length() / 5);

		final StringBuilder buf = new StringBuilder(text.length() + increase);

		while (textIndex != -1) {

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

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

			textIndex = -1;
			replaceIndex = -1;
			// find the next earliest match
			// NOTE: logic mostly duplicated above START
			for (int i = 0; i < searchLength; i++) {
				if (noMoreMatchesForReplIndex[i] || searchList[i] == null || searchList[i].isEmpty()
						|| replacementList[i] == null) {
					continue;
				}
				tempIndex = text.indexOf(searchList[i], start);

				// see if we need to keep searching for this
				if (tempIndex == -1) {
					noMoreMatchesForReplIndex[i] = true;
				} else if (textIndex == -1 || tempIndex < textIndex) {
					textIndex = tempIndex;
					replaceIndex = i;
				}
			}
			// NOTE: logic duplicated above END

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

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

	/**
	 * <p>
	 * Replaces all occurrences of Strings within another String.
	 * </p>
	 *
	 * <p>
	 * A {@code null} reference passed to this method is a no-op, or if any "search
	 * string" or "string to replace" is null, that replace will be ignored.
	 * </p>
	 *
	 * <pre>
	 *  StringUtils.replaceEachRepeatedly(null, *, *) = null
	 *  StringUtils.replaceEachRepeatedly("", *, *) = ""
	 *  StringUtils.replaceEachRepeatedly("aba", null, null) = "aba"
	 *  StringUtils.replaceEachRepeatedly("aba", new String[0], null) = "aba"
	 *  StringUtils.replaceEachRepeatedly("aba", null, new String[0]) = "aba"
	 *  StringUtils.replaceEachRepeatedly("aba", new String[]{"a"}, null) = "aba"
	 *  StringUtils.replaceEachRepeatedly("aba", new String[]{"a"}, new String[]{""}) = "b"
	 *  StringUtils.replaceEachRepeatedly("aba", new String[]{null}, new String[]{"a"}) = "aba"
	 *  StringUtils.replaceEachRepeatedly("abcde", new String[]{"ab", "d"}, new String[]{"w", "t"}) = "wcte"
	 *  (example of how it repeats)
	 *  StringUtils.replaceEachRepeatedly("abcde", new String[]{"ab", "d"}, new String[]{"d", "t"}) = "tcte"
	 *  StringUtils.replaceEachRepeatedly("abcde", new String[]{"ab", "d"}, new String[]{"d", "ab"}) = IllegalStateException
	 * </pre>
	 *
	 * @param text            text to search and replace in, no-op if null
	 * @param searchList      the Strings to search for, no-op if null
	 * @param replacementList the Strings to replace them with, no-op if null
	 * @return the text with any replacements processed, {@code null} if null String
	 *         input
	 * @throws IllegalStateException    if the search is repeating and there is an
	 *                                  endless loop due to outputs of one being
	 *                                  inputs to another
	 * @throws IllegalArgumentException if the lengths of the arrays are not the
	 *                                  same (null is ok, and/or size 0)
	 * @since 2.4
	 */
	public static String replaceEachRepeatedly(final String text, final String[] searchList,
			final String[] replacementList) {
		// timeToLive should be 0 if not used or nothing to replace, else it's
		// the length of the replace array
		final int timeToLive = searchList == null ? 0 : searchList.length;
		return replaceEach(text, searchList, replacementList, true, timeToLive);
	}

	/**
	 * <p>
	 * Replaces the first substring of the text string that matches the given
	 * regular expression with the given replacement.
	 * </p>
	 *
	 * This method is a {@code null} safe equivalent to:
	 * <ul>
	 * <li>{@code text.replaceFirst(regex, replacement)}</li>
	 * <li>{@code Pattern.compile(regex).matcher(text).replaceFirst(replacement)}</li>
	 * </ul>
	 *
	 * <p>
	 * A {@code null} reference passed to this method is a no-op.
	 * </p>
	 *
	 * <p>
	 * The {@link Pattern#DOTALL} option is NOT automatically added. To use the
	 * DOTALL option prepend {@code "(?s)"} to the regex. DOTALL is also known as
	 * single-line mode in Perl.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.replaceFirst(null, *, *)       = null
	 * StringUtils.replaceFirst("any", (String) null, *)   = "any"
	 * StringUtils.replaceFirst("any", *, null)   = "any"
	 * StringUtils.replaceFirst("", "", "zzz")    = "zzz"
	 * StringUtils.replaceFirst("", ".*", "zzz")  = "zzz"
	 * StringUtils.replaceFirst("", ".+", "zzz")  = ""
	 * StringUtils.replaceFirst("abc", "", "ZZ")  = "ZZabc"
	 * StringUtils.replaceFirst("&lt;__&gt;\n&lt;__&gt;", "&lt;.*&gt;", "z")      = "z\n&lt;__&gt;"
	 * StringUtils.replaceFirst("&lt;__&gt;\n&lt;__&gt;", "(?s)&lt;.*&gt;", "z")  = "z"
	 * StringUtils.replaceFirst("ABCabc123", "[a-z]", "_")          = "ABC_bc123"
	 * StringUtils.replaceFirst("ABCabc123abc", "[^A-Z0-9]+", "_")  = "ABC_123abc"
	 * StringUtils.replaceFirst("ABCabc123abc", "[^A-Z0-9]+", "")   = "ABC123abc"
	 * StringUtils.replaceFirst("Lorem ipsum  dolor   sit", "( +)([a-z]+)", "_$2")  = "Lorem_ipsum  dolor   sit"
	 * </pre>
	 *
	 * @param text        text to search and replace in, may be null
	 * @param regex       the regular expression to which this string is to be
	 *                    matched
	 * @param replacement the string to be substituted for the first match
	 * @return the text with the first replacement processed, {@code null} if null
	 *         String input
	 *
	 * @throws java.util.regex.PatternSyntaxException if the regular expression's
	 *                                                syntax is invalid
	 *
	 * @see String#replaceFirst(String, String)
	 * @see java.util.regex.Pattern
	 * @see java.util.regex.Pattern#DOTALL
	 * @since 3.5
	 *
	 * @deprecated Moved to RegExUtils.
	 */
	@Deprecated
	public static String replaceFirst(final String text, final String regex, final String replacement) {
		return RegExUtils.replaceFirst(text, regex, replacement);
	}

	/**
	 * <p>
	 * Case insensitively replaces all occurrences of a String within another
	 * String.
	 * </p>
	 *
	 * <p>
	 * A {@code null} reference passed to this method is a no-op.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.replaceIgnoreCase(null, *, *)        = null
	 * StringUtils.replaceIgnoreCase("", *, *)          = ""
	 * StringUtils.replaceIgnoreCase("any", null, *)    = "any"
	 * StringUtils.replaceIgnoreCase("any", *, null)    = "any"
	 * StringUtils.replaceIgnoreCase("any", "", *)      = "any"
	 * StringUtils.replaceIgnoreCase("aba", "a", null)  = "aba"
	 * StringUtils.replaceIgnoreCase("abA", "A", "")    = "b"
	 * StringUtils.replaceIgnoreCase("aba", "A", "z")   = "zbz"
	 * </pre>
	 *
	 * @see #replaceIgnoreCase(String text, String searchString, String replacement,
	 *      int max)
	 * @param text         text to search and replace in, may be null
	 * @param searchString the String to search for (case insensitive), may be null
	 * @param replacement  the String to replace it with, may be null
	 * @return the text with any replacements processed, {@code null} if null String
	 *         input
	 * @since 3.5
	 */
	public static String replaceIgnoreCase(final String text, final String searchString, final String replacement) {
		return replaceIgnoreCase(text, searchString, replacement, -1);
	}

	/**
	 * <p>
	 * Case insensitively replaces a String with another String inside a larger
	 * String, for the first {@code max} values of the search String.
	 * </p>
	 *
	 * <p>
	 * A {@code null} reference passed to this method is a no-op.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.replaceIgnoreCase(null, *, *, *)         = null
	 * StringUtils.replaceIgnoreCase("", *, *, *)           = ""
	 * StringUtils.replaceIgnoreCase("any", null, *, *)     = "any"
	 * StringUtils.replaceIgnoreCase("any", *, null, *)     = "any"
	 * StringUtils.replaceIgnoreCase("any", "", *, *)       = "any"
	 * StringUtils.replaceIgnoreCase("any", *, *, 0)        = "any"
	 * StringUtils.replaceIgnoreCase("abaa", "a", null, -1) = "abaa"
	 * StringUtils.replaceIgnoreCase("abaa", "a", "", -1)   = "b"
	 * StringUtils.replaceIgnoreCase("abaa", "a", "z", 0)   = "abaa"
	 * StringUtils.replaceIgnoreCase("abaa", "A", "z", 1)   = "zbaa"
	 * StringUtils.replaceIgnoreCase("abAa", "a", "z", 2)   = "zbza"
	 * StringUtils.replaceIgnoreCase("abAa", "a", "z", -1)  = "zbzz"
	 * </pre>
	 *
	 * @param text         text to search and replace in, may be null
	 * @param searchString the String to search for (case insensitive), may be null
	 * @param replacement  the String to replace it with, may be null
	 * @param max          maximum number of values to replace, or {@code -1} if no
	 *                     maximum
	 * @return the text with any replacements processed, {@code null} if null String
	 *         input
	 * @since 3.5
	 */
	public static String replaceIgnoreCase(final String text, final String searchString, final String replacement,
			final int max) {
		return replace(text, searchString, replacement, max, true);
	}

	/**
	 * <p>
	 * Replaces a String with another String inside a larger String, once.
	 * </p>
	 *
	 * <p>
	 * A {@code null} reference passed to this method is a no-op.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.replaceOnce(null, *, *)        = null
	 * StringUtils.replaceOnce("", *, *)          = ""
	 * StringUtils.replaceOnce("any", null, *)    = "any"
	 * StringUtils.replaceOnce("any", *, null)    = "any"
	 * StringUtils.replaceOnce("any", "", *)      = "any"
	 * StringUtils.replaceOnce("aba", "a", null)  = "aba"
	 * StringUtils.replaceOnce("aba", "a", "")    = "ba"
	 * StringUtils.replaceOnce("aba", "a", "z")   = "zba"
	 * </pre>
	 *
	 * @see #replace(String text, String searchString, String replacement, int max)
	 * @param text         text to search and replace in, may be null
	 * @param searchString the String to search for, may be null
	 * @param replacement  the String to replace with, may be null
	 * @return the text with any replacements processed, {@code null} if null String
	 *         input
	 */
	public static String replaceOnce(final String text, final String searchString, final String replacement) {
		return replace(text, searchString, replacement, 1);
	}

	/**
	 * <p>
	 * Case insensitively replaces a String with another String inside a larger
	 * String, once.
	 * </p>
	 *
	 * <p>
	 * A {@code null} reference passed to this method is a no-op.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.replaceOnceIgnoreCase(null, *, *)        = null
	 * StringUtils.replaceOnceIgnoreCase("", *, *)          = ""
	 * StringUtils.replaceOnceIgnoreCase("any", null, *)    = "any"
	 * StringUtils.replaceOnceIgnoreCase("any", *, null)    = "any"
	 * StringUtils.replaceOnceIgnoreCase("any", "", *)      = "any"
	 * StringUtils.replaceOnceIgnoreCase("aba", "a", null)  = "aba"
	 * StringUtils.replaceOnceIgnoreCase("aba", "a", "")    = "ba"
	 * StringUtils.replaceOnceIgnoreCase("aba", "a", "z")   = "zba"
	 * StringUtils.replaceOnceIgnoreCase("FoOFoofoo", "foo", "") = "Foofoo"
	 * </pre>
	 *
	 * @see #replaceIgnoreCase(String text, String searchString, String replacement,
	 *      int max)
	 * @param text         text to search and replace in, may be null
	 * @param searchString the String to search for (case insensitive), may be null
	 * @param replacement  the String to replace with, may be null
	 * @return the text with any replacements processed, {@code null} if null String
	 *         input
	 * @since 3.5
	 */
	public static String replaceOnceIgnoreCase(final String text, final String searchString, final String replacement) {
		return replaceIgnoreCase(text, searchString, replacement, 1);
	}

	/**
	 * <p>
	 * Replaces each substring of the source String that matches the given regular
	 * expression with the given replacement using the {@link Pattern#DOTALL}
	 * option. DOTALL is also known as single-line mode in Perl.
	 * </p>
	 *
	 * This call is a {@code null} safe equivalent to:
	 * <ul>
	 * <li>{@code source.replaceAll(&quot;(?s)&quot; + regex, replacement)}</li>
	 * <li>{@code Pattern.compile(regex, Pattern.DOTALL).matcher(source).replaceAll(replacement)}</li>
	 * </ul>
	 *
	 * <p>
	 * A {@code null} reference passed to this method is a no-op.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.replacePattern(null, *, *)       = null
	 * StringUtils.replacePattern("any", (String) null, *)   = "any"
	 * StringUtils.replacePattern("any", *, null)   = "any"
	 * StringUtils.replacePattern("", "", "zzz")    = "zzz"
	 * StringUtils.replacePattern("", ".*", "zzz")  = "zzz"
	 * StringUtils.replacePattern("", ".+", "zzz")  = ""
	 * StringUtils.replacePattern("&lt;__&gt;\n&lt;__&gt;", "&lt;.*&gt;", "z")       = "z"
	 * StringUtils.replacePattern("ABCabc123", "[a-z]", "_")       = "ABC___123"
	 * StringUtils.replacePattern("ABCabc123", "[^A-Z0-9]+", "_")  = "ABC_123"
	 * StringUtils.replacePattern("ABCabc123", "[^A-Z0-9]+", "")   = "ABC123"
	 * StringUtils.replacePattern("Lorem ipsum  dolor   sit", "( +)([a-z]+)", "_$2")  = "Lorem_ipsum_dolor_sit"
	 * </pre>
	 *
	 * @param source      the source string
	 * @param regex       the regular expression to which this string is to be
	 *                    matched
	 * @param replacement the string to be substituted for each match
	 * @return The resulting {@code String}
	 * @see #replaceAll(String, String, String)
	 * @see String#replaceAll(String, String)
	 * @see Pattern#DOTALL
	 * @since 3.2
	 * @since 3.5 Changed {@code null} reference passed to this method is a no-op.
	 *
	 * @deprecated Moved to RegExUtils.
	 */
	@Deprecated
	public static String replacePattern(final String source, final String regex, final String replacement) {
		return RegExUtils.replacePattern(source, regex, replacement);
	}

	/**
	 * <p>
	 * Reverses a String as per {@link StringBuilder#reverse()}.
	 * </p>
	 *
	 * <p>
	 * A {@code null} String returns {@code null}.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.reverse(null)  = null
	 * StringUtils.reverse("")    = ""
	 * StringUtils.reverse("bat") = "tab"
	 * </pre>
	 *
	 * @param str the String to reverse, may be null
	 * @return the reversed String, {@code null} if null String input
	 */
	public static String reverse(final String str) {
		if (str == null) {
			return null;
		}
		return new StringBuilder(str).reverse().toString();
	}

	/**
	 * <p>
	 * Reverses a String that is delimited by a specific character.
	 * </p>
	 *
	 * <p>
	 * The Strings between the delimiters are not reversed. Thus java.lang.String
	 * becomes String.lang.java (if the delimiter is {@code '.'}).
	 * </p>
	 *
	 * <pre>
	 * StringUtils.reverseDelimited(null, *)      = null
	 * StringUtils.reverseDelimited("", *)        = ""
	 * StringUtils.reverseDelimited("a.b.c", 'x') = "a.b.c"
	 * StringUtils.reverseDelimited("a.b.c", ".") = "c.b.a"
	 * </pre>
	 *
	 * @param str           the String to reverse, may be null
	 * @param separatorChar the separator character to use
	 * @return the reversed String, {@code null} if null String input
	 * @since 2.0
	 */
	public static String reverseDelimited(final String str, final char separatorChar) {
		if (str == null) {
			return null;
		}
		// could implement manually, but simple way is to reuse other,
		// probably slower, methods.
		/*
		 * final String[] strs = split(str, separatorChar); ArrayUtils.reverse(strs);
		 * return join(strs, separatorChar);
		 */
		throw new UnsupportedOperationException("Not supported in TeaVM");
	}

	/**
	 * <p>
	 * Gets the rightmost {@code len} characters of a String.
	 * </p>
	 *
	 * <p>
	 * If {@code len} characters are not available, or the String is {@code null},
	 * the String will be returned without an an exception. An empty String is
	 * returned if len is negative.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.right(null, *)    = null
	 * StringUtils.right(*, -ve)     = ""
	 * StringUtils.right("", *)      = ""
	 * StringUtils.right("abc", 0)   = ""
	 * StringUtils.right("abc", 2)   = "bc"
	 * StringUtils.right("abc", 4)   = "abc"
	 * </pre>
	 *
	 * @param str the String to get the rightmost characters from, may be null
	 * @param len the length of the required String
	 * @return the rightmost characters, {@code null} if null String input
	 */
	public static String right(final String str, final int len) {
		if (str == null) {
			return null;
		}
		if (len < 0) {
			return EMPTY;
		}
		if (str.length() <= len) {
			return str;
		}
		return str.substring(str.length() - len);
	}

	/**
	 * <p>
	 * Right pad a String with spaces (' ').
	 * </p>
	 *
	 * <p>
	 * The String is padded to the size of {@code size}.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.rightPad(null, *)   = null
	 * StringUtils.rightPad("", 3)     = "   "
	 * StringUtils.rightPad("bat", 3)  = "bat"
	 * StringUtils.rightPad("bat", 5)  = "bat  "
	 * StringUtils.rightPad("bat", 1)  = "bat"
	 * StringUtils.rightPad("bat", -1) = "bat"
	 * </pre>
	 *
	 * @param str  the String to pad out, may be null
	 * @param size the size to pad to
	 * @return right padded String or original String if no padding is necessary,
	 *         {@code null} if null String input
	 */
	public static String rightPad(final String str, final int size) {
		return rightPad(str, size, ' ');
	}

	/**
	 * <p>
	 * Right pad a String with a specified character.
	 * </p>
	 *
	 * <p>
	 * The String is padded to the size of {@code size}.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.rightPad(null, *, *)     = null
	 * StringUtils.rightPad("", 3, 'z')     = "zzz"
	 * StringUtils.rightPad("bat", 3, 'z')  = "bat"
	 * StringUtils.rightPad("bat", 5, 'z')  = "batzz"
	 * StringUtils.rightPad("bat", 1, 'z')  = "bat"
	 * StringUtils.rightPad("bat", -1, 'z') = "bat"
	 * </pre>
	 *
	 * @param str     the String to pad out, may be null
	 * @param size    the size to pad to
	 * @param padChar the character to pad with
	 * @return right padded String or original String if no padding is necessary,
	 *         {@code null} if null String input
	 * @since 2.0
	 */
	public static String rightPad(final String str, final int size, final char padChar) {
		if (str == null) {
			return null;
		}
		final int pads = size - str.length();
		if (pads <= 0) {
			return str; // returns original String when possible
		}
		if (pads > PAD_LIMIT) {
			return rightPad(str, size, String.valueOf(padChar));
		}
		return str.concat(repeat(padChar, pads));
	}

	/**
	 * <p>
	 * Right pad a String with a specified String.
	 * </p>
	 *
	 * <p>
	 * The String is padded to the size of {@code size}.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.rightPad(null, *, *)      = null
	 * StringUtils.rightPad("", 3, "z")      = "zzz"
	 * StringUtils.rightPad("bat", 3, "yz")  = "bat"
	 * StringUtils.rightPad("bat", 5, "yz")  = "batyz"
	 * StringUtils.rightPad("bat", 8, "yz")  = "batyzyzy"
	 * StringUtils.rightPad("bat", 1, "yz")  = "bat"
	 * StringUtils.rightPad("bat", -1, "yz") = "bat"
	 * StringUtils.rightPad("bat", 5, null)  = "bat  "
	 * StringUtils.rightPad("bat", 5, "")    = "bat  "
	 * </pre>
	 *
	 * @param str    the String to pad out, may be null
	 * @param size   the size to pad to
	 * @param padStr the String to pad with, null or empty treated as single space
	 * @return right padded String or original String if no padding is necessary,
	 *         {@code null} if null String input
	 */
	public static String rightPad(final String str, final int size, String padStr) {
		if (str == null) {
			return null;
		}
		if (isEmpty(padStr)) {
			padStr = SPACE;
		}
		final int padLen = padStr.length();
		final int strLen = str.length();
		final int pads = size - strLen;
		if (pads <= 0) {
			return str; // returns original String when possible
		}
		if (padLen == 1 && pads <= PAD_LIMIT) {
			return rightPad(str, size, padStr.charAt(0));
		}

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

	/**
	 * <p>
	 * Rotate (circular shift) a String of {@code shift} characters.
	 * </p>
	 * <ul>
	 * <li>If {@code shift > 0}, right circular shift (ex : ABCDEF =&gt;
	 * FABCDE)</li>
	 * <li>If {@code shift < 0}, left circular shift (ex : ABCDEF =&gt; BCDEFA)</li>
	 * </ul>
	 *
	 * <pre>
	 * StringUtils.rotate(null, *)        = null
	 * StringUtils.rotate("", *)          = ""
	 * StringUtils.rotate("abcdefg", 0)   = "abcdefg"
	 * StringUtils.rotate("abcdefg", 2)   = "fgabcde"
	 * StringUtils.rotate("abcdefg", -2)  = "cdefgab"
	 * StringUtils.rotate("abcdefg", 7)   = "abcdefg"
	 * StringUtils.rotate("abcdefg", -7)  = "abcdefg"
	 * StringUtils.rotate("abcdefg", 9)   = "fgabcde"
	 * StringUtils.rotate("abcdefg", -9)  = "cdefgab"
	 * </pre>
	 *
	 * @param str   the String to rotate, may be null
	 * @param shift number of time to shift (positive : right shift, negative : left
	 *              shift)
	 * @return the rotated String, or the original String if {@code shift == 0}, or
	 *         {@code null} if null String input
	 * @since 3.5
	 */
	public static String rotate(final String str, final int shift) {
		if (str == null) {
			return null;
		}

		final int strLen = str.length();
		if (shift == 0 || strLen == 0 || shift % strLen == 0) {
			return str;
		}

		final StringBuilder builder = new StringBuilder(strLen);
		final int offset = -(shift % strLen);
		builder.append(substring(str, offset));
		builder.append(substring(str, 0, offset));
		return builder.toString();
	}

	/**
	 * <p>
	 * Splits the provided text into an array, using whitespace as the separator.
	 * Whitespace is defined by {@link Character#isWhitespace(char)}.
	 * </p>
	 *
	 * <p>
	 * The separator is not included in the returned String array. Adjacent
	 * separators are treated as one separator. For more control over the split use
	 * the StrTokenizer class.
	 * </p>
	 *
	 * <p>
	 * A {@code null} input String returns {@code null}.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.split(null)       = null
	 * StringUtils.split("")         = []
	 * StringUtils.split("abc def")  = ["abc", "def"]
	 * StringUtils.split("abc  def") = ["abc", "def"]
	 * StringUtils.split(" abc ")    = ["abc"]
	 * </pre>
	 *
	 * @param str the String to parse, may be null
	 * @return an array of parsed Strings, {@code null} if null String input
	 */
	public static String[] split(final String str) {
		return split(str, null, -1);
	}

	/**
	 * <p>
	 * Splits the provided text into an array, separator specified. This is an
	 * alternative to using StringTokenizer.
	 * </p>
	 *
	 * <p>
	 * The separator is not included in the returned String array. Adjacent
	 * separators are treated as one separator. For more control over the split use
	 * the StrTokenizer class.
	 * </p>
	 *
	 * <p>
	 * A {@code null} input String returns {@code null}.
	 * </p>
	 *
	 * <pre>
	 * 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 b c", ' ')    = ["a", "b", "c"]
	 * </pre>
	 *
	 * @param str           the String to parse, may be null
	 * @param separatorChar the character used as the delimiter
	 * @return an array of parsed Strings, {@code null} if null String input
	 * @since 2.0
	 */
	public static String[] split(final String str, final char separatorChar) {
		return splitWorker(str, separatorChar, false);
	}

	/**
	 * <p>
	 * Splits the provided text into an array, separators specified. This is an
	 * alternative to using StringTokenizer.
	 * </p>
	 *
	 * <p>
	 * The separator is not included in the returned String array. Adjacent
	 * separators are treated as one separator. For more control over the split use
	 * the StrTokenizer class.
	 * </p>
	 *
	 * <p>
	 * A {@code null} input String returns {@code null}. A {@code null}
	 * separatorChars splits on whitespace.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.split(null, *)         = null
	 * StringUtils.split("", *)           = []
	 * StringUtils.split("abc def", null) = ["abc", "def"]
	 * StringUtils.split("abc def", " ")  = ["abc", "def"]
	 * StringUtils.split("abc  def", " ") = ["abc", "def"]
	 * StringUtils.split("ab:cd:ef", ":") = ["ab", "cd", "ef"]
	 * </pre>
	 *
	 * @param str            the String to parse, may be null
	 * @param separatorChars the characters used as the delimiters, {@code null}
	 *                       splits on whitespace
	 * @return an array of parsed Strings, {@code null} if null String input
	 */
	public static String[] split(final String str, final String separatorChars) {
		return splitWorker(str, separatorChars, -1, false);
	}

	/**
	 * <p>
	 * Splits the provided text into an array with a maximum length, separators
	 * specified.
	 * </p>
	 *
	 * <p>
	 * The separator is not included in the returned String array. Adjacent
	 * separators are treated as one separator.
	 * </p>
	 *
	 * <p>
	 * A {@code null} input String returns {@code null}. A {@code null}
	 * separatorChars splits on whitespace.
	 * </p>
	 *
	 * <p>
	 * If more than {@code max} delimited substrings are found, the last returned
	 * string includes all characters after the first {@code max - 1} returned
	 * strings (including separator characters).
	 * </p>
	 *
	 * <pre>
	 * StringUtils.split(null, *, *)            = null
	 * StringUtils.split("", *, *)              = []
	 * StringUtils.split("ab cd ef", null, 0)   = ["ab", "cd", "ef"]
	 * StringUtils.split("ab   cd ef", null, 0) = ["ab", "cd", "ef"]
	 * StringUtils.split("ab:cd:ef", ":", 0)    = ["ab", "cd", "ef"]
	 * StringUtils.split("ab:cd:ef", ":", 2)    = ["ab", "cd:ef"]
	 * </pre>
	 *
	 * @param str            the String to parse, may be null
	 * @param separatorChars the characters used as the delimiters, {@code null}
	 *                       splits on whitespace
	 * @param max            the maximum number of elements to include in the array.
	 *                       A zero or negative value implies no limit
	 * @return an array of parsed Strings, {@code null} if null String input
	 */
	public static String[] split(final String str, final String separatorChars, final int max) {
		return splitWorker(str, separatorChars, max, false);
	}

	/**
	 * <p>
	 * Splits a String by Character type as returned by
	 * {@code java.lang.Character.getType(char)}. Groups of contiguous characters of
	 * the same type are returned as complete tokens.
	 * 
	 * <pre>
	 * StringUtils.splitByCharacterType(null)         = null
	 * StringUtils.splitByCharacterType("")           = []
	 * StringUtils.splitByCharacterType("ab de fg")   = ["ab", " ", "de", " ", "fg"]
	 * StringUtils.splitByCharacterType("ab   de fg") = ["ab", "   ", "de", " ", "fg"]
	 * StringUtils.splitByCharacterType("ab:cd:ef")   = ["ab", ":", "cd", ":", "ef"]
	 * StringUtils.splitByCharacterType("number5")    = ["number", "5"]
	 * StringUtils.splitByCharacterType("fooBar")     = ["foo", "B", "ar"]
	 * StringUtils.splitByCharacterType("foo200Bar")  = ["foo", "200", "B", "ar"]
	 * StringUtils.splitByCharacterType("ASFRules")   = ["ASFR", "ules"]
	 * </pre>
	 * 
	 * @param str the String to split, may be {@code null}
	 * @return an array of parsed Strings, {@code null} if null String input
	 * @since 2.4
	 */
	public static String[] splitByCharacterType(final String str) {
		return splitByCharacterType(str, false);
	}

	/**
	 * <p>
	 * Splits a String by Character type as returned by
	 * {@code java.lang.Character.getType(char)}. Groups of contiguous characters of
	 * the same type are returned as complete tokens, with the following exception:
	 * if {@code camelCase} is {@code true}, the character of type
	 * {@code Character.UPPERCASE_LETTER}, if any, immediately preceding a token of
	 * type {@code Character.LOWERCASE_LETTER} will belong to the following token
	 * rather than to the preceding, if any, {@code Character.UPPERCASE_LETTER}
	 * token.
	 * 
	 * @param str       the String to split, may be {@code null}
	 * @param camelCase whether to use so-called "camel-case" for letter types
	 * @return an array of parsed Strings, {@code null} if null String input
	 * @since 2.4
	 */
	private static String[] splitByCharacterType(final String str, final boolean camelCase) {
		if (str == null) {
			return null;
		}
		if (str.isEmpty()) {
			return new String[0];
		}
		final char[] c = str.toCharArray();
		final List<String> list = new ArrayList<>();
		int tokenStart = 0;
		int currentType = Character.getType(c[tokenStart]);
		for (int pos = tokenStart + 1; pos < c.length; pos++) {
			final int type = Character.getType(c[pos]);
			if (type == currentType) {
				continue;
			}
			if (camelCase && type == Character.LOWERCASE_LETTER && currentType == Character.UPPERCASE_LETTER) {
				final int newTokenStart = pos - 1;
				if (newTokenStart != tokenStart) {
					list.add(new String(c, tokenStart, newTokenStart - tokenStart));
					tokenStart = newTokenStart;
				}
			} else {
				list.add(new String(c, tokenStart, pos - tokenStart));
				tokenStart = pos;
			}
			currentType = type;
		}
		list.add(new String(c, tokenStart, c.length - tokenStart));
		return list.toArray(new String[0]);
	}

	/**
	 * <p>
	 * Splits a String by Character type as returned by
	 * {@code java.lang.Character.getType(char)}. Groups of contiguous characters of
	 * the same type are returned as complete tokens, with the following exception:
	 * the character of type {@code Character.UPPERCASE_LETTER}, if any, immediately
	 * preceding a token of type {@code Character.LOWERCASE_LETTER} will belong to
	 * the following token rather than to the preceding, if any,
	 * {@code Character.UPPERCASE_LETTER} token.
	 * 
	 * <pre>
	 * StringUtils.splitByCharacterTypeCamelCase(null)         = null
	 * StringUtils.splitByCharacterTypeCamelCase("")           = []
	 * StringUtils.splitByCharacterTypeCamelCase("ab de fg")   = ["ab", " ", "de", " ", "fg"]
	 * StringUtils.splitByCharacterTypeCamelCase("ab   de fg") = ["ab", "   ", "de", " ", "fg"]
	 * StringUtils.splitByCharacterTypeCamelCase("ab:cd:ef")   = ["ab", ":", "cd", ":", "ef"]
	 * StringUtils.splitByCharacterTypeCamelCase("number5")    = ["number", "5"]
	 * StringUtils.splitByCharacterTypeCamelCase("fooBar")     = ["foo", "Bar"]
	 * StringUtils.splitByCharacterTypeCamelCase("foo200Bar")  = ["foo", "200", "Bar"]
	 * StringUtils.splitByCharacterTypeCamelCase("ASFRules")   = ["ASF", "Rules"]
	 * </pre>
	 * 
	 * @param str the String to split, may be {@code null}
	 * @return an array of parsed Strings, {@code null} if null String input
	 * @since 2.4
	 */
	public static String[] splitByCharacterTypeCamelCase(final String str) {
		return splitByCharacterType(str, true);
	}

	/**
	 * <p>
	 * Splits the provided text into an array, separator string specified.
	 * </p>
	 *
	 * <p>
	 * The separator(s) will not be included in the returned String array. Adjacent
	 * separators are treated as one separator.
	 * </p>
	 *
	 * <p>
	 * A {@code null} input String returns {@code null}. A {@code null} separator
	 * splits on whitespace.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.splitByWholeSeparator(null, *)               = null
	 * StringUtils.splitByWholeSeparator("", *)                 = []
	 * StringUtils.splitByWholeSeparator("ab de fg", null)      = ["ab", "de", "fg"]
	 * StringUtils.splitByWholeSeparator("ab   de fg", null)    = ["ab", "de", "fg"]
	 * StringUtils.splitByWholeSeparator("ab:cd:ef", ":")       = ["ab", "cd", "ef"]
	 * StringUtils.splitByWholeSeparator("ab-!-cd-!-ef", "-!-") = ["ab", "cd", "ef"]
	 * </pre>
	 *
	 * @param str       the String to parse, may be null
	 * @param separator String containing the String to be used as a delimiter,
	 *                  {@code null} splits on whitespace
	 * @return an array of parsed Strings, {@code null} if null String was input
	 */
	public static String[] splitByWholeSeparator(final String str, final String separator) {
		return splitByWholeSeparatorWorker(str, separator, -1, false);
	}

	/**
	 * <p>
	 * Splits the provided text into an array, separator string specified. Returns a
	 * maximum of {@code max} substrings.
	 * </p>
	 *
	 * <p>
	 * The separator(s) will not be included in the returned String array. Adjacent
	 * separators are treated as one separator.
	 * </p>
	 *
	 * <p>
	 * A {@code null} input String returns {@code null}. A {@code null} separator
	 * splits on whitespace.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.splitByWholeSeparator(null, *, *)               = null
	 * StringUtils.splitByWholeSeparator("", *, *)                 = []
	 * StringUtils.splitByWholeSeparator("ab de fg", null, 0)      = ["ab", "de", "fg"]
	 * StringUtils.splitByWholeSeparator("ab   de fg", null, 0)    = ["ab", "de", "fg"]
	 * StringUtils.splitByWholeSeparator("ab:cd:ef", ":", 2)       = ["ab", "cd:ef"]
	 * StringUtils.splitByWholeSeparator("ab-!-cd-!-ef", "-!-", 5) = ["ab", "cd", "ef"]
	 * StringUtils.splitByWholeSeparator("ab-!-cd-!-ef", "-!-", 2) = ["ab", "cd-!-ef"]
	 * </pre>
	 *
	 * @param str       the String to parse, may be null
	 * @param separator String containing the String to be used as a delimiter,
	 *                  {@code null} splits on whitespace
	 * @param max       the maximum number of elements to include in the returned
	 *                  array. A zero or negative value implies no limit.
	 * @return an array of parsed Strings, {@code null} if null String was input
	 */
	public static String[] splitByWholeSeparator(final String str, final String separator, final int max) {
		return splitByWholeSeparatorWorker(str, separator, max, false);
	}

	/**
	 * <p>
	 * Splits the provided text into an array, separator string specified.
	 * </p>
	 *
	 * <p>
	 * The separator is not included in the returned String array. Adjacent
	 * separators are treated as separators for empty tokens. For more control over
	 * the split use the StrTokenizer class.
	 * </p>
	 *
	 * <p>
	 * A {@code null} input String returns {@code null}. A {@code null} separator
	 * splits on whitespace.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.splitByWholeSeparatorPreserveAllTokens(null, *)               = null
	 * StringUtils.splitByWholeSeparatorPreserveAllTokens("", *)                 = []
	 * StringUtils.splitByWholeSeparatorPreserveAllTokens("ab de fg", null)      = ["ab", "de", "fg"]
	 * StringUtils.splitByWholeSeparatorPreserveAllTokens("ab   de fg", null)    = ["ab", "", "", "de", "fg"]
	 * StringUtils.splitByWholeSeparatorPreserveAllTokens("ab:cd:ef", ":")       = ["ab", "cd", "ef"]
	 * StringUtils.splitByWholeSeparatorPreserveAllTokens("ab-!-cd-!-ef", "-!-") = ["ab", "cd", "ef"]
	 * </pre>
	 *
	 * @param str       the String to parse, may be null
	 * @param separator String containing the String to be used as a delimiter,
	 *                  {@code null} splits on whitespace
	 * @return an array of parsed Strings, {@code null} if null String was input
	 * @since 2.4
	 */
	public static String[] splitByWholeSeparatorPreserveAllTokens(final String str, final String separator) {
		return splitByWholeSeparatorWorker(str, separator, -1, true);
	}

	/**
	 * <p>
	 * Splits the provided text into an array, separator string specified. Returns a
	 * maximum of {@code max} substrings.
	 * </p>
	 *
	 * <p>
	 * The separator is not included in the returned String array. Adjacent
	 * separators are treated as separators for empty tokens. For more control over
	 * the split use the StrTokenizer class.
	 * </p>
	 *
	 * <p>
	 * A {@code null} input String returns {@code null}. A {@code null} separator
	 * splits on whitespace.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.splitByWholeSeparatorPreserveAllTokens(null, *, *)               = null
	 * StringUtils.splitByWholeSeparatorPreserveAllTokens("", *, *)                 = []
	 * StringUtils.splitByWholeSeparatorPreserveAllTokens("ab de fg", null, 0)      = ["ab", "de", "fg"]
	 * StringUtils.splitByWholeSeparatorPreserveAllTokens("ab   de fg", null, 0)    = ["ab", "", "", "de", "fg"]
	 * StringUtils.splitByWholeSeparatorPreserveAllTokens("ab:cd:ef", ":", 2)       = ["ab", "cd:ef"]
	 * StringUtils.splitByWholeSeparatorPreserveAllTokens("ab-!-cd-!-ef", "-!-", 5) = ["ab", "cd", "ef"]
	 * StringUtils.splitByWholeSeparatorPreserveAllTokens("ab-!-cd-!-ef", "-!-", 2) = ["ab", "cd-!-ef"]
	 * </pre>
	 *
	 * @param str       the String to parse, may be null
	 * @param separator String containing the String to be used as a delimiter,
	 *                  {@code null} splits on whitespace
	 * @param max       the maximum number of elements to include in the returned
	 *                  array. A zero or negative value implies no limit.
	 * @return an array of parsed Strings, {@code null} if null String was input
	 * @since 2.4
	 */
	public static String[] splitByWholeSeparatorPreserveAllTokens(final String str, final String separator,
			final int max) {
		return splitByWholeSeparatorWorker(str, separator, max, true);
	}

	/**
	 * Performs the logic for the {@code splitByWholeSeparatorPreserveAllTokens}
	 * methods.
	 *
	 * @param str               the String to parse, may be {@code null}
	 * @param separator         String containing the String to be used as a
	 *                          delimiter, {@code null} splits on whitespace
	 * @param max               the maximum number of elements to include in the
	 *                          returned array. A zero or negative value implies no
	 *                          limit.
	 * @param preserveAllTokens if {@code true}, adjacent separators are treated as
	 *                          empty token separators; if {@code false}, adjacent
	 *                          separators are treated as one separator.
	 * @return an array of parsed Strings, {@code null} if null String input
	 * @since 2.4
	 */
	private static String[] splitByWholeSeparatorWorker(final String str, final String separator, final int max,
			final boolean preserveAllTokens) {
		if (str == null) {
			return null;
		}

		final int len = str.length();

		if (len == 0) {
			return new String[0];
		}

		if (separator == null || EMPTY.equals(separator)) {
			// Split on whitespace.
			return splitWorker(str, null, max, preserveAllTokens);
		}

		final int separatorLength = separator.length();

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

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

					if (numberOfSubstrings == max) {
						end = len;
						substrings.add(str.substring(beg));
					} else {
						// The following is OK, because String.substring( beg, end ) excludes
						// the character at the position 'end'.
						substrings.add(str.substring(beg, end));

						// Set the starting point for the next search.
						// The following is equivalent to beg = end + (separatorLength - 1) + 1,
						// which is the right calculation:
						beg = end + separatorLength;
					}
				} else {
					// We found a consecutive occurrence of the separator, so skip it.
					if (preserveAllTokens) {
						numberOfSubstrings += 1;
						if (numberOfSubstrings == max) {
							end = len;
							substrings.add(str.substring(beg));
						} else {
							substrings.add(EMPTY);
						}
					}
					beg = end + separatorLength;
				}
			} else {
				// String.substring( beg ) goes from 'beg' to the end of the String.
				substrings.add(str.substring(beg));
				end = len;
			}
		}

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

	/**
	 * <p>
	 * Splits the provided text into an array, using whitespace as the separator,
	 * preserving all tokens, including empty tokens created by adjacent separators.
	 * This is an alternative to using StringTokenizer. Whitespace is defined by
	 * {@link Character#isWhitespace(char)}.
	 * </p>
	 *
	 * <p>
	 * The separator is not included in the returned String array. Adjacent
	 * separators are treated as separators for empty tokens. For more control over
	 * the split use the StrTokenizer class.
	 * </p>
	 *
	 * <p>
	 * A {@code null} input String returns {@code null}.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.splitPreserveAllTokens(null)       = null
	 * StringUtils.splitPreserveAllTokens("")         = []
	 * StringUtils.splitPreserveAllTokens("abc def")  = ["abc", "def"]
	 * StringUtils.splitPreserveAllTokens("abc  def") = ["abc", "", "def"]
	 * StringUtils.splitPreserveAllTokens(" abc ")    = ["", "abc", ""]
	 * </pre>
	 *
	 * @param str the String to parse, may be {@code null}
	 * @return an array of parsed Strings, {@code null} if null String input
	 * @since 2.1
	 */
	public static String[] splitPreserveAllTokens(final String str) {
		return splitWorker(str, null, -1, true);
	}

	/**
	 * <p>
	 * Splits the provided text into an array, separator specified, preserving all
	 * tokens, including empty tokens created by adjacent separators. This is an
	 * alternative to using StringTokenizer.
	 * </p>
	 *
	 * <p>
	 * The separator is not included in the returned String array. Adjacent
	 * separators are treated as separators for empty tokens. For more control over
	 * the split use the StrTokenizer class.
	 * </p>
	 *
	 * <p>
	 * A {@code null} input String returns {@code null}.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.splitPreserveAllTokens(null, *)         = null
	 * StringUtils.splitPreserveAllTokens("", *)           = []
	 * StringUtils.splitPreserveAllTokens("a.b.c", '.')    = ["a", "b", "c"]
	 * StringUtils.splitPreserveAllTokens("a..b.c", '.')   = ["a", "", "b", "c"]
	 * StringUtils.splitPreserveAllTokens("a:b:c", '.')    = ["a:b:c"]
	 * StringUtils.splitPreserveAllTokens("a\tb\nc", null) = ["a", "b", "c"]
	 * StringUtils.splitPreserveAllTokens("a b c", ' ')    = ["a", "b", "c"]
	 * StringUtils.splitPreserveAllTokens("a b c ", ' ')   = ["a", "b", "c", ""]
	 * StringUtils.splitPreserveAllTokens("a b c  ", ' ')   = ["a", "b", "c", "", ""]
	 * StringUtils.splitPreserveAllTokens(" a b c", ' ')   = ["", a", "b", "c"]
	 * StringUtils.splitPreserveAllTokens("  a b c", ' ')  = ["", "", a", "b", "c"]
	 * StringUtils.splitPreserveAllTokens(" a b c ", ' ')  = ["", a", "b", "c", ""]
	 * </pre>
	 *
	 * @param str           the String to parse, may be {@code null}
	 * @param separatorChar the character used as the delimiter, {@code null} splits
	 *                      on whitespace
	 * @return an array of parsed Strings, {@code null} if null String input
	 * @since 2.1
	 */
	public static String[] splitPreserveAllTokens(final String str, final char separatorChar) {
		return splitWorker(str, separatorChar, true);
	}

	/**
	 * <p>
	 * Splits the provided text into an array, separators specified, preserving all
	 * tokens, including empty tokens created by adjacent separators. This is an
	 * alternative to using StringTokenizer.
	 * </p>
	 *
	 * <p>
	 * The separator is not included in the returned String array. Adjacent
	 * separators are treated as separators for empty tokens. For more control over
	 * the split use the StrTokenizer class.
	 * </p>
	 *
	 * <p>
	 * A {@code null} input String returns {@code null}. A {@code null}
	 * separatorChars splits on whitespace.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.splitPreserveAllTokens(null, *)           = null
	 * StringUtils.splitPreserveAllTokens("", *)             = []
	 * StringUtils.splitPreserveAllTokens("abc def", null)   = ["abc", "def"]
	 * StringUtils.splitPreserveAllTokens("abc def", " ")    = ["abc", "def"]
	 * StringUtils.splitPreserveAllTokens("abc  def", " ")   = ["abc", "", def"]
	 * StringUtils.splitPreserveAllTokens("ab:cd:ef", ":")   = ["ab", "cd", "ef"]
	 * StringUtils.splitPreserveAllTokens("ab:cd:ef:", ":")  = ["ab", "cd", "ef", ""]
	 * StringUtils.splitPreserveAllTokens("ab:cd:ef::", ":") = ["ab", "cd", "ef", "", ""]
	 * StringUtils.splitPreserveAllTokens("ab::cd:ef", ":")  = ["ab", "", cd", "ef"]
	 * StringUtils.splitPreserveAllTokens(":cd:ef", ":")     = ["", cd", "ef"]
	 * StringUtils.splitPreserveAllTokens("::cd:ef", ":")    = ["", "", cd", "ef"]
	 * StringUtils.splitPreserveAllTokens(":cd:ef:", ":")    = ["", cd", "ef", ""]
	 * </pre>
	 *
	 * @param str            the String to parse, may be {@code null}
	 * @param separatorChars the characters used as the delimiters, {@code null}
	 *                       splits on whitespace
	 * @return an array of parsed Strings, {@code null} if null String input
	 * @since 2.1
	 */
	public static String[] splitPreserveAllTokens(final String str, final String separatorChars) {
		return splitWorker(str, separatorChars, -1, true);
	}

	/**
	 * <p>
	 * Splits the provided text into an array with a maximum length, separators
	 * specified, preserving all tokens, including empty tokens created by adjacent
	 * separators.
	 * </p>
	 *
	 * <p>
	 * The separator is not included in the returned String array. Adjacent
	 * separators are treated as separators for empty tokens. Adjacent separators
	 * are treated as one separator.
	 * </p>
	 *
	 * <p>
	 * A {@code null} input String returns {@code null}. A {@code null}
	 * separatorChars splits on whitespace.
	 * </p>
	 *
	 * <p>
	 * If more than {@code max} delimited substrings are found, the last returned
	 * string includes all characters after the first {@code max - 1} returned
	 * strings (including separator characters).
	 * </p>
	 *
	 * <pre>
	 * StringUtils.splitPreserveAllTokens(null, *, *)            = null
	 * StringUtils.splitPreserveAllTokens("", *, *)              = []
	 * StringUtils.splitPreserveAllTokens("ab de fg", null, 0)   = ["ab", "de", "fg"]
	 * StringUtils.splitPreserveAllTokens("ab   de fg", null, 0) = ["ab", "", "", "de", "fg"]
	 * StringUtils.splitPreserveAllTokens("ab:cd:ef", ":", 0)    = ["ab", "cd", "ef"]
	 * StringUtils.splitPreserveAllTokens("ab:cd:ef", ":", 2)    = ["ab", "cd:ef"]
	 * StringUtils.splitPreserveAllTokens("ab   de fg", null, 2) = ["ab", "  de fg"]
	 * StringUtils.splitPreserveAllTokens("ab   de fg", null, 3) = ["ab", "", " de fg"]
	 * StringUtils.splitPreserveAllTokens("ab   de fg", null, 4) = ["ab", "", "", "de fg"]
	 * </pre>
	 *
	 * @param str            the String to parse, may be {@code null}
	 * @param separatorChars the characters used as the delimiters, {@code null}
	 *                       splits on whitespace
	 * @param max            the maximum number of elements to include in the array.
	 *                       A zero or negative value implies no limit
	 * @return an array of parsed Strings, {@code null} if null String input
	 * @since 2.1
	 */
	public static String[] splitPreserveAllTokens(final String str, final String separatorChars, final int max) {
		return splitWorker(str, separatorChars, max, true);
	}

	/**
	 * Performs the logic for the {@code split} and {@code splitPreserveAllTokens}
	 * methods that do not return a maximum array length.
	 *
	 * @param str               the String to parse, may be {@code null}
	 * @param separatorChar     the separate character
	 * @param preserveAllTokens if {@code true}, adjacent separators are treated as
	 *                          empty token separators; if {@code false}, adjacent
	 *                          separators are treated as one separator.
	 * @return an array of parsed Strings, {@code null} if null String input
	 */
	private static String[] splitWorker(final String str, final char separatorChar, final boolean preserveAllTokens) {
		// Performance tuned for 2.0 (JDK1.4)

		if (str == null) {
			return null;
		}
		final int len = str.length();
		if (len == 0) {
			return new String[0];
		}
		final List<String> list = new ArrayList<>();
		int i = 0;
		int start = 0;
		boolean match = false;
		boolean lastMatch = false;
		while (i < len) {
			if (str.charAt(i) == separatorChar) {
				if (match || preserveAllTokens) {
					list.add(str.substring(start, i));
					match = false;
					lastMatch = true;
				}
				start = ++i;
				continue;
			}
			lastMatch = false;
			match = true;
			i++;
		}
		if (match || preserveAllTokens && lastMatch) {
			list.add(str.substring(start, i));
		}
		return list.toArray(new String[0]);
	}

	/**
	 * Performs the logic for the {@code split} and {@code splitPreserveAllTokens}
	 * methods that return a maximum array length.
	 *
	 * @param str               the String to parse, may be {@code null}
	 * @param separatorChars    the separate character
	 * @param max               the maximum number of elements to include in the
	 *                          array. A zero or negative value implies no limit.
	 * @param preserveAllTokens if {@code true}, adjacent separators are treated as
	 *                          empty token separators; if {@code false}, adjacent
	 *                          separators are treated as one separator.
	 * @return an array of parsed Strings, {@code null} if null String input
	 */
	private static String[] splitWorker(final String str, final String separatorChars, final int max,
			final boolean preserveAllTokens) {
		// Performance tuned for 2.0 (JDK1.4)
		// Direct code is quicker than StringTokenizer.
		// Also, StringTokenizer uses isSpace() not isWhitespace()

		if (str == null) {
			return null;
		}
		final int len = str.length();
		if (len == 0) {
			return new String[0];
		}
		final List<String> list = new ArrayList<>();
		int sizePlus1 = 1;
		int i = 0;
		int start = 0;
		boolean match = false;
		boolean lastMatch = false;
		if (separatorChars == null) {
			// Null separator means use whitespace
			while (i < len) {
				if (Character.isWhitespace(str.charAt(i))) {
					if (match || preserveAllTokens) {
						lastMatch = true;
						if (sizePlus1++ == max) {
							i = len;
							lastMatch = false;
						}
						list.add(str.substring(start, i));
						match = false;
					}
					start = ++i;
					continue;
				}
				lastMatch = false;
				match = true;
				i++;
			}
		} else if (separatorChars.length() == 1) {
			// Optimise 1 character case
			final char sep = separatorChars.charAt(0);
			while (i < len) {
				if (str.charAt(i) == sep) {
					if (match || preserveAllTokens) {
						lastMatch = true;
						if (sizePlus1++ == max) {
							i = len;
							lastMatch = false;
						}
						list.add(str.substring(start, i));
						match = false;
					}
					start = ++i;
					continue;
				}
				lastMatch = false;
				match = true;
				i++;
			}
		} else {
			// standard case
			while (i < len) {
				if (separatorChars.indexOf(str.charAt(i)) >= 0) {
					if (match || preserveAllTokens) {
						lastMatch = true;
						if (sizePlus1++ == max) {
							i = len;
							lastMatch = false;
						}
						list.add(str.substring(start, i));
						match = false;
					}
					start = ++i;
					continue;
				}
				lastMatch = false;
				match = true;
				i++;
			}
		}
		if (match || preserveAllTokens && lastMatch) {
			list.add(str.substring(start, i));
		}
		return list.toArray(new String[0]);
	}

	/**
	 * <p>
	 * Check if a CharSequence starts with a specified prefix.
	 * </p>
	 *
	 * <p>
	 * {@code null}s are handled without exceptions. Two {@code null} references are
	 * considered to be equal. The comparison is case sensitive.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.startsWith(null, null)      = true
	 * StringUtils.startsWith(null, "abc")     = false
	 * StringUtils.startsWith("abcdef", null)  = false
	 * StringUtils.startsWith("abcdef", "abc") = true
	 * StringUtils.startsWith("ABCDEF", "abc") = false
	 * </pre>
	 *
	 * @see java.lang.String#startsWith(String)
	 * @param str    the CharSequence to check, may be null
	 * @param prefix the prefix to find, may be null
	 * @return {@code true} if the CharSequence starts with the prefix, case
	 *         sensitive, or both {@code null}
	 * @since 2.4
	 * @since 3.0 Changed signature from startsWith(String, String) to
	 *        startsWith(CharSequence, CharSequence)
	 */
	public static boolean startsWith(final CharSequence str, final CharSequence prefix) {
		return startsWith(str, prefix, false);
	}

	/**
	 * <p>
	 * Check if a CharSequence starts with a specified prefix (optionally case
	 * insensitive).
	 * </p>
	 *
	 * @see java.lang.String#startsWith(String)
	 * @param str        the CharSequence to check, may be null
	 * @param prefix     the prefix to find, may be null
	 * @param ignoreCase indicates whether the compare should ignore case (case
	 *                   insensitive) or not.
	 * @return {@code true} if the CharSequence starts with the prefix or both
	 *         {@code null}
	 */
	private static boolean startsWith(final CharSequence str, final CharSequence prefix, final boolean ignoreCase) {
		if (str == null || prefix == null) {
			return str == prefix;
		}
		// Get length once instead of twice in the unlikely case that it changes.
		final int preLen = prefix.length();
		if (preLen > str.length()) {
			return false;
		}
		return CharSequenceUtils.regionMatches(str, ignoreCase, 0, prefix, 0, preLen);
	}

	/**
	 * <p>
	 * Check if a CharSequence starts with any of the provided case-sensitive
	 * prefixes.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.startsWithAny(null, null)      = false
	 * StringUtils.startsWithAny(null, new String[] {"abc"})  = false
	 * StringUtils.startsWithAny("abcxyz", null)     = false
	 * StringUtils.startsWithAny("abcxyz", new String[] {""}) = true
	 * StringUtils.startsWithAny("abcxyz", new String[] {"abc"}) = true
	 * StringUtils.startsWithAny("abcxyz", new String[] {null, "xyz", "abc"}) = true
	 * StringUtils.startsWithAny("abcxyz", null, "xyz", "ABCX") = false
	 * StringUtils.startsWithAny("ABCXYZ", null, "xyz", "abc") = false
	 * </pre>
	 *
	 * @param sequence      the CharSequence to check, may be null
	 * @param searchStrings the case-sensitive CharSequence prefixes, may be empty
	 *                      or contain {@code null}
	 * @see StringUtils#startsWith(CharSequence, CharSequence)
	 * @return {@code true} if the input {@code sequence} is {@code null} AND no
	 *         {@code searchStrings} are provided, or the input {@code sequence}
	 *         begins with any of the provided case-sensitive {@code searchStrings}.
	 * @since 2.5
	 * @since 3.0 Changed signature from startsWithAny(String, String[]) to
	 *        startsWithAny(CharSequence, CharSequence...)
	 */
	public static boolean startsWithAny(final CharSequence sequence, final CharSequence... searchStrings) {
		if (isEmpty(sequence) || searchStrings.length == 0) {
			return false;
		}
		for (final CharSequence searchString : searchStrings) {
			if (startsWith(sequence, searchString)) {
				return true;
			}
		}
		return false;
	}

	/**
	 * <p>
	 * Case insensitive check if a CharSequence starts with a specified prefix.
	 * </p>
	 *
	 * <p>
	 * {@code null}s are handled without exceptions. Two {@code null} references are
	 * considered to be equal. The comparison is case insensitive.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.startsWithIgnoreCase(null, null)      = true
	 * StringUtils.startsWithIgnoreCase(null, "abc")     = false
	 * StringUtils.startsWithIgnoreCase("abcdef", null)  = false
	 * StringUtils.startsWithIgnoreCase("abcdef", "abc") = true
	 * StringUtils.startsWithIgnoreCase("ABCDEF", "abc") = true
	 * </pre>
	 *
	 * @see java.lang.String#startsWith(String)
	 * @param str    the CharSequence to check, may be null
	 * @param prefix the prefix to find, may be null
	 * @return {@code true} if the CharSequence starts with the prefix, case
	 *         insensitive, or both {@code null}
	 * @since 2.4
	 * @since 3.0 Changed signature from startsWithIgnoreCase(String, String) to
	 *        startsWithIgnoreCase(CharSequence, CharSequence)
	 */
	public static boolean startsWithIgnoreCase(final CharSequence str, final CharSequence prefix) {
		return startsWith(str, prefix, true);
	}

	/**
	 * <p>
	 * Strips whitespace from the start and end of a String.
	 * </p>
	 *
	 * <p>
	 * This is similar to {@link #trim(String)} but removes whitespace. Whitespace
	 * is defined by {@link Character#isWhitespace(char)}.
	 * </p>
	 *
	 * <p>
	 * A {@code null} input String returns {@code null}.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.strip(null)     = null
	 * StringUtils.strip("")       = ""
	 * StringUtils.strip("   ")    = ""
	 * StringUtils.strip("abc")    = "abc"
	 * StringUtils.strip("  abc")  = "abc"
	 * StringUtils.strip("abc  ")  = "abc"
	 * StringUtils.strip(" abc ")  = "abc"
	 * StringUtils.strip(" ab c ") = "ab c"
	 * </pre>
	 *
	 * @param str the String to remove whitespace from, may be null
	 * @return the stripped String, {@code null} if null String input
	 */
	public static String strip(final String str) {
		return strip(str, null);
	}

	/**
	 * <p>
	 * Strips any of a set of characters from the start and end of a String. This is
	 * similar to {@link String#trim()} but allows the characters to be stripped to
	 * be controlled.
	 * </p>
	 *
	 * <p>
	 * A {@code null} input String returns {@code null}. An empty string ("") input
	 * returns the empty string.
	 * </p>
	 *
	 * <p>
	 * If the stripChars String is {@code null}, whitespace is stripped as defined
	 * by {@link Character#isWhitespace(char)}. Alternatively use
	 * {@link #strip(String)}.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.strip(null, *)          = null
	 * StringUtils.strip("", *)            = ""
	 * StringUtils.strip("abc", null)      = "abc"
	 * StringUtils.strip("  abc", null)    = "abc"
	 * StringUtils.strip("abc  ", null)    = "abc"
	 * StringUtils.strip(" abc ", null)    = "abc"
	 * StringUtils.strip("  abcyx", "xyz") = "  abc"
	 * </pre>
	 *
	 * @param str        the String to remove characters from, may be null
	 * @param stripChars the characters to remove, null treated as whitespace
	 * @return the stripped String, {@code null} if null String input
	 */
	public static String strip(String str, final String stripChars) {
		str = stripStart(str, stripChars);
		return stripEnd(str, stripChars);
	}

	/**
	 * <p>
	 * Removes diacritics (~= accents) from a string. The case will not be altered.
	 * </p>
	 * <p>
	 * For instance, '&agrave;' will be replaced by 'a'.
	 * </p>
	 * <p>
	 * Note that ligatures will be left as is.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.stripAccents(null)                = null
	 * StringUtils.stripAccents("")                  = ""
	 * StringUtils.stripAccents("control")           = "control"
	 * StringUtils.stripAccents("&eacute;clair")     = "eclair"
	 * </pre>
	 *
	 * @param input String to be stripped
	 * @return input text with diacritics removed
	 *
	 * @since 3.0
	 */
	// See also Lucene's ASCIIFoldingFilter (Lucene 2.9) that replaces accented
	// characters by their unaccented equivalent (and uncommitted bug fix:
	// https://issues.apache.org/jira/browse/LUCENE-1343?focusedCommentId=12858907&page=com.atlassian.jira.plugin.system.issuetabpanels%3Acomment-tabpanel#action_12858907).
	public static String stripAccents(final String input) {
		if (input == null) {
			return null;
		}
		final StringBuilder decomposed = new StringBuilder(Normalizer.normalize(input, Normalizer.Form.NFD));
		convertRemainingAccentCharacters(decomposed);
		// Note that this doesn't correctly remove ligatures...
		return STRIP_ACCENTS_PATTERN.matcher(decomposed).replaceAll(EMPTY);
	}

	/**
	 * <p>
	 * Strips whitespace from the start and end of every String in an array.
	 * Whitespace is defined by {@link Character#isWhitespace(char)}.
	 * </p>
	 *
	 * <p>
	 * A new array is returned each time, except for length zero. A {@code null}
	 * array will return {@code null}. An empty array will return itself. A
	 * {@code null} array entry will be ignored.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.stripAll(null)             = null
	 * StringUtils.stripAll([])               = []
	 * StringUtils.stripAll(["abc", "  abc"]) = ["abc", "abc"]
	 * StringUtils.stripAll(["abc  ", null])  = ["abc", null]
	 * </pre>
	 *
	 * @param strs the array to remove whitespace from, may be null
	 * @return the stripped Strings, {@code null} if null array input
	 */
	public static String[] stripAll(final String... strs) {
		return stripAll(strs, null);
	}

	/**
	 * <p>
	 * Strips any of a set of characters from the start and end of every String in
	 * an array.
	 * </p>
	 * <p>
	 * Whitespace is defined by {@link Character#isWhitespace(char)}.
	 * </p>
	 *
	 * <p>
	 * A new array is returned each time, except for length zero. A {@code null}
	 * array will return {@code null}. An empty array will return itself. A
	 * {@code null} array entry will be ignored. A {@code null} stripChars will
	 * strip whitespace as defined by {@link Character#isWhitespace(char)}.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.stripAll(null, *)                = null
	 * StringUtils.stripAll([], *)                  = []
	 * StringUtils.stripAll(["abc", "  abc"], null) = ["abc", "abc"]
	 * StringUtils.stripAll(["abc  ", null], null)  = ["abc", null]
	 * StringUtils.stripAll(["abc  ", null], "yz")  = ["abc  ", null]
	 * StringUtils.stripAll(["yabcz", null], "yz")  = ["abc", null]
	 * </pre>
	 *
	 * @param strs       the array to remove characters from, may be null
	 * @param stripChars the characters to remove, null treated as whitespace
	 * @return the stripped Strings, {@code null} if null array input
	 */
	public static String[] stripAll(final String[] strs, final String stripChars) {
		final int strsLen = strs.length;
		if (strsLen == 0) {
			return strs;
		}
		final String[] newArr = new String[strsLen];
		for (int i = 0; i < strsLen; i++) {
			newArr[i] = strip(strs[i], stripChars);
		}
		return newArr;
	}

	/**
	 * <p>
	 * Strips any of a set of characters from the end of a String.
	 * </p>
	 *
	 * <p>
	 * A {@code null} input String returns {@code null}. An empty string ("") input
	 * returns the empty string.
	 * </p>
	 *
	 * <p>
	 * If the stripChars String is {@code null}, whitespace is stripped as defined
	 * by {@link Character#isWhitespace(char)}.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.stripEnd(null, *)          = null
	 * StringUtils.stripEnd("", *)            = ""
	 * StringUtils.stripEnd("abc", "")        = "abc"
	 * StringUtils.stripEnd("abc", null)      = "abc"
	 * StringUtils.stripEnd("  abc", null)    = "  abc"
	 * StringUtils.stripEnd("abc  ", null)    = "abc"
	 * StringUtils.stripEnd(" abc ", null)    = " abc"
	 * StringUtils.stripEnd("  abcyx", "xyz") = "  abc"
	 * StringUtils.stripEnd("120.00", ".0")   = "12"
	 * </pre>
	 *
	 * @param str        the String to remove characters from, may be null
	 * @param stripChars the set of characters to remove, null treated as whitespace
	 * @return the stripped String, {@code null} if null String input
	 */
	public static String stripEnd(final String str, final String stripChars) {
		int end = length(str);
		if (end == 0) {
			return str;
		}

		if (stripChars == null) {
			while (end != 0 && Character.isWhitespace(str.charAt(end - 1))) {
				end--;
			}
		} else if (stripChars.isEmpty()) {
			return str;
		} else {
			while (end != 0 && stripChars.indexOf(str.charAt(end - 1)) != INDEX_NOT_FOUND) {
				end--;
			}
		}
		return str.substring(0, end);
	}

	/**
	 * <p>
	 * Strips any of a set of characters from the start of a String.
	 * </p>
	 *
	 * <p>
	 * A {@code null} input String returns {@code null}. An empty string ("") input
	 * returns the empty string.
	 * </p>
	 *
	 * <p>
	 * If the stripChars String is {@code null}, whitespace is stripped as defined
	 * by {@link Character#isWhitespace(char)}.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.stripStart(null, *)          = null
	 * StringUtils.stripStart("", *)            = ""
	 * StringUtils.stripStart("abc", "")        = "abc"
	 * StringUtils.stripStart("abc", null)      = "abc"
	 * StringUtils.stripStart("  abc", null)    = "abc"
	 * StringUtils.stripStart("abc  ", null)    = "abc  "
	 * StringUtils.stripStart(" abc ", null)    = "abc "
	 * StringUtils.stripStart("yxabc  ", "xyz") = "abc  "
	 * </pre>
	 *
	 * @param str        the String to remove characters from, may be null
	 * @param stripChars the characters to remove, null treated as whitespace
	 * @return the stripped String, {@code null} if null String input
	 */
	public static String stripStart(final String str, final String stripChars) {
		final int strLen = length(str);
		if (strLen == 0) {
			return str;
		}
		int start = 0;
		if (stripChars == null) {
			while (start != strLen && Character.isWhitespace(str.charAt(start))) {
				start++;
			}
		} else if (stripChars.isEmpty()) {
			return str;
		} else {
			while (start != strLen && stripChars.indexOf(str.charAt(start)) != INDEX_NOT_FOUND) {
				start++;
			}
		}
		return str.substring(start);
	}

	/**
	 * <p>
	 * Strips whitespace from the start and end of a String returning an empty
	 * String if {@code null} input.
	 * </p>
	 *
	 * <p>
	 * This is similar to {@link #trimToEmpty(String)} but removes whitespace.
	 * Whitespace is defined by {@link Character#isWhitespace(char)}.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.stripToEmpty(null)     = ""
	 * StringUtils.stripToEmpty("")       = ""
	 * StringUtils.stripToEmpty("   ")    = ""
	 * StringUtils.stripToEmpty("abc")    = "abc"
	 * StringUtils.stripToEmpty("  abc")  = "abc"
	 * StringUtils.stripToEmpty("abc  ")  = "abc"
	 * StringUtils.stripToEmpty(" abc ")  = "abc"
	 * StringUtils.stripToEmpty(" ab c ") = "ab c"
	 * </pre>
	 *
	 * @param str the String to be stripped, may be null
	 * @return the trimmed String, or an empty String if {@code null} input
	 * @since 2.0
	 */
	public static String stripToEmpty(final String str) {
		return str == null ? EMPTY : strip(str, null);
	}

	/**
	 * <p>
	 * Strips whitespace from the start and end of a String returning {@code null}
	 * if the String is empty ("") after the strip.
	 * </p>
	 *
	 * <p>
	 * This is similar to {@link #trimToNull(String)} but removes whitespace.
	 * Whitespace is defined by {@link Character#isWhitespace(char)}.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.stripToNull(null)     = null
	 * StringUtils.stripToNull("")       = null
	 * StringUtils.stripToNull("   ")    = null
	 * StringUtils.stripToNull("abc")    = "abc"
	 * StringUtils.stripToNull("  abc")  = "abc"
	 * StringUtils.stripToNull("abc  ")  = "abc"
	 * StringUtils.stripToNull(" abc ")  = "abc"
	 * StringUtils.stripToNull(" ab c ") = "ab c"
	 * </pre>
	 *
	 * @param str the String to be stripped, may be null
	 * @return the stripped String, {@code null} if whitespace, empty or null String
	 *         input
	 * @since 2.0
	 */
	public static String stripToNull(String str) {
		if (str == null) {
			return null;
		}
		str = strip(str, null);
		return str.isEmpty() ? null : str; // NOSONARLINT str cannot be null here
	}

	/**
	 * <p>
	 * Gets a substring from the specified String avoiding exceptions.
	 * </p>
	 *
	 * <p>
	 * A negative start position can be used to start {@code n} characters from the
	 * end of the String.
	 * </p>
	 *
	 * <p>
	 * A {@code null} String will return {@code null}. An empty ("") String will
	 * return "".
	 * </p>
	 *
	 * <pre>
	 * StringUtils.substring(null, *)   = null
	 * StringUtils.substring("", *)     = ""
	 * StringUtils.substring("abc", 0)  = "abc"
	 * StringUtils.substring("abc", 2)  = "c"
	 * StringUtils.substring("abc", 4)  = ""
	 * StringUtils.substring("abc", -2) = "bc"
	 * StringUtils.substring("abc", -4) = "abc"
	 * </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
	 * @return substring from start position, {@code null} if null String input
	 */
	public static String substring(final String str, int start) {
		if (str == null) {
			return null;
		}

		// handle negatives, which means last n characters
		if (start < 0) {
			start = str.length() + start; // remember start is negative
		}

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

		return str.substring(start);
	}

	/**
	 * <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>
	 *
	 * <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 EMPTY;
		}

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

		return str.substring(start, end);
	}

	/**
	 * <p>
	 * Gets the substring after the first occurrence of a separator. The separator
	 * is not returned.
	 * </p>
	 *
	 * <p>
	 * A {@code null} string input will return {@code null}. An empty ("") string
	 * input will return the empty string.
	 *
	 * <p>
	 * If nothing is found, the empty string is returned.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.substringAfter(null, *)      = null
	 * StringUtils.substringAfter("", *)        = ""
	 * StringUtils.substringAfter("abc", 'a')   = "bc"
	 * StringUtils.substringAfter("abcba", 'b') = "cba"
	 * StringUtils.substringAfter("abc", 'c')   = ""
	 * StringUtils.substringAfter("abc", 'd')   = ""
	 * StringUtils.substringAfter(" abc", 32)   = "abc"
	 * </pre>
	 *
	 * @param str       the String to get a substring from, may be null
	 * @param separator the character to search.
	 * @return the substring after the first occurrence of the separator,
	 *         {@code null} if null String input
	 * @since 3.11
	 */
	public static String substringAfter(final String str, final int separator) {
		if (isEmpty(str)) {
			return str;
		}
		final int pos = str.indexOf(separator);
		if (pos == INDEX_NOT_FOUND) {
			return EMPTY;
		}
		return str.substring(pos + 1);
	}

	/**
	 * <p>
	 * Gets the substring after the first occurrence of a separator. The separator
	 * is not returned.
	 * </p>
	 *
	 * <p>
	 * A {@code null} string input will return {@code null}. An empty ("") string
	 * input will return the empty string. A {@code null} separator will return the
	 * empty string if the input string is not {@code null}.
	 * </p>
	 *
	 * <p>
	 * If nothing is found, the empty string is returned.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.substringAfter(null, *)      = null
	 * StringUtils.substringAfter("", *)        = ""
	 * StringUtils.substringAfter(*, null)      = ""
	 * StringUtils.substringAfter("abc", "a")   = "bc"
	 * StringUtils.substringAfter("abcba", "b") = "cba"
	 * StringUtils.substringAfter("abc", "c")   = ""
	 * StringUtils.substringAfter("abc", "d")   = ""
	 * StringUtils.substringAfter("abc", "")    = "abc"
	 * </pre>
	 *
	 * @param str       the String to get a substring from, may be null
	 * @param separator the String to search for, may be null
	 * @return the substring after the first occurrence of the separator,
	 *         {@code null} if null String input
	 * @since 2.0
	 */
	public static String substringAfter(final String str, final String separator) {
		if (isEmpty(str)) {
			return str;
		}
		if (separator == null) {
			return EMPTY;
		}
		final int pos = str.indexOf(separator);
		if (pos == INDEX_NOT_FOUND) {
			return EMPTY;
		}
		return str.substring(pos + separator.length());
	}

	/**
	 * <p>
	 * Gets the substring after the last occurrence of a separator. The separator is
	 * not returned.
	 * </p>
	 *
	 * <p>
	 * A {@code null} string input will return {@code null}. An empty ("") string
	 * input will return the empty string.
	 *
	 * <p>
	 * If nothing is found, the empty string is returned.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.substringAfterLast(null, *)      = null
	 * StringUtils.substringAfterLast("", *)        = ""
	 * StringUtils.substringAfterLast("abc", 'a')   = "bc"
	 * StringUtils.substringAfterLast(" bc", 32)    = "bc"
	 * StringUtils.substringAfterLast("abcba", 'b') = "a"
	 * StringUtils.substringAfterLast("abc", 'c')   = ""
	 * StringUtils.substringAfterLast("a", 'a')     = ""
	 * StringUtils.substringAfterLast("a", 'z')     = ""
	 * </pre>
	 *
	 * @param str       the String to get a substring from, may be null
	 * @param separator the String to search for, may be null
	 * @return the substring after the last occurrence of the separator,
	 *         {@code null} if null String input
	 * @since 3.11
	 */
	public static String substringAfterLast(final String str, final int separator) {
		if (isEmpty(str)) {
			return str;
		}
		final int pos = str.lastIndexOf(separator);
		if (pos == INDEX_NOT_FOUND || pos == str.length() - 1) {
			return EMPTY;
		}
		return str.substring(pos + 1);
	}

	/**
	 * <p>
	 * Gets the substring after the last occurrence of a separator. The separator is
	 * not returned.
	 * </p>
	 *
	 * <p>
	 * A {@code null} string input will return {@code null}. An empty ("") string
	 * input will return the empty string. An empty or {@code null} separator will
	 * return the empty string if the input string is not {@code null}.
	 * </p>
	 *
	 * <p>
	 * If nothing is found, the empty string is returned.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.substringAfterLast(null, *)      = null
	 * StringUtils.substringAfterLast("", *)        = ""
	 * StringUtils.substringAfterLast(*, "")        = ""
	 * StringUtils.substringAfterLast(*, null)      = ""
	 * StringUtils.substringAfterLast("abc", "a")   = "bc"
	 * StringUtils.substringAfterLast("abcba", "b") = "a"
	 * StringUtils.substringAfterLast("abc", "c")   = ""
	 * StringUtils.substringAfterLast("a", "a")     = ""
	 * StringUtils.substringAfterLast("a", "z")     = ""
	 * </pre>
	 *
	 * @param str       the String to get a substring from, may be null
	 * @param separator the String to search for, may be null
	 * @return the substring after the last occurrence of the separator,
	 *         {@code null} if null String input
	 * @since 2.0
	 */
	public static String substringAfterLast(final String str, final String separator) {
		if (isEmpty(str)) {
			return str;
		}
		if (isEmpty(separator)) {
			return EMPTY;
		}
		final int pos = str.lastIndexOf(separator);
		if (pos == INDEX_NOT_FOUND || pos == str.length() - separator.length()) {
			return EMPTY;
		}
		return str.substring(pos + separator.length());
	}

	/**
	 * <p>
	 * Gets the substring before the first occurrence of a separator. The separator
	 * is not returned.
	 * </p>
	 *
	 * <p>
	 * A {@code null} string input will return {@code null}. An empty ("") string
	 * input will return the empty string.
	 * </p>
	 *
	 * <p>
	 * If nothing is found, the string input is returned.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.substringBefore(null, *)      = null
	 * StringUtils.substringBefore("", *)        = ""
	 * StringUtils.substringBefore("abc", 'a')   = ""
	 * StringUtils.substringBefore("abcba", 'b') = "a"
	 * StringUtils.substringBefore("abc", 'c')   = "ab"
	 * StringUtils.substringBefore("abc", 'd')   = "abc"
	 * </pre>
	 *
	 * @param str       the String to get a substring from, may be null
	 * @param separator the String to search for, may be null
	 * @return the substring before the first occurrence of the separator,
	 *         {@code null} if null String input
	 * @since 3.12.0
	 */
	public static String substringBefore(final String str, final int separator) {
		if (isEmpty(str)) {
			return str;
		}
		final int pos = str.indexOf(separator);
		if (pos == INDEX_NOT_FOUND) {
			return str;
		}
		return str.substring(0, pos);
	}

	/**
	 * <p>
	 * Gets the substring before the first occurrence of a separator. The separator
	 * is not returned.
	 * </p>
	 *
	 * <p>
	 * A {@code null} string input will return {@code null}. An empty ("") string
	 * input will return the empty string. A {@code null} separator will return the
	 * input string.
	 * </p>
	 *
	 * <p>
	 * If nothing is found, the string input is returned.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.substringBefore(null, *)      = null
	 * StringUtils.substringBefore("", *)        = ""
	 * StringUtils.substringBefore("abc", "a")   = ""
	 * StringUtils.substringBefore("abcba", "b") = "a"
	 * StringUtils.substringBefore("abc", "c")   = "ab"
	 * StringUtils.substringBefore("abc", "d")   = "abc"
	 * StringUtils.substringBefore("abc", "")    = ""
	 * StringUtils.substringBefore("abc", null)  = "abc"
	 * </pre>
	 *
	 * @param str       the String to get a substring from, may be null
	 * @param separator the String to search for, may be null
	 * @return the substring before the first occurrence of the separator,
	 *         {@code null} if null String input
	 * @since 2.0
	 */
	public static String substringBefore(final String str, final String separator) {
		if (isEmpty(str) || separator == null) {
			return str;
		}
		if (separator.isEmpty()) {
			return EMPTY;
		}
		final int pos = str.indexOf(separator);
		if (pos == INDEX_NOT_FOUND) {
			return str;
		}
		return str.substring(0, pos);
	}

	/**
	 * <p>
	 * Gets the substring before the last occurrence of a separator. The separator
	 * is not returned.
	 * </p>
	 *
	 * <p>
	 * A {@code null} string input will return {@code null}. An empty ("") string
	 * input will return the empty string. An empty or {@code null} separator will
	 * return the input string.
	 * </p>
	 *
	 * <p>
	 * If nothing is found, the string input is returned.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.substringBeforeLast(null, *)      = null
	 * StringUtils.substringBeforeLast("", *)        = ""
	 * StringUtils.substringBeforeLast("abcba", "b") = "abc"
	 * StringUtils.substringBeforeLast("abc", "c")   = "ab"
	 * StringUtils.substringBeforeLast("a", "a")     = ""
	 * StringUtils.substringBeforeLast("a", "z")     = "a"
	 * StringUtils.substringBeforeLast("a", null)    = "a"
	 * StringUtils.substringBeforeLast("a", "")      = "a"
	 * </pre>
	 *
	 * @param str       the String to get a substring from, may be null
	 * @param separator the String to search for, may be null
	 * @return the substring before the last occurrence of the separator,
	 *         {@code null} if null String input
	 * @since 2.0
	 */
	public static String substringBeforeLast(final String str, final String separator) {
		if (isEmpty(str) || isEmpty(separator)) {
			return str;
		}
		final int pos = str.lastIndexOf(separator);
		if (pos == INDEX_NOT_FOUND) {
			return str;
		}
		return str.substring(0, pos);
	}

	/**
	 * <p>
	 * Gets the String that is nested in between two instances of the same String.
	 * </p>
	 *
	 * <p>
	 * A {@code null} input String returns {@code null}. A {@code null} tag returns
	 * {@code null}.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.substringBetween(null, *)            = null
	 * StringUtils.substringBetween("", "")             = ""
	 * StringUtils.substringBetween("", "tag")          = null
	 * StringUtils.substringBetween("tagabctag", null)  = null
	 * StringUtils.substringBetween("tagabctag", "")    = ""
	 * StringUtils.substringBetween("tagabctag", "tag") = "abc"
	 * </pre>
	 *
	 * @param str the String containing the substring, may be null
	 * @param tag the String before and after the substring, may be null
	 * @return the substring, {@code null} if no match
	 * @since 2.0
	 */
	public static String substringBetween(final String str, final String tag) {
		return substringBetween(str, tag, tag);
	}

	/**
	 * <p>
	 * Gets the String that is nested in between two Strings. Only the first match
	 * is returned.
	 * </p>
	 *
	 * <p>
	 * A {@code null} input String returns {@code null}. A {@code null} open/close
	 * returns {@code null} (no match). An empty ("") open and close returns an
	 * empty string.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.substringBetween("wx[b]yz", "[", "]") = "b"
	 * StringUtils.substringBetween(null, *, *)          = null
	 * StringUtils.substringBetween(*, null, *)          = null
	 * StringUtils.substringBetween(*, *, null)          = null
	 * StringUtils.substringBetween("", "", "")          = ""
	 * StringUtils.substringBetween("", "", "]")         = null
	 * StringUtils.substringBetween("", "[", "]")        = null
	 * StringUtils.substringBetween("yabcz", "", "")     = ""
	 * StringUtils.substringBetween("yabcz", "y", "z")   = "abc"
	 * StringUtils.substringBetween("yabczyabcz", "y", "z")   = "abc"
	 * </pre>
	 *
	 * @param str   the String containing the substring, may be null
	 * @param open  the String before the substring, may be null
	 * @param close the String after the substring, may be null
	 * @return the substring, {@code null} if no match
	 * @since 2.0
	 */
	public static String substringBetween(final String str, final String open, final String close) {
		if (!ObjectUtils.allNotNull(str, open, close)) {
			return null;
		}
		final int start = str.indexOf(open);
		if (start != INDEX_NOT_FOUND) {
			final int end = str.indexOf(close, start + open.length());
			if (end != INDEX_NOT_FOUND) {
				return str.substring(start + open.length(), end);
			}
		}
		return null;
	}

	/**
	 * <p>
	 * Searches a String for substrings delimited by a start and end tag, returning
	 * all matching substrings in an array.
	 * </p>
	 *
	 * <p>
	 * A {@code null} input String returns {@code null}. A {@code null} open/close
	 * returns {@code null} (no match). An empty ("") open/close returns
	 * {@code null} (no match).
	 * </p>
	 *
	 * <pre>
	 * StringUtils.substringsBetween("[a][b][c]", "[", "]") = ["a","b","c"]
	 * StringUtils.substringsBetween(null, *, *)            = null
	 * StringUtils.substringsBetween(*, null, *)            = null
	 * StringUtils.substringsBetween(*, *, null)            = null
	 * StringUtils.substringsBetween("", "[", "]")          = []
	 * </pre>
	 *
	 * @param str   the String containing the substrings, null returns null, empty
	 *              returns empty
	 * @param open  the String identifying the start of the substring, empty returns
	 *              null
	 * @param close the String identifying the end of the substring, empty returns
	 *              null
	 * @return a String Array of substrings, or {@code null} if no match
	 * @since 2.3
	 */
	public static String[] substringsBetween(final String str, final String open, final String close) {
		if (str == null || isEmpty(open) || isEmpty(close)) {
			return null;
		}
		final int strLen = str.length();
		if (strLen == 0) {
			return new String[0];
		}
		final int closeLen = close.length();
		final int openLen = open.length();
		final List<String> list = new ArrayList<>();
		int pos = 0;
		while (pos < strLen - closeLen) {
			int start = str.indexOf(open, pos);
			if (start < 0) {
				break;
			}
			start += openLen;
			final int end = str.indexOf(close, start);
			if (end < 0) {
				break;
			}
			list.add(str.substring(start, end));
			pos = end + closeLen;
		}
		if (list.isEmpty()) {
			return null;
		}
		return list.toArray(new String[0]);
	}

	/**
	 * <p>
	 * Swaps the case of a String changing upper and title case to lower case, and
	 * lower case to upper case.
	 * </p>
	 *
	 * <ul>
	 * <li>Upper case character converts to Lower case</li>
	 * <li>Title case character converts to Lower case</li>
	 * <li>Lower case character converts to Upper case</li>
	 * </ul>
	 *
	 * <p>
	 * For a word based algorithm, see
	 * {@link org.apache.commons.lang3.text.WordUtils#swapCase(String)}. A
	 * {@code null} input String returns {@code null}.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.swapCase(null)                 = null
	 * StringUtils.swapCase("")                   = ""
	 * StringUtils.swapCase("The dog has a BONE") = "tHE DOG HAS A bone"
	 * </pre>
	 *
	 * <p>
	 * NOTE: This method changed in Lang version 2.0. It no longer performs a word
	 * based algorithm. If you only use ASCII, you will notice no change. That
	 * functionality is available in org.apache.commons.lang3.text.WordUtils.
	 * </p>
	 *
	 * @param str the String to swap case, may be null
	 * @return the changed String, {@code null} if null String input
	 */
	public static String swapCase(final String str) {
		if (isEmpty(str)) {
			return str;
		}

		final int strLen = str.length();
		final int[] newCodePoints = new int[strLen]; // cannot be longer than the char array
		int outOffset = 0;
		for (int i = 0; i < strLen;) {
			final int oldCodepoint = str.codePointAt(i);
			final int newCodePoint;
			if (Character.isUpperCase(oldCodepoint) || Character.isTitleCase(oldCodepoint)) {
				newCodePoint = Character.toLowerCase(oldCodepoint);
			} else if (Character.isLowerCase(oldCodepoint)) {
				newCodePoint = Character.toUpperCase(oldCodepoint);
			} else {
				newCodePoint = oldCodepoint;
			}
			newCodePoints[outOffset++] = newCodePoint;
			i += Character.charCount(newCodePoint);
		}
		return new String(newCodePoints, 0, outOffset);
	}

	/**
	 * <p>
	 * Converts a {@code CharSequence} into an array of code points.
	 * </p>
	 *
	 * <p>
	 * Valid pairs of surrogate code units will be converted into a single
	 * supplementary code point. Isolated surrogate code units (i.e. a high
	 * surrogate not followed by a low surrogate or a low surrogate not preceded by
	 * a high surrogate) will be returned as-is.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.toCodePoints(null)   =  null
	 * StringUtils.toCodePoints("")     =  []  // empty array
	 * </pre>
	 *
	 * @param cs the character sequence to convert
	 * @return an array of code points
	 * @since 3.6
	 */
	public static int[] toCodePoints(final CharSequence cs) {
		if (cs == null) {
			return null;
		}
		if (cs.length() == 0) {
			return new int[0];
		}

		final String s = cs.toString();
		final int[] result = new int[s.codePointCount(0, s.length())];
		int index = 0;
		for (int i = 0; i < result.length; i++) {
			result[i] = s.codePointAt(index);
			index += Character.charCount(result[i]);
		}
		return result;
	}

	/**
	 * Converts a {@code byte[]} to a String using the specified character encoding.
	 *
	 * @param bytes   the byte array to read from
	 * @param charset the encoding to use, if null then use the platform default
	 * @return a new String
	 * @throws NullPointerException if {@code bytes} is null
	 * @since 3.2
	 * @since 3.3 No longer throws {@link UnsupportedEncodingException}.
	 */
	public static String toEncodedString(final byte[] bytes, final Charset charset) {
		return new String(bytes, Charsets.toCharset(charset));
	}

	/**
	 * Converts the given source String as a lower-case using the
	 * {@link Locale#ROOT} locale in a null-safe manner.
	 *
	 * @param source A source String or null.
	 * @return the given source String as a lower-case using the {@link Locale#ROOT}
	 *         locale or null.
	 * @since 3.10
	 */
	public static String toRootLowerCase(final String source) {
		return source == null ? null : source.toLowerCase(Locale.ROOT);
	}

	/**
	 * Converts the given source String as a upper-case using the
	 * {@link Locale#ROOT} locale in a null-safe manner.
	 *
	 * @param source A source String or null.
	 * @return the given source String as a upper-case using the {@link Locale#ROOT}
	 *         locale or null.
	 * @since 3.10
	 */
	public static String toRootUpperCase(final String source) {
		return source == null ? null : source.toUpperCase(Locale.ROOT);
	}

	/**
	 * Converts a {@code byte[]} to a String using the specified character encoding.
	 *
	 * @param bytes       the byte array to read from
	 * @param charsetName the encoding to use, if null then use the platform default
	 * @return a new String
	 * @throws UnsupportedEncodingException If the named charset is not supported
	 * @throws NullPointerException         if the input is null
	 * @deprecated use {@link StringUtils#toEncodedString(byte[], Charset)} instead
	 *             of String constants in your code
	 * @since 3.1
	 */
	@Deprecated
	public static String toString(final byte[] bytes, final String charsetName) throws UnsupportedEncodingException {
		return new String(bytes, Charsets.toCharset(charsetName));
	}

	private static String toStringOrEmpty(final Object obj) {
		return Objects.toString(obj, EMPTY);
	}

	/**
	 * <p>
	 * Removes control characters (char &lt;= 32) from both ends of this String,
	 * handling {@code null} by returning {@code null}.
	 * </p>
	 *
	 * <p>
	 * The String is trimmed using {@link String#trim()}. Trim removes start and end
	 * characters &lt;= 32. To strip whitespace use {@link #strip(String)}.
	 * </p>
	 *
	 * <p>
	 * To trim your choice of characters, use the {@link #strip(String, String)}
	 * methods.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.trim(null)          = null
	 * StringUtils.trim("")            = ""
	 * StringUtils.trim("     ")       = ""
	 * StringUtils.trim("abc")         = "abc"
	 * StringUtils.trim("    abc    ") = "abc"
	 * </pre>
	 *
	 * @param str the String to be trimmed, may be null
	 * @return the trimmed string, {@code null} if null String input
	 */
	public static String trim(final String str) {
		return str == null ? null : str.trim();
	}

	/**
	 * <p>
	 * Removes control characters (char &lt;= 32) from both ends of this String
	 * returning an empty String ("") if the String is empty ("") after the trim or
	 * if it is {@code null}.
	 *
	 * <p>
	 * The String is trimmed using {@link String#trim()}. Trim removes start and end
	 * characters &lt;= 32. To strip whitespace use {@link #stripToEmpty(String)}.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.trimToEmpty(null)          = ""
	 * StringUtils.trimToEmpty("")            = ""
	 * StringUtils.trimToEmpty("     ")       = ""
	 * StringUtils.trimToEmpty("abc")         = "abc"
	 * StringUtils.trimToEmpty("    abc    ") = "abc"
	 * </pre>
	 *
	 * @param str the String to be trimmed, may be null
	 * @return the trimmed String, or an empty String if {@code null} input
	 * @since 2.0
	 */
	public static String trimToEmpty(final String str) {
		return str == null ? EMPTY : str.trim();
	}

	/**
	 * <p>
	 * Removes control characters (char &lt;= 32) from both ends of this String
	 * returning {@code null} if the String is empty ("") after the trim or if it is
	 * {@code null}.
	 *
	 * <p>
	 * The String is trimmed using {@link String#trim()}. Trim removes start and end
	 * characters &lt;= 32. To strip whitespace use {@link #stripToNull(String)}.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.trimToNull(null)          = null
	 * StringUtils.trimToNull("")            = null
	 * StringUtils.trimToNull("     ")       = null
	 * StringUtils.trimToNull("abc")         = "abc"
	 * StringUtils.trimToNull("    abc    ") = "abc"
	 * </pre>
	 *
	 * @param str the String to be trimmed, may be null
	 * @return the trimmed String, {@code null} if only chars &lt;= 32, empty or
	 *         null String input
	 * @since 2.0
	 */
	public static String trimToNull(final String str) {
		final String ts = trim(str);
		return isEmpty(ts) ? null : ts;
	}

	/**
	 * <p>
	 * Truncates a String. This will turn "Now is the time for all good men" into
	 * "Now is the time for".
	 * </p>
	 *
	 * <p>
	 * Specifically:
	 * </p>
	 * <ul>
	 * <li>If {@code str} is less than {@code maxWidth} characters long, return
	 * it.</li>
	 * <li>Else truncate it to {@code substring(str, 0, maxWidth)}.</li>
	 * <li>If {@code maxWidth} is less than {@code 0}, throw an
	 * {@code IllegalArgumentException}.</li>
	 * <li>In no case will it return a String of length greater than
	 * {@code maxWidth}.</li>
	 * </ul>
	 *
	 * <pre>
	 * StringUtils.truncate(null, 0)       = null
	 * StringUtils.truncate(null, 2)       = null
	 * StringUtils.truncate("", 4)         = ""
	 * StringUtils.truncate("abcdefg", 4)  = "abcd"
	 * StringUtils.truncate("abcdefg", 6)  = "abcdef"
	 * StringUtils.truncate("abcdefg", 7)  = "abcdefg"
	 * StringUtils.truncate("abcdefg", 8)  = "abcdefg"
	 * StringUtils.truncate("abcdefg", -1) = throws an IllegalArgumentException
	 * </pre>
	 *
	 * @param str      the String to truncate, may be null
	 * @param maxWidth maximum length of result String, must be positive
	 * @return truncated String, {@code null} if null String input
	 * @throws IllegalArgumentException If {@code maxWidth} is less than {@code 0}
	 * @since 3.5
	 */
	public static String truncate(final String str, final int maxWidth) {
		return truncate(str, 0, maxWidth);
	}

	/**
	 * <p>
	 * Truncates a String. This will turn "Now is the time for all good men" into
	 * "is the time for all".
	 * </p>
	 *
	 * <p>
	 * Works like {@code truncate(String, int)}, but allows you to specify a "left
	 * edge" offset.
	 *
	 * <p>
	 * Specifically:
	 * </p>
	 * <ul>
	 * <li>If {@code str} is less than {@code maxWidth} characters long, return
	 * it.</li>
	 * <li>Else truncate it to {@code substring(str, offset, maxWidth)}.</li>
	 * <li>If {@code maxWidth} is less than {@code 0}, throw an
	 * {@code IllegalArgumentException}.</li>
	 * <li>If {@code offset} is less than {@code 0}, throw an
	 * {@code IllegalArgumentException}.</li>
	 * <li>In no case will it return a String of length greater than
	 * {@code maxWidth}.</li>
	 * </ul>
	 *
	 * <pre>
	 * StringUtils.truncate(null, 0, 0) = null
	 * StringUtils.truncate(null, 2, 4) = null
	 * StringUtils.truncate("", 0, 10) = ""
	 * StringUtils.truncate("", 2, 10) = ""
	 * StringUtils.truncate("abcdefghij", 0, 3) = "abc"
	 * StringUtils.truncate("abcdefghij", 5, 6) = "fghij"
	 * StringUtils.truncate("raspberry peach", 10, 15) = "peach"
	 * StringUtils.truncate("abcdefghijklmno", 0, 10) = "abcdefghij"
	 * StringUtils.truncate("abcdefghijklmno", -1, 10) = throws an IllegalArgumentException
	 * StringUtils.truncate("abcdefghijklmno", Integer.MIN_VALUE, 10) = throws an IllegalArgumentException
	 * StringUtils.truncate("abcdefghijklmno", Integer.MIN_VALUE, Integer.MAX_VALUE) = throws an IllegalArgumentException
	 * StringUtils.truncate("abcdefghijklmno", 0, Integer.MAX_VALUE) = "abcdefghijklmno"
	 * StringUtils.truncate("abcdefghijklmno", 1, 10) = "bcdefghijk"
	 * StringUtils.truncate("abcdefghijklmno", 2, 10) = "cdefghijkl"
	 * StringUtils.truncate("abcdefghijklmno", 3, 10) = "defghijklm"
	 * StringUtils.truncate("abcdefghijklmno", 4, 10) = "efghijklmn"
	 * StringUtils.truncate("abcdefghijklmno", 5, 10) = "fghijklmno"
	 * StringUtils.truncate("abcdefghijklmno", 5, 5) = "fghij"
	 * StringUtils.truncate("abcdefghijklmno", 5, 3) = "fgh"
	 * StringUtils.truncate("abcdefghijklmno", 10, 3) = "klm"
	 * StringUtils.truncate("abcdefghijklmno", 10, Integer.MAX_VALUE) = "klmno"
	 * StringUtils.truncate("abcdefghijklmno", 13, 1) = "n"
	 * StringUtils.truncate("abcdefghijklmno", 13, Integer.MAX_VALUE) = "no"
	 * StringUtils.truncate("abcdefghijklmno", 14, 1) = "o"
	 * StringUtils.truncate("abcdefghijklmno", 14, Integer.MAX_VALUE) = "o"
	 * StringUtils.truncate("abcdefghijklmno", 15, 1) = ""
	 * StringUtils.truncate("abcdefghijklmno", 15, Integer.MAX_VALUE) = ""
	 * StringUtils.truncate("abcdefghijklmno", Integer.MAX_VALUE, Integer.MAX_VALUE) = ""
	 * StringUtils.truncate("abcdefghij", 3, -1) = throws an IllegalArgumentException
	 * StringUtils.truncate("abcdefghij", -2, 4) = throws an IllegalArgumentException
	 * </pre>
	 *
	 * @param str      the String to truncate, may be null
	 * @param offset   left edge of source String
	 * @param maxWidth maximum length of result String, must be positive
	 * @return truncated String, {@code null} if null String input
	 * @throws IllegalArgumentException If {@code offset} or {@code maxWidth} is
	 *                                  less than {@code 0}
	 * @since 3.5
	 */
	public static String truncate(final String str, final int offset, final int maxWidth) {
		if (offset < 0) {
			throw new IllegalArgumentException("offset cannot be negative");
		}
		if (maxWidth < 0) {
			throw new IllegalArgumentException("maxWith cannot be negative");
		}
		if (str == null) {
			return null;
		}
		if (offset > str.length()) {
			return EMPTY;
		}
		if (str.length() > maxWidth) {
			final int ix = Math.min(offset + maxWidth, str.length());
			return str.substring(offset, ix);
		}
		return str.substring(offset);
	}

	/**
	 * <p>
	 * Uncapitalizes a String, changing the first character to lower case as per
	 * {@link Character#toLowerCase(int)}. No other characters are changed.
	 * </p>
	 *
	 * <p>
	 * For a word based algorithm, see
	 * {@link org.apache.commons.lang3.text.WordUtils#uncapitalize(String)}. A
	 * {@code null} input String returns {@code null}.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.uncapitalize(null)  = null
	 * StringUtils.uncapitalize("")    = ""
	 * StringUtils.uncapitalize("cat") = "cat"
	 * 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 org.apache.commons.lang3.text.WordUtils#uncapitalize(String)
	 * @see #capitalize(String)
	 * @since 2.0
	 */
	public static String uncapitalize(final String str) {
		final int strLen = length(str);
		if (strLen == 0) {
			return str;
		}

		final int firstCodepoint = str.codePointAt(0);
		final int newCodePoint = Character.toLowerCase(firstCodepoint);
		if (firstCodepoint == newCodePoint) {
			// already capitalized
			return str;
		}

		final int[] newCodePoints = new int[strLen]; // cannot be longer than the char array
		int outOffset = 0;
		newCodePoints[outOffset++] = newCodePoint; // copy the first codepoint
		for (int inOffset = Character.charCount(firstCodepoint); inOffset < strLen;) {
			final int codepoint = str.codePointAt(inOffset);
			newCodePoints[outOffset++] = codepoint; // copy the remaining ones
			inOffset += Character.charCount(codepoint);
		}
		return new String(newCodePoints, 0, outOffset);
	}

	/**
	 * <p>
	 * Unwraps a given string from a character.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.unwrap(null, null)         = null
	 * StringUtils.unwrap(null, '\0')         = null
	 * StringUtils.unwrap(null, '1')          = null
	 * StringUtils.unwrap("a", 'a')           = "a"
	 * StringUtils.unwrap("aa", 'a')           = ""
	 * StringUtils.unwrap("\'abc\'", '\'')    = "abc"
	 * StringUtils.unwrap("AABabcBAA", 'A')   = "ABabcBA"
	 * StringUtils.unwrap("A", '#')           = "A"
	 * StringUtils.unwrap("#A", '#')          = "#A"
	 * StringUtils.unwrap("A#", '#')          = "A#"
	 * </pre>
	 *
	 * @param str      the String to be unwrapped, can be null
	 * @param wrapChar the character used to unwrap
	 * @return unwrapped String or the original string if it is not quoted properly
	 *         with the wrapChar
	 * @since 3.6
	 */
	public static String unwrap(final String str, final char wrapChar) {
		if (isEmpty(str) || wrapChar == CharUtils.NUL || str.length() == 1) {
			return str;
		}

		if (str.charAt(0) == wrapChar && str.charAt(str.length() - 1) == wrapChar) {
			final int startIndex = 0;
			final int endIndex = str.length() - 1;

			return str.substring(startIndex + 1, endIndex);
		}

		return str;
	}

	/**
	 * <p>
	 * Unwraps a given string from anther string.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.unwrap(null, null)         = null
	 * StringUtils.unwrap(null, "")           = null
	 * StringUtils.unwrap(null, "1")          = null
	 * StringUtils.unwrap("a", "a")           = "a"
	 * StringUtils.unwrap("aa", "a")          = ""
	 * StringUtils.unwrap("\'abc\'", "\'")    = "abc"
	 * StringUtils.unwrap("\"abc\"", "\"")    = "abc"
	 * StringUtils.unwrap("AABabcBAA", "AA")  = "BabcB"
	 * StringUtils.unwrap("A", "#")           = "A"
	 * StringUtils.unwrap("#A", "#")          = "#A"
	 * StringUtils.unwrap("A#", "#")          = "A#"
	 * </pre>
	 *
	 * @param str       the String to be unwrapped, can be null
	 * @param wrapToken the String used to unwrap
	 * @return unwrapped String or the original string if it is not quoted properly
	 *         with the wrapToken
	 * @since 3.6
	 */
	public static String unwrap(final String str, final String wrapToken) {
		if (isEmpty(str) || isEmpty(wrapToken) || str.length() < 2 * wrapToken.length()) {
			return str;
		}

		if (startsWith(str, wrapToken) && endsWith(str, wrapToken)) {
			final int startIndex = str.indexOf(wrapToken);
			final int endIndex = str.lastIndexOf(wrapToken);
			final int wrapLength = wrapToken.length();

			if (startIndex != -1 && endIndex != -1) {
				return str.substring(startIndex + wrapLength, endIndex);
			}
		}

		return str;
	}

	/**
	 * <p>
	 * Converts a String to upper case as per {@link String#toUpperCase()}.
	 * </p>
	 *
	 * <p>
	 * A {@code null} input String returns {@code null}.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.upperCase(null)  = null
	 * StringUtils.upperCase("")    = ""
	 * StringUtils.upperCase("aBc") = "ABC"
	 * </pre>
	 *
	 * <p>
	 * <strong>Note:</strong> As described in the documentation for
	 * {@link String#toUpperCase()}, the result of this method is affected by the
	 * current locale. For platform-independent case transformations, the method
	 * {@link #lowerCase(String, Locale)} should be used with a specific locale
	 * (e.g. {@link Locale#ENGLISH}).
	 * </p>
	 *
	 * @param str the String to upper case, may be null
	 * @return the upper cased String, {@code null} if null String input
	 */
	public static String upperCase(final String str) {
		if (str == null) {
			return null;
		}
		return str.toUpperCase();
	}

	/**
	 * <p>
	 * Converts a String to upper case as per {@link String#toUpperCase(Locale)}.
	 * </p>
	 *
	 * <p>
	 * A {@code null} input String returns {@code null}.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.upperCase(null, Locale.ENGLISH)  = null
	 * StringUtils.upperCase("", Locale.ENGLISH)    = ""
	 * StringUtils.upperCase("aBc", Locale.ENGLISH) = "ABC"
	 * </pre>
	 *
	 * @param str    the String to upper case, may be null
	 * @param locale the locale that defines the case transformation rules, must not
	 *               be null
	 * @return the upper cased String, {@code null} if null String input
	 * @since 2.5
	 */
	public static String upperCase(final String str, final Locale locale) {
		if (str == null) {
			return null;
		}
		return str.toUpperCase(LocaleUtils.toLocale(locale));
	}

	/**
	 * Returns the string representation of the {@code char} array or null.
	 *
	 * @param value the character array.
	 * @return a String or null
	 * @see String#valueOf(char[])
	 * @since 3.9
	 */
	public static String valueOf(final char[] value) {
		return value == null ? null : String.valueOf(value);
	}

	/**
	 * <p>
	 * Wraps a string with a char.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.wrap(null, *)        = null
	 * StringUtils.wrap("", *)          = ""
	 * StringUtils.wrap("ab", '\0')     = "ab"
	 * StringUtils.wrap("ab", 'x')      = "xabx"
	 * StringUtils.wrap("ab", '\'')     = "'ab'"
	 * StringUtils.wrap("\"ab\"", '\"') = "\"\"ab\"\""
	 * </pre>
	 *
	 * @param str      the string to be wrapped, may be {@code null}
	 * @param wrapWith the char that will wrap {@code str}
	 * @return the wrapped string, or {@code null} if {@code str==null}
	 * @since 3.4
	 */
	public static String wrap(final String str, final char wrapWith) {

		if (isEmpty(str) || wrapWith == CharUtils.NUL) {
			return str;
		}

		return wrapWith + str + wrapWith;
	}

	/**
	 * <p>
	 * Wraps a String with another String.
	 * </p>
	 *
	 * <p>
	 * A {@code null} input String returns {@code null}.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.wrap(null, *)         = null
	 * StringUtils.wrap("", *)           = ""
	 * StringUtils.wrap("ab", null)      = "ab"
	 * StringUtils.wrap("ab", "x")       = "xabx"
	 * StringUtils.wrap("ab", "\"")      = "\"ab\""
	 * StringUtils.wrap("\"ab\"", "\"")  = "\"\"ab\"\""
	 * StringUtils.wrap("ab", "'")       = "'ab'"
	 * StringUtils.wrap("'abcd'", "'")   = "''abcd''"
	 * StringUtils.wrap("\"abcd\"", "'") = "'\"abcd\"'"
	 * StringUtils.wrap("'abcd'", "\"")  = "\"'abcd'\""
	 * </pre>
	 *
	 * @param str      the String to be wrapper, may be null
	 * @param wrapWith the String that will wrap str
	 * @return wrapped String, {@code null} if null String input
	 * @since 3.4
	 */
	public static String wrap(final String str, final String wrapWith) {

		if (isEmpty(str) || isEmpty(wrapWith)) {
			return str;
		}

		return wrapWith.concat(str).concat(wrapWith);
	}

	/**
	 * <p>
	 * Wraps a string with a char if that char is missing from the start or end of
	 * the given string.
	 * </p>
	 *
	 * <p>
	 * A new {@code String} will not be created if {@code str} is already wrapped.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.wrapIfMissing(null, *)        = null
	 * StringUtils.wrapIfMissing("", *)          = ""
	 * StringUtils.wrapIfMissing("ab", '\0')     = "ab"
	 * StringUtils.wrapIfMissing("ab", 'x')      = "xabx"
	 * StringUtils.wrapIfMissing("ab", '\'')     = "'ab'"
	 * StringUtils.wrapIfMissing("\"ab\"", '\"') = "\"ab\""
	 * StringUtils.wrapIfMissing("/", '/')  = "/"
	 * StringUtils.wrapIfMissing("a/b/c", '/')  = "/a/b/c/"
	 * StringUtils.wrapIfMissing("/a/b/c", '/')  = "/a/b/c/"
	 * StringUtils.wrapIfMissing("a/b/c/", '/')  = "/a/b/c/"
	 * </pre>
	 *
	 * @param str      the string to be wrapped, may be {@code null}
	 * @param wrapWith the char that will wrap {@code str}
	 * @return the wrapped string, or {@code null} if {@code str==null}
	 * @since 3.5
	 */
	public static String wrapIfMissing(final String str, final char wrapWith) {
		if (isEmpty(str) || wrapWith == CharUtils.NUL) {
			return str;
		}
		final boolean wrapStart = str.charAt(0) != wrapWith;
		final boolean wrapEnd = str.charAt(str.length() - 1) != wrapWith;
		if (!wrapStart && !wrapEnd) {
			return str;
		}

		final StringBuilder builder = new StringBuilder(str.length() + 2);
		if (wrapStart) {
			builder.append(wrapWith);
		}
		builder.append(str);
		if (wrapEnd) {
			builder.append(wrapWith);
		}
		return builder.toString();
	}

	/**
	 * <p>
	 * Wraps a string with a string if that string is missing from the start or end
	 * of the given string.
	 * </p>
	 *
	 * <p>
	 * A new {@code String} will not be created if {@code str} is already wrapped.
	 * </p>
	 *
	 * <pre>
	 * StringUtils.wrapIfMissing(null, *)         = null
	 * StringUtils.wrapIfMissing("", *)           = ""
	 * StringUtils.wrapIfMissing("ab", null)      = "ab"
	 * StringUtils.wrapIfMissing("ab", "x")       = "xabx"
	 * StringUtils.wrapIfMissing("ab", "\"")      = "\"ab\""
	 * StringUtils.wrapIfMissing("\"ab\"", "\"")  = "\"ab\""
	 * StringUtils.wrapIfMissing("ab", "'")       = "'ab'"
	 * StringUtils.wrapIfMissing("'abcd'", "'")   = "'abcd'"
	 * StringUtils.wrapIfMissing("\"abcd\"", "'") = "'\"abcd\"'"
	 * StringUtils.wrapIfMissing("'abcd'", "\"")  = "\"'abcd'\""
	 * StringUtils.wrapIfMissing("/", "/")  = "/"
	 * StringUtils.wrapIfMissing("a/b/c", "/")  = "/a/b/c/"
	 * StringUtils.wrapIfMissing("/a/b/c", "/")  = "/a/b/c/"
	 * StringUtils.wrapIfMissing("a/b/c/", "/")  = "/a/b/c/"
	 * </pre>
	 *
	 * @param str      the string to be wrapped, may be {@code null}
	 * @param wrapWith the string that will wrap {@code str}
	 * @return the wrapped string, or {@code null} if {@code str==null}
	 * @since 3.5
	 */
	public static String wrapIfMissing(final String str, final String wrapWith) {
		if (isEmpty(str) || isEmpty(wrapWith)) {
			return str;
		}

		final boolean wrapStart = !str.startsWith(wrapWith);
		final boolean wrapEnd = !str.endsWith(wrapWith);
		if (!wrapStart && !wrapEnd) {
			return str;
		}

		final 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();
	}

	/**
	 * <p>
	 * {@code StringUtils} instances should NOT be constructed in standard
	 * programming. Instead, the class should be used as
	 * {@code StringUtils.trim(" foo ");}.
	 * </p>
	 *
	 * <p>
	 * This constructor is public to permit tools that require a JavaBean instance
	 * to operate.
	 * </p>
	 */
	public StringUtils() {
	}

}
