/*

  * 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.text.Normalizer;

 import java.util.ArrayList;

 import java.util.Arrays;

 import java.util.Iterator;

 import java.util.List;

 import java.util.Locale;

 import java.util.regex.Pattern;

 /**

  * <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</b>

  *      - compares two strings null-safe</li>

  *  <li><b>startsWith</b>

  *      - check if a String starts with a prefix null-safe</li>

  *  <li><b>endsWith</b>

  *      - check if a String ends with a suffix null-safe</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>

  *      - does 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>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>Reverse/ReverseDelimited</b>

  *      - reverses a String</li>

  *  <li><b>Abbreviate</b>

  *      - abbreviates a string using ellipsis</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 give sample code 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

  * @version $Id: StringUtils.java 1437065 2013-01-22 17:29:33Z ggregory $

  */

 //@Immutable

 public class StringUtils {

     // 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 = "";

     /**

      * 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;

     /**

      * A regex pattern for recognizing blocks of whitespace characters.

      * The apparent convolutedness of the pattern serves the purpose of

      * ignoring "blocks" consisting of only a single space:  the pattern

      * is used only to normalize whitespace, condensing "blocks" down to a

      * single space, thus matching the same would likely cause a great

      * many noop replacements.

      */

     private static final Pattern WHITESPACE_PATTERN = Pattern.compile("(?: \\s|[\\s&&[^ ]])\\s*");

     /**

      * <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() {

         super();

     }

     // Empty checks

     //-----------------------------------------------------------------------

     /**

      * <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 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 !StringUtils.isEmpty(cs);

     }

     /**

      * <p>Checks if a CharSequence is whitespace, empty ("") or null.</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

      * @since 2.0

      * @since 3.0 Changed signature from isBlank(String) to isBlank(CharSequence)

      */

     public static boolean isBlank(final CharSequence cs) {

         int strLen;

         if (cs == null || (strLen = cs.length()) == 0) {

             return true;

         }

         for (int i = 0; i < strLen; i++) {

             if (Character.isWhitespace(cs.charAt(i)) == false) {

                 return false;

             }

         }

         return true;

     }

     /**

      * <p>Checks if a CharSequence is not empty (""), not null and not whitespace only.</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

      * @since 2.0

      * @since 3.0 Changed signature from isNotBlank(String) to isNotBlank(CharSequence)

      */

     public static boolean isNotBlank(final CharSequence cs) {

         return !StringUtils.isBlank(cs);

     }

     // Trim

     //-----------------------------------------------------------------------

     /**

      * <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 <= 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 {@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 <= 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 <= 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>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 <= 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();

     }

     // Stripping

     //-----------------------------------------------------------------------

     /**

      * <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 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.length() == 0 ? null : str;

     }

     /**

      * <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 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) {

         if (isEmpty(str)) {

             return str;

         }

         str = stripStart(str, stripChars);

         return stripEnd(str, stripChars);

     }

     /**

      * <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) {

         int strLen;

         if (str == null || (strLen = str.length()) == 0) {

             return str;

         }

         int start = 0;

         if (stripChars == null) {

             while (start != strLen && Character.isWhitespace(str.charAt(start))) {

                 start++;

             }

         } else if (stripChars.length() == 0) {

             return str;

         } else {

             while (start != strLen && stripChars.indexOf(str.charAt(start)) != INDEX_NOT_FOUND) {

                 start++;

             }

         }

         return str.substring(start);

     }

     /**

      * <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;

         if (str == null || (end = str.length()) == 0) {

             return str;

         }

         if (stripChars == null) {

             while (end != 0 && Character.isWhitespace(str.charAt(end - 1))) {

                 end--;

             }

         } else if (stripChars.length() == 0) {

             return str;

         } else {

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

                 end--;

             }

         }

         return str.substring(0, end);

     }

     // StripAll

     //-----------------------------------------------------------------------

     /**

      * <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>

      * 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) {

         int strsLen;

         if (strs == null || (strsLen = strs.length) == 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>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("é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 Pattern pattern = Pattern.compile("\\p{InCombiningDiacriticalMarks}+");//$NON-NLS-1$

         final String decomposed = Normalizer.normalize(input, Normalizer.Form.NFD);

         // Note that this doesn't correctly remove ligatures...

         return pattern.matcher(decomposed).replaceAll("");//$NON-NLS-1$

     }

     // Equals

     //-----------------------------------------------------------------------

     /**

      * <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 case sensitive.</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>

      *

      * @see Object#equals(Object)

      * @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)

      */

     public static boolean equals(final CharSequence cs1, final CharSequence cs2) {

         if (cs1 == cs2) {

             return true;

         }

         if (cs1 == null || cs2 == null) {

             return false;

         }

         if (cs1 instanceof String && cs2 instanceof String) {

             return cs1.equals(cs2);

         }

         return CharSequenceUtils.regionMatches(cs1, false, 0, cs2, 0, Math.max(cs1.length(), cs2.length()));

     }

     /**

      * <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. Comparison is case insensitive.</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 str1  the first CharSequence, may be null

      * @param str2  the second CharSequence, may be null

      * @return {@code true} if the CharSequence are equal, case insensitive, or

      *  both {@code null}

      * @since 3.0 Changed signature from equalsIgnoreCase(String, String) to equalsIgnoreCase(CharSequence, CharSequence)

      */

     public static boolean equalsIgnoreCase(final CharSequence str1, final CharSequence str2) {

         if (str1 == null || str2 == null) {

             return str1 == str2;

         } else if (str1 == str2) {

             return true;

         } else if (str1.length() != str2.length()) {

             return false;

         } else {

             return CharSequenceUtils.regionMatches(str1, true, 0, str2, 0, str1.length());

         }

     }

     // IndexOf

     //-----------------------------------------------------------------------

     /**

      * <p>Finds the first index within a CharSequence, handling {@code null}.

      * This method uses {@link String#indexOf(int, int)} if possible.</p>

      *

      * <p>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)

      */

     public static int indexOf(final CharSequence seq, final int searchChar) {

         if (isEmpty(seq)) {

             return INDEX_NOT_FOUND;

         }

         return CharSequenceUtils.indexOf(seq, searchChar, 0);

     }

     /**

      * <p>Finds the first index within a CharSequence from a start position,

      * handling {@code null}.

      * This method uses {@link String#indexOf(int, int)} if possible.</p>

      *

      * <p>A {@code null} or empty ("") CharSequence will return {@code (INDEX_NOT_FOUND) -1}.

      * A negative start position is treated as zero.

      * A start position greater than the string length returns {@code -1}.</p>

      *

      * <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,

      *  -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)

      */

     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>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,

      *  -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);

     }

     /**

      * <p>Finds the n-th index within a CharSequence, handling {@code null}.

      * This method uses {@link String#indexOf(String)} if possible.</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>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>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

      * @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;

         int index = lastIndex ? str.length() : INDEX_NOT_FOUND;

         do {

             if (lastIndex) {

                 index = CharSequenceUtils.lastIndexOf(str, searchStr, index - 1);

             } else {

                 index = CharSequenceUtils.indexOf(str, searchStr, index + 1);

             }

             if (index < 0) {

                 return index;

             }

             found++;

         } while (found < ordinal);

         return index;

     }

     /**

      * <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)        = 3

      * </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,

      *  -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;

     }

     // LastIndexOf

     //-----------------------------------------------------------------------

     /**

      * <p>Finds the last index within a CharSequence, handling {@code null}.

      * This method uses {@link String#lastIndexOf(int)} if possible.</p>

      *

      * <p>A {@code null} or empty ("") CharSequence will return {@code -1}.</p>

      *

      * <pre>

      * StringUtils.lastIndexOf(null, *)         = -1

      * StringUtils.lastIndexOf("", *)           = -1

      * StringUtils.lastIndexOf("aabaabaa", 'a') = 7

      * StringUtils.lastIndexOf("aabaabaa", 'b') = 5

      * </pre>

      *

      * @param seq  the 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)

      */

     public static int lastIndexOf(final CharSequence seq, final int searchChar) {

         if (isEmpty(seq)) {

             return INDEX_NOT_FOUND;

         }

         return CharSequenceUtils.lastIndexOf(seq, searchChar, seq.length());

     }

     /**

      * <p>Finds the last index within a CharSequence from a start position,

      * handling {@code null}.

      * This method uses {@link String#lastIndexOf(int, int)} if possible.</p>

      *

      * <p>A {@code null} or empty ("") CharSequence will return {@code -1}.

      * A negative start position returns {@code -1}.

      * A start position greater than the string length searches the whole string.</p>

      *

      * <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,

      *  -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>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 || searchSeq == null) {

             return INDEX_NOT_FOUND;

         }

         return CharSequenceUtils.lastIndexOf(seq, searchSeq, seq.length());

     }

     /**

      * <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>Finds the first 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.</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

      * </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,

      *  -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) {

         if (seq == null || searchSeq == null) {

             return INDEX_NOT_FOUND;

         }

         return CharSequenceUtils.lastIndexOf(seq, searchSeq, startPos);

     }

     /**

      * <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.</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 first index of the search CharSequence,

      *  -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;

         }

         if (startPos > str.length() - searchStr.length()) {

             startPos = str.length() - searchStr.length();

         }

         if (startPos < 0) {

             return INDEX_NOT_FOUND;

         }

         if (searchStr.length() == 0) {

             return startPos;

         }

         for (int i = startPos; i >= 0; i--) {

             if (CharSequenceUtils.regionMatches(str, true, i, searchStr, 0, searchStr.length())) {

                 return i;

             }

         }

         return INDEX_NOT_FOUND;

     }

     // Contains

     //-----------------------------------------------------------------------

     /**

      * <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 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