StrUtils (dexcoder-commons 2.3.1 API)

java.lang.Object
- com.dexcoder.commons.utils.StrUtils

```
public class StrUtils
extends Object
```
本类来源于apache-commons-lang > StringUtils
Created by liyd on 2015-12-4.

字段概要

字段
限定符和类型字段和说明

static String EMPTY
The empty String "".

static int INDEX_NOT_FOUND
Represents a failed index search.

字段
限定符和类型	字段和说明
`static String`	`EMPTY` The empty String `""`.
`static int`	`INDEX_NOT_FOUND` Represents a failed index search.

构造器概要

构造器
构造器和说明

StrUtils()
StrUtils instances should NOT be constructed in standard programming.

构造器
构造器和说明
`StrUtils()` `StrUtils` instances should NOT be constructed in standard programming.

方法概要

方法
限定符和类型	方法和说明
`static String`	`abbreviate(String str, int maxWidth)` Abbreviates a String using ellipses.
`static String`	`abbreviate(String str, int offset, int maxWidth)` Abbreviates a String using ellipses.
`static String`	`capitalise(String str)` 已过时。 Use the standardly named `capitalize(String)`. Method will be removed in Commons Lang 3.0.
`static String`	`capitalize(String str)` Capitalizes a String changing the first letter to title case as per `Character.toTitleCase(char)`.
`static String`	`center(String str, int size)` Centers a String in a larger String of size `size` using the space character (' ').
`static String`	`center(String str, int size, char padChar)` Centers a String in a larger String of size `size`.
`static String`	`center(String str, int size, String padStr)` Centers a String in a larger String of size `size`.
`static String`	`chomp(String str, String separator)` Removes `separator` from the end of `str` if it's there, otherwise leave it alone.
`static String`	`chompLast(String str, String sep)` 已过时。 Use `chomp(String, String)` instead. Method will be removed in Commons Lang 3.0.
`static String`	`concatenate(Object[] array)` 已过时。 Use the better named `join(Object[])` instead. Method will be removed in Commons Lang 3.0.
`static boolean`	`contains(String str, char searchChar)` Checks if String contains a search character, handling `null`.
`static boolean`	`contains(String str, String searchStr)` Checks if String contains a search String, handling `null`.
`static boolean`	`containsAny(String str, char[] searchChars)` Checks if the String contains any character in the given set of characters.
`static boolean`	`containsAny(String str, String searchChars)` Checks if the String contains any character in the given set of characters.
`static boolean`	`containsIgnoreCase(String str, String searchStr)` Checks if String contains a search String irrespective of case, handling `null`.
`static boolean`	`containsNone(String str, char[] invalidChars)` Checks that the String does not contain certain characters.
`static boolean`	`containsNone(String str, String invalidChars)` Checks that the String does not contain certain characters.
`static boolean`	`containsOnly(String str, char[] valid)` Checks if the String contains only certain characters.
`static boolean`	`containsOnly(String str, String validChars)` Checks if the String contains only certain characters.
`static int`	`countMatches(String str, String sub)` Counts how many times the substring appears in the larger String.
`static String`	`defaultIfEmpty(String str, String defaultStr)` Returns either the passed in String, or if the String is empty or `null`, the value of `defaultStr`.
`static String`	`defaultString(String str)` Returns either the passed in String, or if the String is `null`, an empty String ("").
`static String`	`defaultString(String str, String defaultStr)` Returns either the passed in String, or if the String is `null`, the value of `defaultStr`.
`static String`	`deleteWhitespace(String str)` Deletes all whitespaces from a String as defined by `Character.isWhitespace(char)`.
`static String`	`difference(String str1, String str2)` Compares two Strings, and returns the portion where they differ.
`static boolean`	`endsWith(String str, String suffix)` Check if a String ends with a specified suffix.
`static boolean`	`endsWithIgnoreCase(String str, String suffix)` Case insensitive check if a String ends with a specified suffix.
`static boolean`	`equals(String str1, String str2)` Compares two Strings, returning `true` if they are equal.
`static boolean`	`equalsIgnoreCase(String str1, String str2)` Compares two Strings, returning `true` if they are equal ignoring the case.
`static String`	`getChomp(String str, String sep)` 已过时。 Use `substringAfterLast(String, String)` instead (although this doesn't include the separator) Method will be removed in Commons Lang 3.0.
`static String`	`getCommonPrefix(String[] strs)` Compares all Strings in an array and returns the initial sequence of characters that is common to all of them.
`static int`	`getLevenshteinDistance(String s, String t)` Find the Levenshtein distance between two Strings.
`static String`	`getNestedString(String str, String tag)` 已过时。 Use the better named `substringBetween(String, String)`. Method will be removed in Commons Lang 3.0.
`static String`	`getNestedString(String str, String open, String close)` 已过时。 Use the better named `substringBetween(String, String, String)`. Method will be removed in Commons Lang 3.0.
`static String`	`getPrechomp(String str, String sep)` 已过时。 Use `substringBefore(String, String)` instead (although this doesn't include the separator). Method will be removed in Commons Lang 3.0.
`static int`	`indexOf(String str, char searchChar)` Finds the first index within a String, handling `null`.
`static int`	`indexOf(String str, char searchChar, int startPos)` Finds the first index within a String from a start position, handling `null`.
`static int`	`indexOf(String str, String searchStr)` Finds the first index within a String, handling `null`.
`static int`	`indexOf(String str, String searchStr, int startPos)` Finds the first index within a String, handling `null`.
`static int`	`indexOfAny(String str, char[] searchChars)` Search a String to find the first index of any character in the given set of characters.
`static int`	`indexOfAny(String str, String searchChars)` Search a String to find the first index of any character in the given set of characters.
`static int`	`indexOfAny(String str, String[] searchStrs)` Find the first index of any of a set of potential substrings.
`static int`	`indexOfAnyBut(String str, char[] searchChars)` Search a String to find the first index of any character not in the given set of characters.
`static int`	`indexOfAnyBut(String str, String searchChars)` Search a String to find the first index of any character not in the given set of characters.
`static int`	`indexOfDifference(String[] strs)` Compares all Strings in an array and returns the index at which the Strings begin to differ.
`static int`	`indexOfDifference(String str1, String str2)` Compares two Strings, and returns the index at which the Strings begin to differ.
`static boolean`	`isAlpha(String str)` Checks if the String contains only unicode letters.
`static boolean`	`isAlphanumeric(String str)` Checks if the String contains only unicode letters or digits.
`static boolean`	`isAlphanumericSpace(String str)` Checks if the String contains only unicode letters, digits or space (`' '`).
`static boolean`	`isAlphaSpace(String str)` Checks if the String contains only unicode letters and space (' ').
`static boolean`	`isBlank(String str)` Checks if a String is whitespace, empty ("") or null.
`static boolean`	`isEmpty(String str)` Checks if a String is empty ("") or null.
`static boolean`	`isNotBlank(String str)` Checks if a String is not empty (""), not null and not whitespace only.
`static boolean`	`isNotEmpty(String str)` Checks if a String is not empty ("") and not null.
`static boolean`	`isNumeric(String str)` Checks if the String contains only unicode digits.
`static boolean`	`isNumericSpace(String str)` Checks if the String contains only unicode digits or space (`' '`).
`static boolean`	`isWhitespace(String str)` Checks if the String contains only whitespace.
`static String`	`join(Object[] array)` Joins the elements of the provided array into a single String containing the provided list of elements.
`static String`	`join(Object[] array, char separator)` Joins the elements of the provided array into a single String containing the provided list of elements.
`static String`	`join(Object[] array, char separator, int startIndex, int endIndex)` Joins the elements of the provided array into a single String containing the provided list of elements.
`static String`	`join(Object[] array, String separator)` Joins the elements of the provided array into a single String containing the provided list of elements.
`static String`	`join(Object[] array, String separator, int startIndex, int endIndex)` Joins the elements of the provided array into a single String containing the provided list of elements.
`static int`	`lastIndexOf(String str, char searchChar)` Finds the last index within a String, handling `null`.
`static int`	`lastIndexOf(String str, char searchChar, int startPos)` Finds the last index within a String from a start position, handling `null`.
`static int`	`lastIndexOf(String str, String searchStr)` Finds the last index within a String, handling `null`.
`static int`	`lastIndexOf(String str, String searchStr, int startPos)` Finds the first index within a String, handling `null`.
`static int`	`lastIndexOfAny(String str, String[] searchStrs)` Find the latest index of any of a set of potential substrings.
`static String`	`left(String str, int len)` Gets the leftmost `len` characters of a String.
`static String`	`leftPad(String str, int size)` Left pad a String with spaces (' ').
`static String`	`leftPad(String str, int size, char padChar)` Left pad a String with a specified character.
`static String`	`leftPad(String str, int size, String padStr)` Left pad a String with a specified String.
`static int`	`length(String str)` Gets a String's length or `0` if the String is `null`.
`static String`	`lowerCase(String str)` Converts a String to lower case as per `String.toLowerCase()`.
`static String`	`mid(String str, int pos, int len)` Gets `len` characters from the middle of a String.
`static int`	`ordinalIndexOf(String str, String searchStr, int ordinal)` Finds the n-th index within a String, handling `null`.
`static String`	`overlay(String str, String overlay, int start, int end)` Overlays part of a String with another String.
`static String`	`overlayString(String text, String overlay, int start, int end)` 已过时。 Use better named `overlay(String, String, int, int)` instead. Method will be removed in Commons Lang 3.0.
`static String`	`prechomp(String str, String sep)` 已过时。 Use `substringAfter(String, String)` instead. Method will be removed in Commons Lang 3.0.
`static String`	`remove(String str, char remove)` Removes all occurrences of a character from within the source string.
`static String`	`remove(String str, String remove)` Removes all occurrences of a substring from within the source string.
`static String`	`removeEnd(String str, String remove)` Removes a substring only if it is at the end of a source string, otherwise returns the source string.
`static String`	`removeEndIgnoreCase(String str, String remove)` Case insensitive removal of a substring if it is at the end of a source string, otherwise returns the source string.
`static String`	`removeStart(String str, String remove)` Removes a substring only if it is at the begining of a source string, otherwise returns the source string.
`static String`	`removeStartIgnoreCase(String str, String remove)` Case insensitive removal of a substring if it is at the begining of a source string, otherwise returns the source string.
`static String`	`repeat(String str, int repeat)` Repeat a String `repeat` times to form a new String.
`static String`	`replace(String text, String searchString, String replacement)` Replaces all occurrences of a String within another String.
`static String`	`replace(String text, String searchString, String replacement, int max)` Replaces a String with another String inside a larger String, for the first `max` values of the search String.
`static String`	`replaceChars(String str, char searchChar, char replaceChar)` Replaces all occurrences of a character in a String with another.
`static String`	`replaceChars(String str, String searchChars, String replaceChars)` Replaces multiple characters in a String in one go.
`static String`	`replaceEach(String text, String[] searchList, String[] replacementList)` Replaces all occurrences of Strings within another String.
`static String`	`replaceEachRepeatedly(String text, String[] searchList, String[] replacementList)` Replaces all occurrences of Strings within another String.
`static String`	`replaceOnce(String text, String searchString, String replacement)` Replaces a String with another String inside a larger String, once.
`static String`	`reverse(String str)` Reverses a String as per `StringBuffer.reverse()`.
`static String`	`right(String str, int len)` Gets the rightmost `len` characters of a String.
`static String`	`rightPad(String str, int size)` Right pad a String with spaces (' ').
`static String`	`rightPad(String str, int size, char padChar)` Right pad a String with a specified character.
`static String`	`rightPad(String str, int size, String padStr)` Right pad a String with a specified String.
`static String[]`	`split(String str)` Splits the provided text into an array, using whitespace as the separator.
`static String[]`	`split(String str, char separatorChar)` Splits the provided text into an array, separator specified.
`static String[]`	`split(String str, String separatorChars)` Splits the provided text into an array, separators specified.
`static String[]`	`split(String str, String separatorChars, int max)` Splits the provided text into an array with a maximum length, separators specified.
`static String[]`	`splitByCharacterType(String str)` Splits a String by Character type as returned by `java.lang.Character.getType(char)`.
`static String[]`	`splitByCharacterTypeCamelCase(String str)` Splits a String by Character type as returned by `java.lang.Character.getType(char)`.
`static String[]`	`splitByWholeSeparator(String str, String separator)` Splits the provided text into an array, separator string specified.
`static String[]`	`splitByWholeSeparator(String str, String separator, int max)` Splits the provided text into an array, separator string specified.
`static String[]`	`splitByWholeSeparatorPreserveAllTokens(String str, String separator)` Splits the provided text into an array, separator string specified.
`static String[]`	`splitByWholeSeparatorPreserveAllTokens(String str, String separator, int max)` Splits the provided text into an array, separator string specified.
`static String[]`	`splitPreserveAllTokens(String str)` Splits the provided text into an array, using whitespace as the separator, preserving all tokens, including empty tokens created by adjacent separators.
`static String[]`	`splitPreserveAllTokens(String str, char separatorChar)` Splits the provided text into an array, separator specified, preserving all tokens, including empty tokens created by adjacent separators.
`static String[]`	`splitPreserveAllTokens(String str, String separatorChars)` Splits the provided text into an array, separators specified, preserving all tokens, including empty tokens created by adjacent separators.
`static String[]`	`splitPreserveAllTokens(String str, String separatorChars, int max)` Splits the provided text into an array with a maximum length, separators specified, preserving all tokens, including empty tokens created by adjacent separators.
`static boolean`	`startsWith(String str, String prefix)` Check if a String starts with a specified prefix.
`static boolean`	`startsWithIgnoreCase(String str, String prefix)` Case insensitive check if a String starts with a specified prefix.
`static String`	`strip(String str)` Strips whitespace from the start and end of a String.
`static String`	`strip(String str, String stripChars)` Strips any of a set of characters from the start and end of a String.
`static String[]`	`stripAll(String[] strs)` Strips whitespace from the start and end of every String in an array.
`static String[]`	`stripAll(String[] strs, String stripChars)` Strips any of a set of characters from the start and end of every String in an array.
`static String`	`stripEnd(String str, String stripChars)` Strips any of a set of characters from the end of a String.
`static String`	`stripStart(String str, String stripChars)` Strips any of a set of characters from the start of a String.
`static String`	`stripToEmpty(String str)` Strips whitespace from the start and end of a String returning an empty String if `null` input.
`static String`	`stripToNull(String str)` Strips whitespace from the start and end of a String returning `null` if the String is empty ("") after the strip.
`static String`	`substring(String str, int start)` Gets a substring from the specified String avoiding exceptions.
`static String`	`substring(String str, int start, int end)` Gets a substring from the specified String avoiding exceptions.
`static String`	`substringAfter(String str, String separator)` Gets the substring after the first occurrence of a separator.
`static String`	`substringAfterLast(String str, String separator)` Gets the substring after the last occurrence of a separator.
`static String`	`substringBefore(String str, String separator)` Gets the substring before the first occurrence of a separator.
`static String`	`substringBeforeLast(String str, String separator)` Gets the substring before the last occurrence of a separator.
`static String`	`substringBetween(String str, String tag)` Gets the String that is nested in between two instances of the same String.
`static String`	`substringBetween(String str, String open, String close)` Gets the String that is nested in between two Strings.
`static String[]`	`substringsBetween(String str, String open, String close)` Searches a String for substrings delimited by a start and end tag, returning all matching substrings in an array.
`static String`	`swapCase(String str)` Swaps the case of a String changing upper and title case to lower case, and lower case to upper case.
`static String`	`trim(String str)` Removes control characters (char <= 32) from both ends of this String, handling `null` by returning `null`.
`static String`	`trimToEmpty(String str)` Removes control characters (char <= 32) from both ends of this String returning an empty String ("") if the String is empty ("") after the trim or if it is `null`.
`static String`	`trimToNull(String str)` Removes control characters (char <= 32) from both ends of this String returning `null` if the String is empty ("") after the trim or if it is `null`.
`static String`	`uncapitalise(String str)` 已过时。 Use the standardly named `uncapitalize(String)`. Method will be removed in Commons Lang 3.0.
`static String`	`uncapitalize(String str)` Uncapitalizes a String changing the first letter to title case as per `Character.toLowerCase(char)`.
`static String`	`upperCase(String str)` Converts a String to upper case as per `String.toUpperCase()`.

从类继承的方法 java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

字段详细资料
- EMPTY
```
public static final String EMPTY
```
  The empty String "".
  
  从以下版本开始:
  
  2.0
  
  另请参阅:
  常量字段值
- INDEX_NOT_FOUND
```
public static final int INDEX_NOT_FOUND
```
  Represents a failed index search.
  
  从以下版本开始:
  
  2.1
  
  另请参阅:
  常量字段值

构造器详细资料
- StrUtils
```
public StrUtils()
```
  StrUtils instances should NOT be constructed in standard programming. Instead, the class should be used as StrUtils.trim(" foo ");.
  
  This constructor is public to permit tools that require a JavaBean instance to operate.

方法详细资料

isEmpty
```
public static boolean isEmpty(String str)
```
Checks if a String is empty ("") or null.
```
 StrUtils.isEmpty(null)      = true
 StrUtils.isEmpty("")        = true
 StrUtils.isEmpty(" ")       = false
 StrUtils.isEmpty("bob")     = false
 StrUtils.isEmpty("  bob  ") = false
 
```
NOTE: This method changed in Lang version 2.0. It no longer trims the String. That functionality is available in isBlank().
参数:
str - the String to check, may be null

返回:
true if the String is empty or null

isNotEmpty

public static boolean isNotEmpty(String str)

Checks if a String is not empty ("") and not null.

 StrUtils.isNotEmpty(null)      = false
 StrUtils.isNotEmpty("")        = false
 StrUtils.isNotEmpty(" ")       = true
 StrUtils.isNotEmpty("bob")     = true
 StrUtils.isNotEmpty("  bob  ") = true

参数:: str - the String to check, may be null
返回:: true if the String is not empty and not null

isBlank

public static boolean isBlank(String str)

Checks if a String is whitespace, empty ("") or null.

 StrUtils.isBlank(null)      = true
 StrUtils.isBlank("")        = true
 StrUtils.isBlank(" ")       = true
 StrUtils.isBlank("bob")     = false
 StrUtils.isBlank("  bob  ") = false

参数:: str - the String to check, may be null
返回:: true if the String is null, empty or whitespace
从以下版本开始:: 2.0

isNotBlank

public static boolean isNotBlank(String str)

Checks if a String is not empty (""), not null and not whitespace only.

 StrUtils.isNotBlank(null)      = false
 StrUtils.isNotBlank("")        = false
 StrUtils.isNotBlank(" ")       = false
 StrUtils.isNotBlank("bob")     = true
 StrUtils.isNotBlank("  bob  ") = true

参数:: str - the String to check, may be null
返回:: true if the String is not empty and not null and not whitespace
从以下版本开始:: 2.0

trim
```
public static String trim(String str)
```
Removes control characters (char <= 32) from both ends of this String, handling null by returning null.

The String is trimmed using String.trim(). Trim removes start and end characters <= 32. To strip whitespace use strip(String).

To trim your choice of characters, use the strip(String, String) methods.
```
 StrUtils.trim(null)          = null
 StrUtils.trim("")            = ""
 StrUtils.trim("     ")       = ""
 StrUtils.trim("abc")         = "abc"
 StrUtils.trim("    abc    ") = "abc"
 
```
参数:
str - the String to be trimmed, may be null

返回:
the trimmed string, null if null String input

trimToNull
```
public static String trimToNull(String str)
```
Removes control characters (char <= 32) from both ends of this String returning null if the String is empty ("") after the trim or if it is null.

The String is trimmed using String.trim(). Trim removes start and end characters <= 32. To strip whitespace use stripToNull(String).
```
 StrUtils.trimToNull(null)          = null
 StrUtils.trimToNull("")            = null
 StrUtils.trimToNull("     ")       = null
 StrUtils.trimToNull("abc")         = "abc"
 StrUtils.trimToNull("    abc    ") = "abc"
 
```
参数:
str - the String to be trimmed, may be null

返回:
the trimmed String, null if only chars <= 32, empty or null String input
从以下版本开始:

2.0

trimToEmpty
```
public static String trimToEmpty(String str)
```
Removes control characters (char <= 32) from both ends of this String returning an empty String ("") if the String is empty ("") after the trim or if it is null.

The String is trimmed using String.trim(). Trim removes start and end characters <= 32. To strip whitespace use stripToEmpty(String).
```
 StrUtils.trimToEmpty(null)          = ""
 StrUtils.trimToEmpty("")            = ""
 StrUtils.trimToEmpty("     ")       = ""
 StrUtils.trimToEmpty("abc")         = "abc"
 StrUtils.trimToEmpty("    abc    ") = "abc"
 
```
参数:
str - the String to be trimmed, may be null

返回:
the trimmed String, or an empty String if null input
从以下版本开始:

2.0

strip

public static String strip(String str)

Strips whitespace from the start and end of a String.

This is similar to trim(String) but removes whitespace. Whitespace is defined by Character.isWhitespace(char).

A null input String returns null.

 StrUtils.strip(null)     = null
 StrUtils.strip("")       = ""
 StrUtils.strip("   ")    = ""
 StrUtils.strip("abc")    = "abc"
 StrUtils.strip("  abc")  = "abc"
 StrUtils.strip("abc  ")  = "abc"
 StrUtils.strip(" abc ")  = "abc"
 StrUtils.strip(" ab c ") = "ab c"

参数:: str - the String to remove whitespace from, may be null
返回:: the stripped String, null if null String input

stripToNull
```
public static String stripToNull(String str)
```
Strips whitespace from the start and end of a String returning null if the String is empty ("") after the strip.

This is similar to trimToNull(String) but removes whitespace. Whitespace is defined by Character.isWhitespace(char).
```
 StrUtils.stripToNull(null)     = null
 StrUtils.stripToNull("")       = null
 StrUtils.stripToNull("   ")    = null
 StrUtils.stripToNull("abc")    = "abc"
 StrUtils.stripToNull("  abc")  = "abc"
 StrUtils.stripToNull("abc  ")  = "abc"
 StrUtils.stripToNull(" abc ")  = "abc"
 StrUtils.stripToNull(" ab c ") = "ab c"
 
```
参数:
str - the String to be stripped, may be null

返回:
the stripped String, null if whitespace, empty or null String input
从以下版本开始:

2.0

stripToEmpty

public static String stripToEmpty(String str)

Strips whitespace from the start and end of a String returning an empty String if null input.

This is similar to trimToEmpty(String) but removes whitespace. Whitespace is defined by Character.isWhitespace(char).

 StrUtils.stripToEmpty(null)     = ""
 StrUtils.stripToEmpty("")       = ""
 StrUtils.stripToEmpty("   ")    = ""
 StrUtils.stripToEmpty("abc")    = "abc"
 StrUtils.stripToEmpty("  abc")  = "abc"
 StrUtils.stripToEmpty("abc  ")  = "abc"
 StrUtils.stripToEmpty(" abc ")  = "abc"
 StrUtils.stripToEmpty(" ab c ") = "ab c"

参数:: str - the String to be stripped, may be null
返回:: the trimmed String, or an empty String if null input
从以下版本开始:: 2.0

strip
```
public static String strip(String str,
           String stripChars)
```
Strips any of a set of characters from the start and end of a String. This is similar to String.trim() but allows the characters to be stripped to be controlled.

A null input String returns null. An empty string ("") input returns the empty string.

If the stripChars String is null, whitespace is stripped as defined by Character.isWhitespace(char). Alternatively use strip(String).
```
 StrUtils.strip(null, *)          = null
 StrUtils.strip("", *)            = ""
 StrUtils.strip("abc", null)      = "abc"
 StrUtils.strip("  abc", null)    = "abc"
 StrUtils.strip("abc  ", null)    = "abc"
 StrUtils.strip(" abc ", null)    = "abc"
 StrUtils.strip("  abcyx", "xyz") = "  abc"
 
```
参数:
str - the String to remove characters from, may be null
stripChars - the characters to remove, null treated as whitespace

返回:
the stripped String, null if null String input

stripStart

public static String stripStart(String str,
                String stripChars)

Strips any of a set of characters from the start of a String.

A null input String returns null. An empty string ("") input returns the empty string.

If the stripChars String is null, whitespace is stripped as defined by Character.isWhitespace(char).

 StrUtils.stripStart(null, *)          = null
 StrUtils.stripStart("", *)            = ""
 StrUtils.stripStart("abc", "")        = "abc"
 StrUtils.stripStart("abc", null)      = "abc"
 StrUtils.stripStart("  abc", null)    = "abc"
 StrUtils.stripStart("abc  ", null)    = "abc  "
 StrUtils.stripStart(" abc ", null)    = "abc "
 StrUtils.stripStart("yxabc  ", "xyz") = "abc  "

参数:: str - the String to remove characters from, may be null; stripChars - the characters to remove, null treated as whitespace
返回:: the stripped String, null if null String input

stripEnd

public static String stripEnd(String str,
              String stripChars)

Strips any of a set of characters from the end of a String.

A null input String returns null. An empty string ("") input returns the empty string.

If the stripChars String is null, whitespace is stripped as defined by Character.isWhitespace(char).

 StrUtils.stripEnd(null, *)          = null
 StrUtils.stripEnd("", *)            = ""
 StrUtils.stripEnd("abc", "")        = "abc"
 StrUtils.stripEnd("abc", null)      = "abc"
 StrUtils.stripEnd("  abc", null)    = "  abc"
 StrUtils.stripEnd("abc  ", null)    = "abc"
 StrUtils.stripEnd(" abc ", null)    = " abc"
 StrUtils.stripEnd("  abcyx", "xyz") = "  abc"

参数:: str - the String to remove characters from, may be null; stripChars - the characters to remove, null treated as whitespace
返回:: the stripped String, null if null String input

stripAll
```
public static String[] stripAll(String[] strs)
```
Strips whitespace from the start and end of every String in an array. Whitespace is defined by Character.isWhitespace(char).

A new array is returned each time, except for length zero. A null array will return null. An empty array will return itself. A null array entry will be ignored.
```
 StrUtils.stripAll(null)             = null
 StrUtils.stripAll([])               = []
 StrUtils.stripAll(["abc", "  abc"]) = ["abc", "abc"]
 StrUtils.stripAll(["abc  ", null])  = ["abc", null]
 
```
参数:
strs - the array to remove whitespace from, may be null

返回:
the stripped Strings, null if null array input

stripAll
```
public static String[] stripAll(String[] strs,
                String stripChars)
```
Strips any of a set of characters from the start and end of every String in an array.
Whitespace is defined by Character.isWhitespace(char).

A new array is returned each time, except for length zero. A null array will return null. An empty array will return itself. A null array entry will be ignored. A null stripChars will strip whitespace as defined by Character.isWhitespace(char).
```
 StrUtils.stripAll(null, *)                = null
 StrUtils.stripAll([], *)                  = []
 StrUtils.stripAll(["abc", "  abc"], null) = ["abc", "abc"]
 StrUtils.stripAll(["abc  ", null], null)  = ["abc", null]
 StrUtils.stripAll(["abc  ", null], "yz")  = ["abc  ", null]
 StrUtils.stripAll(["yabcz", null], "yz")  = ["abc", null]
 
```
参数:
strs - the array to remove characters from, may be null
stripChars - the characters to remove, null treated as whitespace

返回:
the stripped Strings, null if null array input

equals
```
public static boolean equals(String str1,
             String str2)
```
Compares two Strings, returning true if they are equal.

nulls are handled without exceptions. Two null references are considered to be equal. The comparison is case sensitive.
```
 StrUtils.equals(null, null)   = true
 StrUtils.equals(null, "abc")  = false
 StrUtils.equals("abc", null)  = false
 StrUtils.equals("abc", "abc") = true
 StrUtils.equals("abc", "ABC") = false
 
```
参数:
str1 - the first String, may be null
str2 - the second String, may be null

返回:
true if the Strings are equal, case sensitive, or both null
另请参阅:
String.equals(Object)

equalsIgnoreCase
```
public static boolean equalsIgnoreCase(String str1,
                       String str2)
```
Compares two Strings, returning true if they are equal ignoring the case.

nulls are handled without exceptions. Two null references are considered equal. Comparison is case insensitive.
```
 StrUtils.equalsIgnoreCase(null, null)   = true
 StrUtils.equalsIgnoreCase(null, "abc")  = false
 StrUtils.equalsIgnoreCase("abc", null)  = false
 StrUtils.equalsIgnoreCase("abc", "abc") = true
 StrUtils.equalsIgnoreCase("abc", "ABC") = true
 
```
参数:
str1 - the first String, may be null
str2 - the second String, may be null

返回:
true if the Strings are equal, case insensitive, or both null
另请参阅:
String.equalsIgnoreCase(String)

indexOf
```
public static int indexOf(String str,
          char searchChar)
```
Finds the first index within a String, handling null. This method uses String.indexOf(int).

A null or empty ("") String will return -1.
```
 StrUtils.indexOf(null, *)         = -1
 StrUtils.indexOf("", *)           = -1
 StrUtils.indexOf("aabaabaa", 'a') = 0
 StrUtils.indexOf("aabaabaa", 'b') = 2
 
```
参数:
str - the String to check, may be null
searchChar - the character to find

返回:
the first index of the search character, -1 if no match or null string input
从以下版本开始:

2.0

indexOf
```
public static int indexOf(String str,
          char searchChar,
          int startPos)
```
Finds the first index within a String from a start position, handling null. This method uses String.indexOf(int, int).

A null or empty ("") String will return -1. A negative start position is treated as zero. A start position greater than the string length returns -1.
```
 StrUtils.indexOf(null, *, *)          = -1
 StrUtils.indexOf("", *, *)            = -1
 StrUtils.indexOf("aabaabaa", 'b', 0)  = 2
 StrUtils.indexOf("aabaabaa", 'b', 3)  = 5
 StrUtils.indexOf("aabaabaa", 'b', 9)  = -1
 StrUtils.indexOf("aabaabaa", 'b', -1) = 2
 
```
参数:
str - the String to check, may be null
searchChar - the character to find
startPos - the start position, negative treated as zero

返回:
the first index of the search character, -1 if no match or null string input
从以下版本开始:

2.0

indexOf

public static int indexOf(String str,
          String searchStr)

Finds the first index within a String, handling null. This method uses String.indexOf(String).

A null String will return -1.

 StrUtils.indexOf(null, *)          = -1
 StrUtils.indexOf(*, null)          = -1
 StrUtils.indexOf("", "")           = 0
 StrUtils.indexOf("aabaabaa", "a")  = 0
 StrUtils.indexOf("aabaabaa", "b")  = 2
 StrUtils.indexOf("aabaabaa", "ab") = 1
 StrUtils.indexOf("aabaabaa", "")   = 0

参数:: str - the String to check, may be null; searchStr - the String to find, may be null
返回:: the first index of the search String, -1 if no match or null string input
从以下版本开始:: 2.0

ordinalIndexOf

public static int ordinalIndexOf(String str,
                 String searchStr,
                 int ordinal)

Finds the n-th index within a String, handling null. This method uses String.indexOf(String).

A null String will return -1.

 StrUtils.ordinalIndexOf(null, *, *)          = -1
 StrUtils.ordinalIndexOf(*, null, *)          = -1
 StrUtils.ordinalIndexOf("", "", *)           = 0
 StrUtils.ordinalIndexOf("aabaabaa", "a", 1)  = 0
 StrUtils.ordinalIndexOf("aabaabaa", "a", 2)  = 1
 StrUtils.ordinalIndexOf("aabaabaa", "b", 1)  = 2
 StrUtils.ordinalIndexOf("aabaabaa", "b", 2)  = 5
 StrUtils.ordinalIndexOf("aabaabaa", "ab", 1) = 1
 StrUtils.ordinalIndexOf("aabaabaa", "ab", 2) = 4
 StrUtils.ordinalIndexOf("aabaabaa", "", 1)   = 0
 StrUtils.ordinalIndexOf("aabaabaa", "", 2)   = 0

参数:: str - the String to check, may be null; searchStr - the String to find, may be null; ordinal - the n-th searchStr to find
返回:: the n-th index of the search String, -1 (INDEX_NOT_FOUND) if no match or null string input
从以下版本开始:: 2.1

indexOf

public static int indexOf(String str,
          String searchStr,
          int startPos)

Finds the first index within a String, handling null. This method uses String.indexOf(String, int).

A null String will return -1. A negative start position is treated as zero. An empty ("") search String always matches. A start position greater than the string length only matches an empty search String.

 StrUtils.indexOf(null, *, *)          = -1
 StrUtils.indexOf(*, null, *)          = -1
 StrUtils.indexOf("", "", 0)           = 0
 StrUtils.indexOf("aabaabaa", "a", 0)  = 0
 StrUtils.indexOf("aabaabaa", "b", 0)  = 2
 StrUtils.indexOf("aabaabaa", "ab", 0) = 1
 StrUtils.indexOf("aabaabaa", "b", 3)  = 5
 StrUtils.indexOf("aabaabaa", "b", 9)  = -1
 StrUtils.indexOf("aabaabaa", "b", -1) = 2
 StrUtils.indexOf("aabaabaa", "", 2)   = 2
 StrUtils.indexOf("abc", "", 9)        = 3

参数:: str - the String to check, may be null; searchStr - the String to find, may be null; startPos - the start position, negative treated as zero
返回:: the first index of the search String, -1 if no match or null string input
从以下版本开始:: 2.0

lastIndexOf
```
public static int lastIndexOf(String str,
              char searchChar)
```
Finds the last index within a String, handling null. This method uses String.lastIndexOf(int).

A null or empty ("") String will return -1.
```
 StrUtils.lastIndexOf(null, *)         = -1
 StrUtils.lastIndexOf("", *)           = -1
 StrUtils.lastIndexOf("aabaabaa", 'a') = 7
 StrUtils.lastIndexOf("aabaabaa", 'b') = 5
 
```
参数:
str - the String to check, may be null
searchChar - the character to find

返回:
the last index of the search character, -1 if no match or null string input
从以下版本开始:

2.0

lastIndexOf
```
public static int lastIndexOf(String str,
              char searchChar,
              int startPos)
```
Finds the last index within a String from a start position, handling null. This method uses String.lastIndexOf(int, int).

A null or empty ("") String will return -1. A negative start position returns -1. A start position greater than the string length searches the whole string.
```
 StrUtils.lastIndexOf(null, *, *)          = -1
 StrUtils.lastIndexOf("", *,  *)           = -1
 StrUtils.lastIndexOf("aabaabaa", 'b', 8)  = 5
 StrUtils.lastIndexOf("aabaabaa", 'b', 4)  = 2
 StrUtils.lastIndexOf("aabaabaa", 'b', 0)  = -1
 StrUtils.lastIndexOf("aabaabaa", 'b', 9)  = 5
 StrUtils.lastIndexOf("aabaabaa", 'b', -1) = -1
 StrUtils.lastIndexOf("aabaabaa", 'a', 0)  = 0
 
```
参数:
str - the String to check, may be null
searchChar - the character to find
startPos - the start position

返回:
the last index of the search character, -1 if no match or null string input
从以下版本开始:

2.0

lastIndexOf

public static int lastIndexOf(String str,
              String searchStr)

Finds the last index within a String, handling null. This method uses String.lastIndexOf(String).

A null String will return -1.

 StrUtils.lastIndexOf(null, *)          = -1
 StrUtils.lastIndexOf(*, null)          = -1
 StrUtils.lastIndexOf("", "")           = 0
 StrUtils.lastIndexOf("aabaabaa", "a")  = 0
 StrUtils.lastIndexOf("aabaabaa", "b")  = 2
 StrUtils.lastIndexOf("aabaabaa", "ab") = 1
 StrUtils.lastIndexOf("aabaabaa", "")   = 8

参数:: str - the String to check, may be null; searchStr - the String to find, may be null
返回:: the last index of the search String, -1 if no match or null string input
从以下版本开始:: 2.0

lastIndexOf
```
public static int lastIndexOf(String str,
              String searchStr,
              int startPos)
```
Finds the first index within a String, handling null. This method uses String.lastIndexOf(String, int).

A null String will return -1. A negative start position returns -1. An empty ("") search String always matches unless the start position is negative. A start position greater than the string length searches the whole string.
```
 StrUtils.lastIndexOf(null, *, *)          = -1
 StrUtils.lastIndexOf(*, null, *)          = -1
 StrUtils.lastIndexOf("aabaabaa", "a", 8)  = 7
 StrUtils.lastIndexOf("aabaabaa", "b", 8)  = 5
 StrUtils.lastIndexOf("aabaabaa", "ab", 8) = 4
 StrUtils.lastIndexOf("aabaabaa", "b", 9)  = 5
 StrUtils.lastIndexOf("aabaabaa", "b", -1) = -1
 StrUtils.lastIndexOf("aabaabaa", "a", 0)  = 0
 StrUtils.lastIndexOf("aabaabaa", "b", 0)  = -1
 
```
参数:
str - the String to check, may be null
searchStr - the String to find, may be null
startPos - the start position, negative treated as zero

返回:
the first index of the search String, -1 if no match or null string input
从以下版本开始:

2.0

contains
```
public static boolean contains(String str,
               char searchChar)
```
Checks if String contains a search character, handling null. This method uses String.indexOf(int).

A null or empty ("") String will return false.
```
 StrUtils.contains(null, *)    = false
 StrUtils.contains("", *)      = false
 StrUtils.contains("abc", 'a') = true
 StrUtils.contains("abc", 'z') = false
 
```
参数:
str - the String to check, may be null
searchChar - the character to find

返回:
true if the String contains the search character, false if not or null string input
从以下版本开始:

2.0

contains

public static boolean contains(String str,
               String searchStr)

Checks if String contains a search String, handling null. This method uses String.indexOf(String).

A null String will return false.

 StrUtils.contains(null, *)     = false
 StrUtils.contains(*, null)     = false
 StrUtils.contains("", "")      = true
 StrUtils.contains("abc", "")   = true
 StrUtils.contains("abc", "a")  = true
 StrUtils.contains("abc", "z")  = false

参数:: str - the String to check, may be null; searchStr - the String to find, may be null
返回:: true if the String contains the search String, false if not or null string input
从以下版本开始:: 2.0

containsIgnoreCase

public static boolean containsIgnoreCase(String str,
                         String searchStr)

Checks if String contains a search String irrespective of case, handling null. This method uses contains(String, String).

A null String will return false.

 StrUtils.contains(null, *) = false
 StrUtils.contains(*, null) = false
 StrUtils.contains("", "") = true
 StrUtils.contains("abc", "") = true
 StrUtils.contains("abc", "a") = true
 StrUtils.contains("abc", "z") = false
 StrUtils.contains("abc", "A") = true
 StrUtils.contains("abc", "Z") = false

参数:: str - the String to check, may be null; searchStr - the String to find, may be null
返回:: true if the String contains the search String irrespective of case or false if not or null string input

indexOfAny

public static int indexOfAny(String str,
             char[] searchChars)

Search a String to find the first index of any character in the given set of characters.

A null String will return -1. A null or zero length search array will return -1.

 StrUtils.indexOfAny(null, *)                = -1
 StrUtils.indexOfAny("", *)                  = -1
 StrUtils.indexOfAny(*, null)                = -1
 StrUtils.indexOfAny(*, [])                  = -1
 StrUtils.indexOfAny("zzabyycdxx",['z','a']) = 0
 StrUtils.indexOfAny("zzabyycdxx",['b','y']) = 3
 StrUtils.indexOfAny("aba", ['z'])           = -1

参数:: str - the String to check, may be null; searchChars - the chars to search for, may be null
返回:: the index of any of the chars, -1 if no match or null input
从以下版本开始:: 2.0

indexOfAny

public static int indexOfAny(String str,
             String searchChars)

Search a String to find the first index of any character in the given set of characters.

A null String will return -1. A null search string will return -1.

 StrUtils.indexOfAny(null, *)            = -1
 StrUtils.indexOfAny("", *)              = -1
 StrUtils.indexOfAny(*, null)            = -1
 StrUtils.indexOfAny(*, "")              = -1
 StrUtils.indexOfAny("zzabyycdxx", "za") = 0
 StrUtils.indexOfAny("zzabyycdxx", "by") = 3
 StrUtils.indexOfAny("aba","z")          = -1

参数:: str - the String to check, may be null; searchChars - the chars to search for, may be null
返回:: the index of any of the chars, -1 if no match or null input
从以下版本开始:: 2.0

containsAny

public static boolean containsAny(String str,
                  char[] searchChars)

Checks if the String contains any character in the given set of characters.

A null String will return false. A null or zero length search array will return false.

 StrUtils.containsAny(null, *)                = false
 StrUtils.containsAny("", *)                  = false
 StrUtils.containsAny(*, null)                = false
 StrUtils.containsAny(*, [])                  = false
 StrUtils.containsAny("zzabyycdxx",['z','a']) = true
 StrUtils.containsAny("zzabyycdxx",['b','y']) = true
 StrUtils.containsAny("aba", ['z'])           = false

参数:: str - the String to check, may be null; searchChars - the chars to search for, may be null
返回:: the true if any of the chars are found, false if no match or null input
从以下版本开始:: 2.4

containsAny

public static boolean containsAny(String str,
                  String searchChars)

Checks if the String contains any character in the given set of characters.

A null String will return false. A null search string will return false.

 StrUtils.containsAny(null, *)            = false
 StrUtils.containsAny("", *)              = false
 StrUtils.containsAny(*, null)            = false
 StrUtils.containsAny(*, "")              = false
 StrUtils.containsAny("zzabyycdxx", "za") = true
 StrUtils.containsAny("zzabyycdxx", "by") = true
 StrUtils.containsAny("aba","z")          = false

参数:: str - the String to check, may be null; searchChars - the chars to search for, may be null
返回:: the true if any of the chars are found, false if no match or null input
从以下版本开始:: 2.4

indexOfAnyBut

public static int indexOfAnyBut(String str,
                char[] searchChars)

Search a String to find the first index of any character not in the given set of characters.

A null String will return -1. A null or zero length search array will return -1.

 StrUtils.indexOfAnyBut(null, *)           = -1
 StrUtils.indexOfAnyBut("", *)             = -1
 StrUtils.indexOfAnyBut(*, null)           = -1
 StrUtils.indexOfAnyBut(*, [])             = -1
 StrUtils.indexOfAnyBut("zzabyycdxx",'za') = 3
 StrUtils.indexOfAnyBut("zzabyycdxx", '')  = 0
 StrUtils.indexOfAnyBut("aba", 'ab')       = -1

参数:: str - the String to check, may be null; searchChars - the chars to search for, may be null
返回:: the index of any of the chars, -1 if no match or null input
从以下版本开始:: 2.0

indexOfAnyBut

public static int indexOfAnyBut(String str,
                String searchChars)

Search a String to find the first index of any character not in the given set of characters.

A null String will return -1. A null search string will return -1.

 StrUtils.indexOfAnyBut(null, *)            = -1
 StrUtils.indexOfAnyBut("", *)              = -1
 StrUtils.indexOfAnyBut(*, null)            = -1
 StrUtils.indexOfAnyBut(*, "")              = -1
 StrUtils.indexOfAnyBut("zzabyycdxx", "za") = 3
 StrUtils.indexOfAnyBut("zzabyycdxx", "")   = 0
 StrUtils.indexOfAnyBut("aba","ab")         = -1

参数:: str - the String to check, may be null; searchChars - the chars to search for, may be null
返回:: the index of any of the chars, -1 if no match or null input
从以下版本开始:: 2.0

containsOnly

public static boolean containsOnly(String str,
                   char[] valid)

Checks if the String contains only certain characters.

A null String will return false. A null valid character array will return false. An empty String ("") always returns true.

 StrUtils.containsOnly(null, *)       = false
 StrUtils.containsOnly(*, null)       = false
 StrUtils.containsOnly("", *)         = true
 StrUtils.containsOnly("ab", '')      = false
 StrUtils.containsOnly("abab", 'abc') = true
 StrUtils.containsOnly("ab1", 'abc')  = false
 StrUtils.containsOnly("abz", 'abc')  = false

参数:: str - the String to check, may be null; valid - an array of valid chars, may be null
返回:: true if it only contains valid chars and is non-null

containsOnly

public static boolean containsOnly(String str,
                   String validChars)

Checks if the String contains only certain characters.

A null String will return false. A null valid character String will return false. An empty String ("") always returns true.

 StrUtils.containsOnly(null, *)       = false
 StrUtils.containsOnly(*, null)       = false
 StrUtils.containsOnly("", *)         = true
 StrUtils.containsOnly("ab", "")      = false
 StrUtils.containsOnly("abab", "abc") = true
 StrUtils.containsOnly("ab1", "abc")  = false
 StrUtils.containsOnly("abz", "abc")  = false

参数:: str - the String to check, may be null; validChars - a String of valid chars, may be null
返回:: true if it only contains valid chars and is non-null
从以下版本开始:: 2.0

containsNone

public static boolean containsNone(String str,
                   char[] invalidChars)

Checks that the String does not contain certain characters.

A null String will return true. A null invalid character array will return true. An empty String ("") always returns true.

 StrUtils.containsNone(null, *)       = true
 StrUtils.containsNone(*, null)       = true
 StrUtils.containsNone("", *)         = true
 StrUtils.containsNone("ab", '')      = true
 StrUtils.containsNone("abab", 'xyz') = true
 StrUtils.containsNone("ab1", 'xyz')  = true
 StrUtils.containsNone("abz", 'xyz')  = false

参数:: str - the String to check, may be null; invalidChars - an array of invalid chars, may be null
返回:: true if it contains none of the invalid chars, or is null
从以下版本开始:: 2.0

containsNone

public static boolean containsNone(String str,
                   String invalidChars)

Checks that the String does not contain certain characters.

A null String will return true. A null invalid character array will return true. An empty String ("") always returns true.

 StrUtils.containsNone(null, *)       = true
 StrUtils.containsNone(*, null)       = true
 StrUtils.containsNone("", *)         = true
 StrUtils.containsNone("ab", "")      = true
 StrUtils.containsNone("abab", "xyz") = true
 StrUtils.containsNone("ab1", "xyz")  = true
 StrUtils.containsNone("abz", "xyz")  = false

参数:: str - the String to check, may be null; invalidChars - a String of invalid chars, may be null
返回:: true if it contains none of the invalid chars, or is null
从以下版本开始:: 2.0

indexOfAny

public static int indexOfAny(String str,
             String[] searchStrs)

Find the first index of any of a set of potential substrings.

A null String will return -1. A null or zero length search array will return -1. A null search array entry will be ignored, but a search array containing "" will return 0 if str is not null. This method uses String.indexOf(String).

 StrUtils.indexOfAny(null, *)                     = -1
 StrUtils.indexOfAny(*, null)                     = -1
 StrUtils.indexOfAny(*, [])                       = -1
 StrUtils.indexOfAny("zzabyycdxx", ["ab","cd"])   = 2
 StrUtils.indexOfAny("zzabyycdxx", ["cd","ab"])   = 2
 StrUtils.indexOfAny("zzabyycdxx", ["mn","op"])   = -1
 StrUtils.indexOfAny("zzabyycdxx", ["zab","aby"]) = 1
 StrUtils.indexOfAny("zzabyycdxx", [""])          = 0
 StrUtils.indexOfAny("", [""])                    = 0
 StrUtils.indexOfAny("", ["a"])                   = -1

参数:: str - the String to check, may be null; searchStrs - the Strings to search for, may be null
返回:: the first index of any of the searchStrs in str, -1 if no match

lastIndexOfAny

public static int lastIndexOfAny(String str,
                 String[] searchStrs)

Find the latest index of any of a set of potential substrings.

A null String will return -1. A null search array will return -1. A null or zero length search array entry will be ignored, but a search array containing "" will return the length of str if str is not null. This method uses String.indexOf(String)

 StrUtils.lastIndexOfAny(null, *)                   = -1
 StrUtils.lastIndexOfAny(*, null)                   = -1
 StrUtils.lastIndexOfAny(*, [])                     = -1
 StrUtils.lastIndexOfAny(*, [null])                 = -1
 StrUtils.lastIndexOfAny("zzabyycdxx", ["ab","cd"]) = 6
 StrUtils.lastIndexOfAny("zzabyycdxx", ["cd","ab"]) = 6
 StrUtils.lastIndexOfAny("zzabyycdxx", ["mn","op"]) = -1
 StrUtils.lastIndexOfAny("zzabyycdxx", ["mn","op"]) = -1
 StrUtils.lastIndexOfAny("zzabyycdxx", ["mn",""])   = 10

参数:: str - the String to check, may be null; searchStrs - the Strings to search for, may be null
返回:: the last index of any of the Strings, -1 if no match

substring
```
public static String substring(String str,
               int start)
```
Gets a substring from the specified String avoiding exceptions.

A negative start position can be used to start n characters from the end of the String.

A null String will return null. An empty ("") String will return "".
```
 StrUtils.substring(null, *)   = null
 StrUtils.substring("", *)     = ""
 StrUtils.substring("abc", 0)  = "abc"
 StrUtils.substring("abc", 2)  = "c"
 StrUtils.substring("abc", 4)  = ""
 StrUtils.substring("abc", -2) = "bc"
 StrUtils.substring("abc", -4) = "abc"
 
```
参数:
str - the String to get the substring from, may be null
start - the position to start from, negative means count back from the end of the String by this many characters

返回:
substring from start position, null if null String input

substring
```
public static String substring(String str,
               int start,
               int end)
```
Gets a substring from the specified String avoiding exceptions.

A negative start position can be used to start/end n characters from the end of the String.

The returned substring starts with the character in the start position and ends before the end position. All position counting is zero-based -- i.e., to start at the beginning of the string use start = 0. Negative start and end positions can be used to specify offsets relative to the end of the String.

If start is not strictly to the left of end, "" is returned.
```
 StrUtils.substring(null, *, *)    = null
 StrUtils.substring("", * ,  *)    = "";
 StrUtils.substring("abc", 0, 2)   = "ab"
 StrUtils.substring("abc", 2, 0)   = ""
 StrUtils.substring("abc", 2, 4)   = "c"
 StrUtils.substring("abc", 4, 6)   = ""
 StrUtils.substring("abc", 2, 2)   = ""
 StrUtils.substring("abc", -2, -1) = "b"
 StrUtils.substring("abc", -4, 2)  = "ab"
 
```
参数:
str - the String to get the substring from, may be null
start - the position to start from, negative means count back from the end of the String by this many characters
end - the position to end at (exclusive), negative means count back from the end of the String by this many characters

返回:
substring from start position to end positon, null if null String input

left
```
public static String left(String str,
          int len)
```
Gets the leftmost len characters of a String.

If len characters are not available, or the String is null, the String will be returned without an exception. An exception is thrown if len is negative.
```
 StrUtils.left(null, *)    = null
 StrUtils.left(*, -ve)     = ""
 StrUtils.left("", *)      = ""
 StrUtils.left("abc", 0)   = ""
 StrUtils.left("abc", 2)   = "ab"
 StrUtils.left("abc", 4)   = "abc"
 
```
参数:
str - the String to get the leftmost characters from, may be null
len - the length of the required String, must be zero or positive

返回:
the leftmost characters, null if null String input

right
```
public static String right(String str,
           int len)
```
Gets the rightmost len characters of a String.

If len characters are not available, or the String is null, the String will be returned without an an exception. An exception is thrown if len is negative.
```
 StrUtils.right(null, *)    = null
 StrUtils.right(*, -ve)     = ""
 StrUtils.right("", *)      = ""
 StrUtils.right("abc", 0)   = ""
 StrUtils.right("abc", 2)   = "bc"
 StrUtils.right("abc", 4)   = "abc"
 
```
参数:
str - the String to get the rightmost characters from, may be null
len - the length of the required String, must be zero or positive

返回:
the rightmost characters, null if null String input

mid
```
public static String mid(String str,
         int pos,
         int len)
```
Gets len characters from the middle of a String.

If len characters are not available, the remainder of the String will be returned without an exception. If the String is null, null will be returned. An exception is thrown if len is negative.
```
 StrUtils.mid(null, *, *)    = null
 StrUtils.mid(*, *, -ve)     = ""
 StrUtils.mid("", 0, *)      = ""
 StrUtils.mid("abc", 0, 2)   = "ab"
 StrUtils.mid("abc", 0, 4)   = "abc"
 StrUtils.mid("abc", 2, 4)   = "c"
 StrUtils.mid("abc", 4, 2)   = ""
 StrUtils.mid("abc", -2, 2)  = "ab"
 
```
参数:
str - the String to get the characters from, may be null
pos - the position to start from, negative treated as zero
len - the length of the required String, must be zero or positive

返回:
the middle characters, null if null String input

substringBefore

public static String substringBefore(String str,
                     String separator)

Gets the substring before the first occurrence of a separator. The separator is not returned.

A null string input will return null. An empty ("") string input will return the empty string. A null separator will return the input string.

 StrUtils.substringBefore(null, *)      = null
 StrUtils.substringBefore("", *)        = ""
 StrUtils.substringBefore("abc", "a")   = ""
 StrUtils.substringBefore("abcba", "b") = "a"
 StrUtils.substringBefore("abc", "c")   = "ab"
 StrUtils.substringBefore("abc", "d")   = "abc"
 StrUtils.substringBefore("abc", "")    = ""
 StrUtils.substringBefore("abc", null)  = "abc"

参数:: str - the String to get a substring from, may be null; separator - the String to search for, may be null
返回:: the substring before the first occurrence of the separator, null if null String input
从以下版本开始:: 2.0

substringAfter
```
public static String substringAfter(String str,
                    String separator)
```
Gets the substring after the first occurrence of a separator. The separator is not returned.

A null string input will return null. An empty ("") string input will return the empty string. A null separator will return the empty string if the input string is not null.
```
 StrUtils.substringAfter(null, *)      = null
 StrUtils.substringAfter("", *)        = ""
 StrUtils.substringAfter(*, null)      = ""
 StrUtils.substringAfter("abc", "a")   = "bc"
 StrUtils.substringAfter("abcba", "b") = "cba"
 StrUtils.substringAfter("abc", "c")   = ""
 StrUtils.substringAfter("abc", "d")   = ""
 StrUtils.substringAfter("abc", "")    = "abc"
 
```
参数:
str - the String to get a substring from, may be null
separator - the String to search for, may be null

返回:
the substring after the first occurrence of the separator, null if null String input
从以下版本开始:

2.0

substringBeforeLast

public static String substringBeforeLast(String str,
                         String separator)

Gets the substring before the last occurrence of a separator. The separator is not returned.

A null string input will return null. An empty ("") string input will return the empty string. An empty or null separator will return the input string.

 StrUtils.substringBeforeLast(null, *)      = null
 StrUtils.substringBeforeLast("", *)        = ""
 StrUtils.substringBeforeLast("abcba", "b") = "abc"
 StrUtils.substringBeforeLast("abc", "c")   = "ab"
 StrUtils.substringBeforeLast("a", "a")     = ""
 StrUtils.substringBeforeLast("a", "z")     = "a"
 StrUtils.substringBeforeLast("a", null)    = "a"
 StrUtils.substringBeforeLast("a", "")      = "a"

参数:: str - the String to get a substring from, may be null; separator - the String to search for, may be null
返回:: the substring before the last occurrence of the separator, null if null String input
从以下版本开始:: 2.0

substringAfterLast

public static String substringAfterLast(String str,
                        String separator)

Gets the substring after the last occurrence of a separator. The separator is not returned.

A null string input will return null. An empty ("") string input will return the empty string. An empty or null separator will return the empty string if the input string is not null.

 StrUtils.substringAfterLast(null, *)      = null
 StrUtils.substringAfterLast("", *)        = ""
 StrUtils.substringAfterLast(*, "")        = ""
 StrUtils.substringAfterLast(*, null)      = ""
 StrUtils.substringAfterLast("abc", "a")   = "bc"
 StrUtils.substringAfterLast("abcba", "b") = "a"
 StrUtils.substringAfterLast("abc", "c")   = ""
 StrUtils.substringAfterLast("a", "a")     = ""
 StrUtils.substringAfterLast("a", "z")     = ""

参数:: str - the String to get a substring from, may be null; separator - the String to search for, may be null
返回:: the substring after the last occurrence of the separator, null if null String input
从以下版本开始:: 2.0

substringBetween

public static String substringBetween(String str,
                      String tag)

Gets the String that is nested in between two instances of the same String.

A null input String returns null. A null tag returns null.

 StrUtils.substringBetween(null, *)            = null
 StrUtils.substringBetween("", "")             = ""
 StrUtils.substringBetween("", "tag")          = null
 StrUtils.substringBetween("tagabctag", null)  = null
 StrUtils.substringBetween("tagabctag", "")    = ""
 StrUtils.substringBetween("tagabctag", "tag") = "abc"

参数:: str - the String containing the substring, may be null; tag - the String before and after the substring, may be null
返回:: the substring, null if no match
从以下版本开始:: 2.0

substringBetween

public static String substringBetween(String str,
                      String open,
                      String close)

Gets the String that is nested in between two Strings. Only the first match is returned.

A null input String returns null. A null open/close returns null (no match). An empty ("") open and close returns an empty string.

 StrUtils.substringBetween("wx[b]yz", "[", "]") = "b"
 StrUtils.substringBetween(null, *, *)          = null
 StrUtils.substringBetween(*, null, *)          = null
 StrUtils.substringBetween(*, *, null)          = null
 StrUtils.substringBetween("", "", "")          = ""
 StrUtils.substringBetween("", "", "]")         = null
 StrUtils.substringBetween("", "[", "]")        = null
 StrUtils.substringBetween("yabcz", "", "")     = ""
 StrUtils.substringBetween("yabcz", "y", "z")   = "abc"
 StrUtils.substringBetween("yabczyabcz", "y", "z")   = "abc"

参数:: str - the String containing the substring, may be null; open - the String before the substring, may be null; close - the String after the substring, may be null
返回:: the substring, null if no match
从以下版本开始:: 2.0

substringsBetween
```
public static String[] substringsBetween(String str,
                         String open,
                         String close)
```
Searches a String for substrings delimited by a start and end tag, returning all matching substrings in an array.

A null input String returns null. A null open/close returns null (no match). An empty ("") open/close returns null (no match).
```
 StrUtils.substringsBetween("[a][b][c]", "[", "]") = ["a","b","c"]
 StrUtils.substringsBetween(null, *, *)            = null
 StrUtils.substringsBetween(*, null, *)            = null
 StrUtils.substringsBetween(*, *, null)            = null
 StrUtils.substringsBetween("", "[", "]")          = []
 
```
参数:
str - the String containing the substrings, null returns null, empty returns empty
open - the String identifying the start of the substring, empty returns null
close - the String identifying the end of the substring, empty returns null

返回:
a String Array of substrings, or null if no match
从以下版本开始:

2.3

getNestedString

public static String getNestedString(String str,
                     String tag)

已过时。 Use the better named substringBetween(String, String). Method will be removed in Commons Lang 3.0.

Gets the String that is nested in between two instances of the same String.

A null input String returns null. A null tag returns null.

 StrUtils.getNestedString(null, *)            = null
 StrUtils.getNestedString("", "")             = ""
 StrUtils.getNestedString("", "tag")          = null
 StrUtils.getNestedString("tagabctag", null)  = null
 StrUtils.getNestedString("tagabctag", "")    = ""
 StrUtils.getNestedString("tagabctag", "tag") = "abc"

参数:: str - the String containing nested-string, may be null; tag - the String before and after nested-string, may be null
返回:: the nested String, null if no match

getNestedString

public static String getNestedString(String str,
                     String open,
                     String close)

已过时。 Use the better named substringBetween(String, String, String). Method will be removed in Commons Lang 3.0.

Gets the String that is nested in between two Strings. Only the first match is returned.

A null input String returns null. A null open/close returns null (no match). An empty ("") open/close returns an empty string.

 StrUtils.getNestedString(null, *, *)          = null
 StrUtils.getNestedString("", "", "")          = ""
 StrUtils.getNestedString("", "", "tag")       = null
 StrUtils.getNestedString("", "tag", "tag")    = null
 StrUtils.getNestedString("yabcz", null, null) = null
 StrUtils.getNestedString("yabcz", "", "")     = ""
 StrUtils.getNestedString("yabcz", "y", "z")   = "abc"
 StrUtils.getNestedString("yabczyabcz", "y", "z")   = "abc"

参数:: str - the String containing nested-string, may be null; open - the String before nested-string, may be null; close - the String after nested-string, may be null
返回:: the nested String, null if no match

split
```
public static String[] split(String str)
```
Splits the provided text into an array, using whitespace as the separator. Whitespace is defined by Character.isWhitespace(char).

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.

A null input String returns null.
```
 StrUtils.split(null)       = null
 StrUtils.split("")         = []
 StrUtils.split("abc def")  = ["abc", "def"]
 StrUtils.split("abc  def") = ["abc", "def"]
 StrUtils.split(" abc ")    = ["abc"]
 
```
参数:
str - the String to parse, may be null

返回:
an array of parsed Strings, null if null String input

split
```
public static String[] split(String str,
             char separatorChar)
```
Splits the provided text into an array, separator specified. This is an alternative to using StringTokenizer.

The separator is not included in the returned String array. Adjacent separators are treated as one separator. For more control over the split use the StrTokenizer class.

A null input String returns null.
```
 StrUtils.split(null, *)         = null
 StrUtils.split("", *)           = []
 StrUtils.split("a.b.c", '.')    = ["a", "b", "c"]
 StrUtils.split("a..b.c", '.')   = ["a", "b", "c"]
 StrUtils.split("a:b:c", '.')    = ["a:b:c"]
 StrUtils.split("a b c", ' ')    = ["a", "b", "c"]
 
```
参数:
str - the String to parse, may be null
separatorChar - the character used as the delimiter

返回:
an array of parsed Strings, null if null String input
从以下版本开始:

2.0

split
```
public static String[] split(String str,
             String separatorChars)
```
Splits the provided text into an array, separators specified. This is an alternative to using StringTokenizer.

The separator is not included in the returned String array. Adjacent separators are treated as one separator. For more control over the split use the StrTokenizer class.

A null input String returns null. A null separatorChars splits on whitespace.
```
 StrUtils.split(null, *)         = null
 StrUtils.split("", *)           = []
 StrUtils.split("abc def", null) = ["abc", "def"]
 StrUtils.split("abc def", " ")  = ["abc", "def"]
 StrUtils.split("abc  def", " ") = ["abc", "def"]
 StrUtils.split("ab:cd:ef", ":") = ["ab", "cd", "ef"]
 
```
参数:
str - the String to parse, may be null
separatorChars - the characters used as the delimiters, null splits on whitespace

返回:
an array of parsed Strings, null if null String input

split
```
public static String[] split(String str,
             String separatorChars,
             int max)
```
Splits the provided text into an array with a maximum length, separators specified.

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

A null input String returns null. A null separatorChars splits on whitespace.

If more than max delimited substrings are found, the last returned string includes all characters after the first max - 1 returned strings (including separator characters).
```
 StrUtils.split(null, *, *)            = null
 StrUtils.split("", *, *)              = []
 StrUtils.split("ab de fg", null, 0)   = ["ab", "cd", "ef"]
 StrUtils.split("ab   de fg", null, 0) = ["ab", "cd", "ef"]
 StrUtils.split("ab:cd:ef", ":", 0)    = ["ab", "cd", "ef"]
 StrUtils.split("ab:cd:ef", ":", 2)    = ["ab", "cd:ef"]
 
```
参数:
str - the String to parse, may be null
separatorChars - the characters used as the delimiters, null splits on whitespace
max - the maximum number of elements to include in the array. A zero or negative value implies no limit

返回:
an array of parsed Strings, null if null String input

splitByWholeSeparator

public static String[] splitByWholeSeparator(String str,
                             String separator)

Splits the provided text into an array, separator string specified.

The separator(s) will not be included in the returned String array. Adjacent separators are treated as one separator.

A null input String returns null. A null separator splits on whitespace.

 StrUtils.splitByWholeSeparator(null, *)               = null
 StrUtils.splitByWholeSeparator("", *)                 = []
 StrUtils.splitByWholeSeparator("ab de fg", null)      = ["ab", "de", "fg"]
 StrUtils.splitByWholeSeparator("ab   de fg", null)    = ["ab", "de", "fg"]
 StrUtils.splitByWholeSeparator("ab:cd:ef", ":")       = ["ab", "cd", "ef"]
 StrUtils.splitByWholeSeparator("ab-!-cd-!-ef", "-!-") = ["ab", "cd", "ef"]

参数:: str - the String to parse, may be null; separator - String containing the String to be used as a delimiter, null splits on whitespace
返回:: an array of parsed Strings, null if null String was input

splitByWholeSeparator

public static String[] splitByWholeSeparator(String str,
                             String separator,
                             int max)

Splits the provided text into an array, separator string specified. Returns a maximum of max substrings.

The separator(s) will not be included in the returned String array. Adjacent separators are treated as one separator.

A null input String returns null. A null separator splits on whitespace.

 StrUtils.splitByWholeSeparator(null, *, *)               = null
 StrUtils.splitByWholeSeparator("", *, *)                 = []
 StrUtils.splitByWholeSeparator("ab de fg", null, 0)      = ["ab", "de", "fg"]
 StrUtils.splitByWholeSeparator("ab   de fg", null, 0)    = ["ab", "de", "fg"]
 StrUtils.splitByWholeSeparator("ab:cd:ef", ":", 2)       = ["ab", "cd:ef"]
 StrUtils.splitByWholeSeparator("ab-!-cd-!-ef", "-!-", 5) = ["ab", "cd", "ef"]
 StrUtils.splitByWholeSeparator("ab-!-cd-!-ef", "-!-", 2) = ["ab", "cd-!-ef"]

参数:: str - the String to parse, may be null; separator - String containing the String to be used as a delimiter, null splits on whitespace; max - the maximum number of elements to include in the returned array. A zero or negative value implies no limit.
返回:: an array of parsed Strings, null if null String was input

splitByWholeSeparatorPreserveAllTokens

public static String[] splitByWholeSeparatorPreserveAllTokens(String str,
                                              String separator)

Splits the provided text into an array, separator string specified.

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.

A null input String returns null. A null separator splits on whitespace.

 StrUtils.splitByWholeSeparatorPreserveAllTokens(null, *)               = null
 StrUtils.splitByWholeSeparatorPreserveAllTokens("", *)                 = []
 StrUtils.splitByWholeSeparatorPreserveAllTokens("ab de fg", null)      = ["ab", "de", "fg"]
 StrUtils.splitByWholeSeparatorPreserveAllTokens("ab   de fg", null)    = ["ab", "", "", "de", "fg"]
 StrUtils.splitByWholeSeparatorPreserveAllTokens("ab:cd:ef", ":")       = ["ab", "cd", "ef"]
 StrUtils.splitByWholeSeparatorPreserveAllTokens("ab-!-cd-!-ef", "-!-") = ["ab", "cd", "ef"]

参数:: str - the String to parse, may be null; separator - String containing the String to be used as a delimiter, null splits on whitespace
返回:: an array of parsed Strings, null if null String was input
从以下版本开始:: 2.4

splitByWholeSeparatorPreserveAllTokens

public static String[] splitByWholeSeparatorPreserveAllTokens(String str,
                                              String separator,
                                              int max)

Splits the provided text into an array, separator string specified. Returns a maximum of max substrings.

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.

A null input String returns null. A null separator splits on whitespace.

 StrUtils.splitByWholeSeparatorPreserveAllTokens(null, *, *)               = null
 StrUtils.splitByWholeSeparatorPreserveAllTokens("", *, *)                 = []
 StrUtils.splitByWholeSeparatorPreserveAllTokens("ab de fg", null, 0)      = ["ab", "de", "fg"]
 StrUtils.splitByWholeSeparatorPreserveAllTokens("ab   de fg", null, 0)    = ["ab", "", "", "de", "fg"]
 StrUtils.splitByWholeSeparatorPreserveAllTokens("ab:cd:ef", ":", 2)       = ["ab", "cd:ef"]
 StrUtils.splitByWholeSeparatorPreserveAllTokens("ab-!-cd-!-ef", "-!-", 5) = ["ab", "cd", "ef"]
 StrUtils.splitByWholeSeparatorPreserveAllTokens("ab-!-cd-!-ef", "-!-", 2) = ["ab", "cd-!-ef"]

参数:: str - the String to parse, may be null; separator - String containing the String to be used as a delimiter, null splits on whitespace; max - the maximum number of elements to include in the returned array. A zero or negative value implies no limit.
返回:: an array of parsed Strings, null if null String was input
从以下版本开始:: 2.4

splitPreserveAllTokens
```
public static String[] splitPreserveAllTokens(String str)
```
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 Character.isWhitespace(char).

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.

A null input String returns null.
```
 StrUtils.splitPreserveAllTokens(null)       = null
 StrUtils.splitPreserveAllTokens("")         = []
 StrUtils.splitPreserveAllTokens("abc def")  = ["abc", "def"]
 StrUtils.splitPreserveAllTokens("abc  def") = ["abc", "", "def"]
 StrUtils.splitPreserveAllTokens(" abc ")    = ["", "abc", ""]
 
```
参数:
str - the String to parse, may be null

返回:
an array of parsed Strings, null if null String input
从以下版本开始:

2.1

splitPreserveAllTokens

public static String[] splitPreserveAllTokens(String str,
                              char separatorChar)

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.

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.

A null input String returns null.

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

参数:: str - the String to parse, may be null; separatorChar - the character used as the delimiter, null splits on whitespace
返回:: an array of parsed Strings, null if null String input
从以下版本开始:: 2.1

splitPreserveAllTokens

public static String[] splitPreserveAllTokens(String str,
                              String separatorChars)

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.

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.

A null input String returns null. A null separatorChars splits on whitespace.

 StrUtils.splitPreserveAllTokens(null, *)           = null
 StrUtils.splitPreserveAllTokens("", *)             = []
 StrUtils.splitPreserveAllTokens("abc def", null)   = ["abc", "def"]
 StrUtils.splitPreserveAllTokens("abc def", " ")    = ["abc", "def"]
 StrUtils.splitPreserveAllTokens("abc  def", " ")   = ["abc", "", def"]
 StrUtils.splitPreserveAllTokens("ab:cd:ef", ":")   = ["ab", "cd", "ef"]
 StrUtils.splitPreserveAllTokens("ab:cd:ef:", ":")  = ["ab", "cd", "ef", ""]
 StrUtils.splitPreserveAllTokens("ab:cd:ef::", ":") = ["ab", "cd", "ef", "", ""]
 StrUtils.splitPreserveAllTokens("ab::cd:ef", ":")  = ["ab", "", cd", "ef"]
 StrUtils.splitPreserveAllTokens(":cd:ef", ":")     = ["", cd", "ef"]
 StrUtils.splitPreserveAllTokens("::cd:ef", ":")    = ["", "", cd", "ef"]
 StrUtils.splitPreserveAllTokens(":cd:ef:", ":")    = ["", cd", "ef", ""]

参数:: str - the String to parse, may be null; separatorChars - the characters used as the delimiters, null splits on whitespace
返回:: an array of parsed Strings, null if null String input
从以下版本开始:: 2.1

splitPreserveAllTokens
```
public static String[] splitPreserveAllTokens(String str,
                              String separatorChars,
                              int max)
```
Splits the provided text into an array with a maximum length, separators specified, preserving all tokens, including empty tokens created by adjacent separators.

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.

A null input String returns null. A null separatorChars splits on whitespace.

If more than max delimited substrings are found, the last returned string includes all characters after the first max - 1 returned strings (including separator characters).
```
 StrUtils.splitPreserveAllTokens(null, *, *)            = null
 StrUtils.splitPreserveAllTokens("", *, *)              = []
 StrUtils.splitPreserveAllTokens("ab de fg", null, 0)   = ["ab", "cd", "ef"]
 StrUtils.splitPreserveAllTokens("ab   de fg", null, 0) = ["ab", "cd", "ef"]
 StrUtils.splitPreserveAllTokens("ab:cd:ef", ":", 0)    = ["ab", "cd", "ef"]
 StrUtils.splitPreserveAllTokens("ab:cd:ef", ":", 2)    = ["ab", "cd:ef"]
 StrUtils.splitPreserveAllTokens("ab   de fg", null, 2) = ["ab", "  de fg"]
 StrUtils.splitPreserveAllTokens("ab   de fg", null, 3) = ["ab", "", " de fg"]
 StrUtils.splitPreserveAllTokens("ab   de fg", null, 4) = ["ab", "", "", "de fg"]
 
```
参数:
str - the String to parse, may be null
separatorChars - the characters used as the delimiters, null splits on whitespace
max - the maximum number of elements to include in the array. A zero or negative value implies no limit

返回:
an array of parsed Strings, null if null String input
从以下版本开始:

2.1

splitByCharacterType

public static String[] splitByCharacterType(String str)

Splits a String by Character type as returned by java.lang.Character.getType(char). Groups of contiguous characters of the same type are returned as complete tokens.

 StrUtils.splitByCharacterType(null)         = null
 StrUtils.splitByCharacterType("")           = []
 StrUtils.splitByCharacterType("ab de fg")   = ["ab", " ", "de", " ", "fg"]
 StrUtils.splitByCharacterType("ab   de fg") = ["ab", "   ", "de", " ", "fg"]
 StrUtils.splitByCharacterType("ab:cd:ef")   = ["ab", ":", "cd", ":", "ef"]
 StrUtils.splitByCharacterType("number5")    = ["number", "5"]
 StrUtils.splitByCharacterType("fooBar")     = ["foo", "B", "ar"]
 StrUtils.splitByCharacterType("foo200Bar")  = ["foo", "200", "B", "ar"]
 StrUtils.splitByCharacterType("ASFRules")   = ["ASFR", "ules"]

参数:: str - the String to split, may be null
返回:: an array of parsed Strings, null if null String input
从以下版本开始:: 2.4

splitByCharacterTypeCamelCase

public static String[] splitByCharacterTypeCamelCase(String str)

Splits a String by Character type as returned by 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 Character.UPPERCASE_LETTER, if any, immediately preceding a token of type Character.LOWERCASE_LETTER will belong to the following token rather than to the preceding, if any, Character.UPPERCASE_LETTER token.

 StrUtils.splitByCharacterTypeCamelCase(null)         = null
 StrUtils.splitByCharacterTypeCamelCase("")           = []
 StrUtils.splitByCharacterTypeCamelCase("ab de fg")   = ["ab", " ", "de", " ", "fg"]
 StrUtils.splitByCharacterTypeCamelCase("ab   de fg") = ["ab", "   ", "de", " ", "fg"]
 StrUtils.splitByCharacterTypeCamelCase("ab:cd:ef")   = ["ab", ":", "cd", ":", "ef"]
 StrUtils.splitByCharacterTypeCamelCase("number5")    = ["number", "5"]
 StrUtils.splitByCharacterTypeCamelCase("fooBar")     = ["foo", "Bar"]
 StrUtils.splitByCharacterTypeCamelCase("foo200Bar")  = ["foo", "200", "Bar"]
 StrUtils.splitByCharacterTypeCamelCase("ASFRules")   = ["ASF", "Rules"]

参数:: str - the String to split, may be null
返回:: an array of parsed Strings, null if null String input
从以下版本开始:: 2.4

concatenate
```
public static String concatenate(Object[] array)
```
已过时。 Use the better named join(Object[]) instead. Method will be removed in Commons Lang 3.0.
Concatenates elements of an array into a single String. Null objects or empty strings within the array are represented by empty strings.
```
 StrUtils.concatenate(null)            = null
 StrUtils.concatenate([])              = ""
 StrUtils.concatenate([null])          = ""
 StrUtils.concatenate(["a", "b", "c"]) = "abc"
 StrUtils.concatenate([null, "", "a"]) = "a"
 
```
参数:
array - the array of values to concatenate, may be null

返回:
the concatenated String, null if null array input

join
```
public static String join(Object[] array)
```
Joins the elements of the provided array into a single String containing the provided list of elements.

No separator is added to the joined String. Null objects or empty strings within the array are represented by empty strings.
```
 StrUtils.join(null)            = null
 StrUtils.join([])              = ""
 StrUtils.join([null])          = ""
 StrUtils.join(["a", "b", "c"]) = "abc"
 StrUtils.join([null, "", "a"]) = "a"
 
```
参数:
array - the array of values to join together, may be null

返回:
the joined String, null if null array input
从以下版本开始:

2.0

join
```
public static String join(Object[] array,
          char separator)
```
Joins the elements of the provided array into a single String containing the provided list of elements.

No delimiter is added before or after the list. Null objects or empty strings within the array are represented by empty strings.
```
 StrUtils.join(null, *)               = null
 StrUtils.join([], *)                 = ""
 StrUtils.join([null], *)             = ""
 StrUtils.join(["a", "b", "c"], ';')  = "a;b;c"
 StrUtils.join(["a", "b", "c"], null) = "abc"
 StrUtils.join([null, "", "a"], ';')  = ";;a"
 
```
参数:
array - the array of values to join together, may be null
separator - the separator character to use

返回:
the joined String, null if null array input
从以下版本开始:

2.0

join
```
public static String join(Object[] array,
          char separator,
          int startIndex,
          int endIndex)
```
Joins the elements of the provided array into a single String containing the provided list of elements.

No delimiter is added before or after the list. Null objects or empty strings within the array are represented by empty strings.
```
 StrUtils.join(null, *)               = null
 StrUtils.join([], *)                 = ""
 StrUtils.join([null], *)             = ""
 StrUtils.join(["a", "b", "c"], ';')  = "a;b;c"
 StrUtils.join(["a", "b", "c"], null) = "abc"
 StrUtils.join([null, "", "a"], ';')  = ";;a"
 
```
参数:
array - the array of values to join together, may be null
separator - the separator character to use
startIndex - the first index to start joining from. It is an error to pass in an end index past the end of the array
endIndex - the index to stop joining from (exclusive). It is an error to pass in an end index past the end of the array

返回:
the joined String, null if null array input
从以下版本开始:

2.0

join
```
public static String join(Object[] array,
          String separator)
```
Joins the elements of the provided array into a single String containing the provided list of elements.

No delimiter is added before or after the list. A null separator is the same as an empty String (""). Null objects or empty strings within the array are represented by empty strings.
```
 StrUtils.join(null, *)                = null
 StrUtils.join([], *)                  = ""
 StrUtils.join([null], *)              = ""
 StrUtils.join(["a", "b", "c"], "--")  = "a--b--c"
 StrUtils.join(["a", "b", "c"], null)  = "abc"
 StrUtils.join(["a", "b", "c"], "")    = "abc"
 StrUtils.join([null, "", "a"], ',')   = ",,a"
 
```
参数:
array - the array of values to join together, may be null
separator - the separator character to use, null treated as ""

返回:
the joined String, null if null array input

join
```
public static String join(Object[] array,
          String separator,
          int startIndex,
          int endIndex)
```
Joins the elements of the provided array into a single String containing the provided list of elements.

No delimiter is added before or after the list. A null separator is the same as an empty String (""). Null objects or empty strings within the array are represented by empty strings.
```
 StrUtils.join(null, *)                = null
 StrUtils.join([], *)                  = ""
 StrUtils.join([null], *)              = ""
 StrUtils.join(["a", "b", "c"], "--")  = "a--b--c"
 StrUtils.join(["a", "b", "c"], null)  = "abc"
 StrUtils.join(["a", "b", "c"], "")    = "abc"
 StrUtils.join([null, "", "a"], ',')   = ",,a"
 
```
参数:
array - the array of values to join together, may be null
separator - the separator character to use, null treated as ""
startIndex - the first index to start joining from. It is an error to pass in an end index past the end of the array
endIndex - the index to stop joining from (exclusive). It is an error to pass in an end index past the end of the array

返回:
the joined String, null if null array input

deleteWhitespace

public static String deleteWhitespace(String str)

Deletes all whitespaces from a String as defined by Character.isWhitespace(char).

 StrUtils.deleteWhitespace(null)         = null
 StrUtils.deleteWhitespace("")           = ""
 StrUtils.deleteWhitespace("abc")        = "abc"
 StrUtils.deleteWhitespace("   ab  c  ") = "abc"

参数:: str - the String to delete whitespace from, may be null
返回:: the String without whitespaces, null if null String input

removeStart

public static String removeStart(String str,
                 String remove)

Removes a substring only if it is at the begining of a source string, otherwise returns the source string.

A null source string will return null. An empty ("") source string will return the empty string. A null search string will return the source string.

 StrUtils.removeStart(null, *)      = null
 StrUtils.removeStart("", *)        = ""
 StrUtils.removeStart(*, null)      = *
 StrUtils.removeStart("www.domain.com", "www.")   = "domain.com"
 StrUtils.removeStart("domain.com", "www.")       = "domain.com"
 StrUtils.removeStart("www.domain.com", "domain") = "www.domain.com"
 StrUtils.removeStart("abc", "")    = "abc"

参数:: str - the source String to search, may be null; remove - the String to search for and remove, may be null
返回:: the substring with the string removed if found, null if null String input
从以下版本开始:: 2.1

removeStartIgnoreCase

public static String removeStartIgnoreCase(String str,
                           String remove)

Case insensitive removal of a substring if it is at the begining of a source string, otherwise returns the source string.

A null source string will return null. An empty ("") source string will return the empty string. A null search string will return the source string.

 StrUtils.removeStartIgnoreCase(null, *)      = null
 StrUtils.removeStartIgnoreCase("", *)        = ""
 StrUtils.removeStartIgnoreCase(*, null)      = *
 StrUtils.removeStartIgnoreCase("www.domain.com", "www.")   = "domain.com"
 StrUtils.removeStartIgnoreCase("www.domain.com", "WWW.")   = "domain.com"
 StrUtils.removeStartIgnoreCase("domain.com", "www.")       = "domain.com"
 StrUtils.removeStartIgnoreCase("www.domain.com", "domain") = "www.domain.com"
 StrUtils.removeStartIgnoreCase("abc", "")    = "abc"

参数:: str - the source String to search, may be null; remove - the String to search for (case insensitive) and remove, may be null
返回:: the substring with the string removed if found, null if null String input
从以下版本开始:: 2.4

removeEnd
```
public static String removeEnd(String str,
               String remove)
```
Removes a substring only if it is at the end of a source string, otherwise returns the source string.

A null source string will return null. An empty ("") source string will return the empty string. A null search string will return the source string.
```
 StrUtils.removeEnd(null, *)      = null
 StrUtils.removeEnd("", *)        = ""
 StrUtils.removeEnd(*, null)      = *
 StrUtils.removeEnd("www.domain.com", ".com.")  = "www.domain.com"
 StrUtils.removeEnd("www.domain.com", ".com")   = "www.domain"
 StrUtils.removeEnd("www.domain.com", "domain") = "www.domain.com"
 StrUtils.removeEnd("abc", "")    = "abc"
 
```
参数:
str - the source String to search, may be null
remove - the String to search for and remove, may be null

返回:
the substring with the string removed if found, null if null String input
从以下版本开始:

2.1

removeEndIgnoreCase
```
public static String removeEndIgnoreCase(String str,
                         String remove)
```
Case insensitive removal of a substring if it is at the end of a source string, otherwise returns the source string.

A null source string will return null. An empty ("") source string will return the empty string. A null search string will return the source string.
```
 StrUtils.removeEnd(null, *)      = null
 StrUtils.removeEnd("", *)        = ""
 StrUtils.removeEnd(*, null)      = *
 StrUtils.removeEnd("www.domain.com", ".com.")  = "www.domain.com."
 StrUtils.removeEnd("www.domain.com", ".com")   = "www.domain"
 StrUtils.removeEnd("www.domain.com", "domain") = "www.domain.com"
 StrUtils.removeEnd("abc", "")    = "abc"
 
```
参数:
str - the source String to search, may be null
remove - the String to search for (case insensitive) and remove, may be null

返回:
the substring with the string removed if found, null if null String input
从以下版本开始:

2.4

remove
```
public static String remove(String str,
            String remove)
```
Removes all occurrences of a substring from within the source string.

A null source string will return null. An empty ("") source string will return the empty string. A null remove string will return the source string. An empty ("") remove string will return the source string.
```
 StrUtils.remove(null, *)        = null
 StrUtils.remove("", *)          = ""
 StrUtils.remove(*, null)        = *
 StrUtils.remove(*, "")          = *
 StrUtils.remove("queued", "ue") = "qd"
 StrUtils.remove("queued", "zz") = "queued"
 
```
参数:
str - the source String to search, may be null
remove - the String to search for and remove, may be null

返回:
the substring with the string removed if found, null if null String input
从以下版本开始:

2.1

remove
```
public static String remove(String str,
            char remove)
```
Removes all occurrences of a character from within the source string.

A null source string will return null. An empty ("") source string will return the empty string.
```
 StrUtils.remove(null, *)       = null
 StrUtils.remove("", *)         = ""
 StrUtils.remove("queued", 'u') = "qeed"
 StrUtils.remove("queued", 'z') = "queued"
 
```
参数:
str - the source String to search, may be null
remove - the char to search for and remove, may be null

返回:
the substring with the char removed if found, null if null String input
从以下版本开始:

2.1

replaceOnce

public static String replaceOnce(String text,
                 String searchString,
                 String replacement)

Replaces a String with another String inside a larger String, once.

A null reference passed to this method is a no-op.

 StrUtils.replaceOnce(null, *, *)        = null
 StrUtils.replaceOnce("", *, *)          = ""
 StrUtils.replaceOnce("any", null, *)    = "any"
 StrUtils.replaceOnce("any", *, null)    = "any"
 StrUtils.replaceOnce("any", "", *)      = "any"
 StrUtils.replaceOnce("aba", "a", null)  = "aba"
 StrUtils.replaceOnce("aba", "a", "")    = "ba"
 StrUtils.replaceOnce("aba", "a", "z")   = "zba"

参数:: text - text to search and replace in, may be null; searchString - the String to search for, may be null; replacement - the String to replace with, may be null
返回:: the text with any replacements processed, null if null String input
另请参阅:: replace(String text, String searchString, String replacement, int max)

replace

public static String replace(String text,
             String searchString,
             String replacement)

Replaces all occurrences of a String within another String.

A null reference passed to this method is a no-op.

 StrUtils.replace(null, *, *)        = null
 StrUtils.replace("", *, *)          = ""
 StrUtils.replace("any", null, *)    = "any"
 StrUtils.replace("any", *, null)    = "any"
 StrUtils.replace("any", "", *)      = "any"
 StrUtils.replace("aba", "a", null)  = "aba"
 StrUtils.replace("aba", "a", "")    = "b"
 StrUtils.replace("aba", "a", "z")   = "zbz"

参数:: text - text to search and replace in, may be null; searchString - the String to search for, may be null; replacement - the String to replace it with, may be null
返回:: the text with any replacements processed, null if null String input
另请参阅:: replace(String text, String searchString, String replacement, int max)

replace

public static String replace(String text,
             String searchString,
             String replacement,
             int max)

Replaces a String with another String inside a larger String, for the first max values of the search String.

A null reference passed to this method is a no-op.

 StrUtils.replace(null, *, *, *)         = null
 StrUtils.replace("", *, *, *)           = ""
 StrUtils.replace("any", null, *, *)     = "any"
 StrUtils.replace("any", *, null, *)     = "any"
 StrUtils.replace("any", "", *, *)       = "any"
 StrUtils.replace("any", *, *, 0)        = "any"
 StrUtils.replace("abaa", "a", null, -1) = "abaa"
 StrUtils.replace("abaa", "a", "", -1)   = "b"
 StrUtils.replace("abaa", "a", "z", 0)   = "abaa"
 StrUtils.replace("abaa", "a", "z", 1)   = "zbaa"
 StrUtils.replace("abaa", "a", "z", 2)   = "zbza"
 StrUtils.replace("abaa", "a", "z", -1)  = "zbzz"

参数:: text - text to search and replace in, may be null; searchString - the String to search for, may be null; replacement - the String to replace it with, may be null; max - maximum number of values to replace, or -1 if no maximum
返回:: the text with any replacements processed, null if null String input

replaceEach

public static String replaceEach(String text,
                 String[] searchList,
                 String[] replacementList)

Replaces all occurrences of Strings within another String.

A 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.

  StrUtils.replaceEach(null, *, *)        = null
  StrUtils.replaceEach("", *, *)          = ""
  StrUtils.replaceEach("aba", null, null) = "aba"
  StrUtils.replaceEach("aba", new String[0], null) = "aba"
  StrUtils.replaceEach("aba", null, new String[0]) = "aba"
  StrUtils.replaceEach("aba", new String[]{"a"}, null)  = "aba"
  StrUtils.replaceEach("aba", new String[]{"a"}, new String[]{""})  = "b"
  StrUtils.replaceEach("aba", new String[]{null}, new String[]{"a"})  = "aba"
  StrUtils.replaceEach("abcde", new String[]{"ab", "d"}, new String[]{"w", "t"})  = "wcte"
  (example of how it does not repeat)
  StrUtils.replaceEach("abcde", new String[]{"ab", "d"}, new String[]{"d", "t"})  = "dcte"

参数:: text - text to search and replace in, no-op if null; searchList - the Strings to search for, no-op if null; replacementList - the Strings to replace them with, no-op if null
返回:: the text with any replacements processed, null if null String input
抛出:: IndexOutOfBoundsException - if the lengths of the arrays are not the same (null is ok, and/or size 0)
从以下版本开始:: 2.4

replaceEachRepeatedly

public static String replaceEachRepeatedly(String text,
                           String[] searchList,
                           String[] replacementList)

Replaces all occurrences of Strings within another String.

  StrUtils.replaceEach(null, *, *, *) = null
  StrUtils.replaceEach("", *, *, *) = ""
  StrUtils.replaceEach("aba", null, null, *) = "aba"
  StrUtils.replaceEach("aba", new String[0], null, *) = "aba"
  StrUtils.replaceEach("aba", null, new String[0], *) = "aba"
  StrUtils.replaceEach("aba", new String[]{"a"}, null, *) = "aba"
  StrUtils.replaceEach("aba", new String[]{"a"}, new String[]{""}, *) = "b"
  StrUtils.replaceEach("aba", new String[]{null}, new String[]{"a"}, *) = "aba"
  StrUtils.replaceEach("abcde", new String[]{"ab", "d"}, new String[]{"w", "t"}, *) = "wcte"
  (example of how it repeats)
  StrUtils.replaceEach("abcde", new String[]{"ab", "d"}, new String[]{"d", "t"}, false) = "dcte"
  StrUtils.replaceEach("abcde", new String[]{"ab", "d"}, new String[]{"d", "t"}, true) = "tcte"
  StrUtils.replaceEach("abcde", new String[]{"ab", "d"}, new String[]{"d", "ab"}, true) = IllegalArgumentException
  StrUtils.replaceEach("abcde", new String[]{"ab", "d"}, new String[]{"d", "ab"}, false) = "dcabe"

参数:: text - text to search and replace in, no-op if null; searchList - the Strings to search for, no-op if null; replacementList - the Strings to replace them with, no-op if null
返回:: the text with any replacements processed, null if null String input
抛出:: IllegalArgumentException - if the search is repeating and there is an endless loop due to outputs of one being inputs to another; IndexOutOfBoundsException - if the lengths of the arrays are not the same (null is ok, and/or size 0)
从以下版本开始:: 2.4

replaceChars
```
public static String replaceChars(String str,
                  char searchChar,
                  char replaceChar)
```
Replaces all occurrences of a character in a String with another. This is a null-safe version of String.replace(char, char).

A null string input returns null. An empty ("") string input returns an empty string.
```
 StrUtils.replaceChars(null, *, *)        = null
 StrUtils.replaceChars("", *, *)          = ""
 StrUtils.replaceChars("abcba", 'b', 'y') = "aycya"
 StrUtils.replaceChars("abcba", 'z', 'y') = "abcba"
 
```
参数:
str - String to replace characters in, may be null
searchChar - the character to search for, may be null
replaceChar - the character to replace, may be null

返回:
modified String, null if null string input
从以下版本开始:

2.0

replaceChars
```
public static String replaceChars(String str,
                  String searchChars,
                  String replaceChars)
```
Replaces multiple characters in a String in one go. This method can also be used to delete characters.

For example:
replaceChars("hello", "ho", "jy") = jelly.

A null string input returns null. An empty ("") string input returns an empty string. A null or empty set of search characters returns the input string.

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.
```
 StrUtils.replaceChars(null, *, *)           = null
 StrUtils.replaceChars("", *, *)             = ""
 StrUtils.replaceChars("abc", null, *)       = "abc"
 StrUtils.replaceChars("abc", "", *)         = "abc"
 StrUtils.replaceChars("abc", "b", null)     = "ac"
 StrUtils.replaceChars("abc", "b", "")       = "ac"
 StrUtils.replaceChars("abcba", "bc", "yz")  = "ayzya"
 StrUtils.replaceChars("abcba", "bc", "y")   = "ayya"
 StrUtils.replaceChars("abcba", "bc", "yzx") = "ayzya"
 
```
参数:
str - String to replace characters in, may be null
searchChars - a set of characters to search for, may be null
replaceChars - a set of characters to replace, may be null

返回:
modified String, null if null string input
从以下版本开始:

2.0

overlayString

public static String overlayString(String text,
                   String overlay,
                   int start,
                   int end)

已过时。 Use better named overlay(String, String, int, int) instead. Method will be removed in Commons Lang 3.0.

Overlays part of a String with another String.

 StrUtils.overlayString(null, *, *, *)           = NullPointerException
 StrUtils.overlayString(*, null, *, *)           = NullPointerException
 StrUtils.overlayString("", "abc", 0, 0)         = "abc"
 StrUtils.overlayString("abcdef", null, 2, 4)    = "abef"
 StrUtils.overlayString("abcdef", "", 2, 4)      = "abef"
 StrUtils.overlayString("abcdef", "zzzz", 2, 4)  = "abzzzzef"
 StrUtils.overlayString("abcdef", "zzzz", 4, 2)  = "abcdzzzzcdef"
 StrUtils.overlayString("abcdef", "zzzz", -1, 4) = IndexOutOfBoundsException
 StrUtils.overlayString("abcdef", "zzzz", 2, 8)  = IndexOutOfBoundsException

参数:: text - the String to do overlaying in, may be null; overlay - the String to overlay, may be null; start - the position to start overlaying at, must be valid; end - the position to stop overlaying before, must be valid
返回:: overlayed String, null if null String input
抛出:: NullPointerException - if text or overlay is null; IndexOutOfBoundsException - if either position is invalid

overlay

public static String overlay(String str,
             String overlay,
             int start,
             int end)

Overlays part of a String with another String.

A null string input returns 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.

 StrUtils.overlay(null, *, *, *)            = null
 StrUtils.overlay("", "abc", 0, 0)          = "abc"
 StrUtils.overlay("abcdef", null, 2, 4)     = "abef"
 StrUtils.overlay("abcdef", "", 2, 4)       = "abef"
 StrUtils.overlay("abcdef", "", 4, 2)       = "abef"
 StrUtils.overlay("abcdef", "zzzz", 2, 4)   = "abzzzzef"
 StrUtils.overlay("abcdef", "zzzz", 4, 2)   = "abzzzzef"
 StrUtils.overlay("abcdef", "zzzz", -1, 4)  = "zzzzef"
 StrUtils.overlay("abcdef", "zzzz", 2, 8)   = "abzzzz"
 StrUtils.overlay("abcdef", "zzzz", -2, -3) = "zzzzabcdef"
 StrUtils.overlay("abcdef", "zzzz", 8, 10)  = "abcdefzzzz"

参数:: str - the String to do overlaying in, may be null; overlay - the String to overlay, may be null; start - the position to start overlaying at; end - the position to stop overlaying before
返回:: overlayed String, null if null String input
从以下版本开始:: 2.0

chomp

public static String chomp(String str,
           String separator)

Removes separator from the end of str if it's there, otherwise leave it alone.

NOTE: This method changed in version 2.0. It now more closely matches Perl chomp. For the previous behavior, use substringBeforeLast(String, String). This method uses String.endsWith(String).

 StrUtils.chomp(null, *)         = null
 StrUtils.chomp("", *)           = ""
 StrUtils.chomp("foobar", "bar") = "foo"
 StrUtils.chomp("foobar", "baz") = "foobar"
 StrUtils.chomp("foo", "foo")    = ""
 StrUtils.chomp("foo ", "foo")   = "foo "
 StrUtils.chomp(" foo", "foo")   = " "
 StrUtils.chomp("foo", "foooo")  = "foo"
 StrUtils.chomp("foo", "")       = "foo"
 StrUtils.chomp("foo", null)     = "foo"

参数:: str - the String to chomp from, may be null; separator - separator String, may be null
返回:: String without trailing separator, null if null String input

chompLast
```
public static String chompLast(String str,
               String sep)
```
已过时。 Use chomp(String, String) instead. Method will be removed in Commons Lang 3.0.

Remove a value if and only if the String ends with that value.

参数:
str - the String to chomp from, must not be null
sep - the String to chomp, must not be null

返回:
String without chomped ending

抛出:

NullPointerException - if str or sep is null

getChomp
```
public static String getChomp(String str,
              String sep)
```
已过时。 Use substringAfterLast(String, String) instead (although this doesn't include the separator) Method will be removed in Commons Lang 3.0.

Remove everything and return the last value of a supplied String, and everything after it from a String.

参数:
str - the String to chomp from, must not be null
sep - the String to chomp, must not be null

返回:
String chomped

抛出:

NullPointerException - if str or sep is null

prechomp
```
public static String prechomp(String str,
              String sep)
```
已过时。 Use substringAfter(String, String) instead. Method will be removed in Commons Lang 3.0.

Remove the first value of a supplied String, and everything before it from a String.

参数:
str - the String to chomp from, must not be null
sep - the String to chomp, must not be null

返回:
String without chomped beginning

抛出:

NullPointerException - if str or sep is null

getPrechomp
```
public static String getPrechomp(String str,
                 String sep)
```
已过时。 Use substringBefore(String, String) instead (although this doesn't include the separator). Method will be removed in Commons Lang 3.0.

Remove and return everything before the first value of a supplied String from another String.

参数:
str - the String to chomp from, must not be null
sep - the String to chomp, must not be null

返回:
String prechomped

抛出:

NullPointerException - if str or sep is null

repeat

public static String repeat(String str,
            int repeat)

Repeat a String repeat times to form a new String.

 StrUtils.repeat(null, 2) = null
 StrUtils.repeat("", 0)   = ""
 StrUtils.repeat("", 2)   = ""
 StrUtils.repeat("a", 3)  = "aaa"
 StrUtils.repeat("ab", 2) = "abab"
 StrUtils.repeat("a", -2) = ""

参数:: str - the String to repeat, may be null; repeat - number of times to repeat str, negative treated as zero
返回:: a new String consisting of the original String repeated, null if null String input

rightPad

public static String rightPad(String str,
              int size)

Right pad a String with spaces (' ').

The String is padded to the size of size.

 StrUtils.rightPad(null, *)   = null
 StrUtils.rightPad("", 3)     = "   "
 StrUtils.rightPad("bat", 3)  = "bat"
 StrUtils.rightPad("bat", 5)  = "bat  "
 StrUtils.rightPad("bat", 1)  = "bat"
 StrUtils.rightPad("bat", -1) = "bat"

参数:: str - the String to pad out, may be null; size - the size to pad to
返回:: right padded String or original String if no padding is necessary, null if null String input

rightPad

public static String rightPad(String str,
              int size,
              char padChar)

Right pad a String with a specified character.

The String is padded to the size of size.

 StrUtils.rightPad(null, *, *)     = null
 StrUtils.rightPad("", 3, 'z')     = "zzz"
 StrUtils.rightPad("bat", 3, 'z')  = "bat"
 StrUtils.rightPad("bat", 5, 'z')  = "batzz"
 StrUtils.rightPad("bat", 1, 'z')  = "bat"
 StrUtils.rightPad("bat", -1, 'z') = "bat"

参数:: str - the String to pad out, may be null; size - the size to pad to; padChar - the character to pad with
返回:: right padded String or original String if no padding is necessary, null if null String input
从以下版本开始:: 2.0

rightPad

public static String rightPad(String str,
              int size,
              String padStr)

Right pad a String with a specified String.

The String is padded to the size of size.

 StrUtils.rightPad(null, *, *)      = null
 StrUtils.rightPad("", 3, "z")      = "zzz"
 StrUtils.rightPad("bat", 3, "yz")  = "bat"
 StrUtils.rightPad("bat", 5, "yz")  = "batyz"
 StrUtils.rightPad("bat", 8, "yz")  = "batyzyzy"
 StrUtils.rightPad("bat", 1, "yz")  = "bat"
 StrUtils.rightPad("bat", -1, "yz") = "bat"
 StrUtils.rightPad("bat", 5, null)  = "bat  "
 StrUtils.rightPad("bat", 5, "")    = "bat  "

参数:: str - the String to pad out, may be null; size - the size to pad to; padStr - the String to pad with, null or empty treated as single space
返回:: right padded String or original String if no padding is necessary, null if null String input

leftPad

public static String leftPad(String str,
             int size)

Left pad a String with spaces (' ').

The String is padded to the size of size.


 
 
 StrUtils.leftPad(null, *)   = null
 StrUtils.leftPad("", 3)     = "   "
 StrUtils.leftPad("bat", 3)  = "bat"
 StrUtils.leftPad("bat", 5)  = "  bat"
 StrUtils.leftPad("bat", 1)  = "bat"
 StrUtils.leftPad("bat", -1) = "bat"


参数:
str - the String to pad out, may be null
size - the size to pad to
返回:
left padded String or original String if no padding is necessary,
 null if null String input







leftPad
public static String leftPad(String str,
             int size,
             char padChar)
Left pad a String with a specified character.
 
 
Pad to a size of size.
 
 
 StrUtils.leftPad(null, *, *)     = null
 StrUtils.leftPad("", 3, 'z')     = "zzz"
 StrUtils.leftPad("bat", 3, 'z')  = "bat"
 StrUtils.leftPad("bat", 5, 'z')  = "zzbat"
 StrUtils.leftPad("bat", 1, 'z')  = "bat"
 StrUtils.leftPad("bat", -1, 'z') = "bat"
 
参数:
str - the String to pad out, may be null
size - the size to pad to
padChar - the character to pad with
返回:
left padded String or original String if no padding is necessary,
 null if null String input
从以下版本开始:
  2.0







leftPad
public static String leftPad(String str,
             int size,
             String padStr)
Left pad a String with a specified String.
 
 
Pad to a size of size.
 
 
 StrUtils.leftPad(null, *, *)      = null
 StrUtils.leftPad("", 3, "z")      = "zzz"
 StrUtils.leftPad("bat", 3, "yz")  = "bat"
 StrUtils.leftPad("bat", 5, "yz")  = "yzbat"
 StrUtils.leftPad("bat", 8, "yz")  = "yzyzybat"
 StrUtils.leftPad("bat", 1, "yz")  = "bat"
 StrUtils.leftPad("bat", -1, "yz") = "bat"
 StrUtils.leftPad("bat", 5, null)  = "  bat"
 StrUtils.leftPad("bat", 5, "")    = "  bat"
 
参数:
str - the String to pad out, may be null
size - the size to pad to
padStr - the String to pad with, null or empty treated as single space
返回:
left padded String or original String if no padding is necessary,
 null if null String input







length
public static int length(String str)
Gets a String's length or 0 if the String is null.
参数:
str - a String or null
返回:
String length or 0 if the String is null.
从以下版本开始:
  2.4







center
public static String center(String str,
            int size)
Centers a String in a larger String of size size
 using the space character (' ').

 

 
If the size is less than the String length, the String is returned.
 A null String returns null.
 A negative size is treated as zero.
 
 
Equivalent to center(str, size, " ").
 
 
 StrUtils.center(null, *)   = null
 StrUtils.center("", 4)     = "    "
 StrUtils.center("ab", -1)  = "ab"
 StrUtils.center("ab", 4)   = " ab "
 StrUtils.center("abcd", 2) = "abcd"
 StrUtils.center("a", 4)    = " a  "
 
参数:
str - the String to center, may be null
size - the int size of new String, negative treated as zero
返回:
centered String, null if null String input







center
public static String center(String str,
            int size,
            char padChar)
Centers a String in a larger String of size size.
 Uses a supplied character as the value to pad the String with.
 
 
If the size is less than the String length, the String is returned.
 A null String returns null.
 A negative size is treated as zero.
 
 
 StrUtils.center(null, *, *)     = null
 StrUtils.center("", 4, ' ')     = "    "
 StrUtils.center("ab", -1, ' ')  = "ab"
 StrUtils.center("ab", 4, ' ')   = " ab"
 StrUtils.center("abcd", 2, ' ') = "abcd"
 StrUtils.center("a", 4, ' ')    = " a  "
 StrUtils.center("a", 4, 'y')    = "yayy"
 
参数:
str - the String to center, may be null
size - the int size of new String, negative treated as zero
padChar - the character to pad the new String with
返回:
centered String, null if null String input
从以下版本开始:
  2.0







center
public static String center(String str,
            int size,
            String padStr)
Centers a String in a larger String of size size.
 Uses a supplied String as the value to pad the String with.
 
 
If the size is less than the String length, the String is returned.
 A null String returns null.
 A negative size is treated as zero.
 
 
 StrUtils.center(null, *, *)     = null
 StrUtils.center("", 4, " ")     = "    "
 StrUtils.center("ab", -1, " ")  = "ab"
 StrUtils.center("ab", 4, " ")   = " ab"
 StrUtils.center("abcd", 2, " ") = "abcd"
 StrUtils.center("a", 4, " ")    = " a  "
 StrUtils.center("a", 4, "yz")   = "yayz"
 StrUtils.center("abc", 7, null) = "  abc  "
 StrUtils.center("abc", 7, "")   = "  abc  "
 
参数:
str - the String to center, may be null
size - the int size of new String, negative treated as zero
padStr - the String to pad the new String with, must not be null or empty
返回:
centered String, null if null String input
抛出:
IllegalArgumentException - if padStr is null or empty







upperCase
public static String upperCase(String str)
Converts a String to upper case as per String.toUpperCase().
 
 
A null input String returns null.
 
 
 StrUtils.upperCase(null)  = null
 StrUtils.upperCase("")    = ""
 StrUtils.upperCase("aBc") = "ABC"
 
参数:
str - the String to upper case, may be null
返回:
the upper cased String, null if null String input







lowerCase
public static String lowerCase(String str)
Converts a String to lower case as per String.toLowerCase().
 
 
A null input String returns null.
 
 
 StrUtils.lowerCase(null)  = null
 StrUtils.lowerCase("")    = ""
 StrUtils.lowerCase("aBc") = "abc"
 
参数:
str - the String to lower case, may be null
返回:
the lower cased String, null if null String input







capitalize
public static String capitalize(String str)
Capitalizes a String changing the first letter to title case as
 per Character.toTitleCase(char). No other letters are changed.
 
 A null input String returns null.
 
 
 StrUtils.capitalize(null)  = null
 StrUtils.capitalize("")    = ""
 StrUtils.capitalize("cat") = "Cat"
 StrUtils.capitalize("cAt") = "CAt"
 
参数:
str - the String to capitalize, may be null
返回:
the capitalized String, null if null String input
从以下版本开始:
  2.0
另请参阅:
uncapitalize(String)







capitalise
public static String capitalise(String str)
已过时。 Use the standardly named capitalize(String).
 Method will be removed in Commons Lang 3.0.
Capitalizes a String changing the first letter to title case as
 per Character.toTitleCase(char). No other letters are changed.
参数:
str - the String to capitalize, may be null
返回:
the capitalized String, null if null String input







uncapitalize
public static String uncapitalize(String str)
Uncapitalizes a String changing the first letter to title case as
 per Character.toLowerCase(char). No other letters are changed.
 
 
 StrUtils.uncapitalize(null)  = null
 StrUtils.uncapitalize("")    = ""
 StrUtils.uncapitalize("Cat") = "cat"
 StrUtils.uncapitalize("CAT") = "cAT"
 
参数:
str - the String to uncapitalize, may be null
返回:
the uncapitalized String, null if null String input
从以下版本开始:
  2.0
另请参阅:
capitalize(String)







uncapitalise
public static String uncapitalise(String str)
已过时。 Use the standardly named uncapitalize(String).
 Method will be removed in Commons Lang 3.0.
Uncapitalizes a String changing the first letter to title case as
 per Character.toLowerCase(char). No other letters are changed.
参数:
str - the String to uncapitalize, may be null
返回:
the uncapitalized String, null if null String input







swapCase
public static String swapCase(String str)
Swaps the case of a String changing upper and title case to
 lower case, and lower case to upper case.
 
 

 Upper case character converts to Lower case
 Title case character converts to Lower case
 Lower case character converts to Upper case
 
 
 A null input String returns null.
 
 
 StrUtils.swapCase(null)                 = null
 StrUtils.swapCase("")                   = ""
 StrUtils.swapCase("The dog has a BONE") = "tHE DOG HAS A bone"
 
 
 
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 WordUtils.
参数:
str - the String to swap case, may be null
返回:
the changed String, null if null String input







countMatches
public static int countMatches(String str,
               String sub)
Counts how many times the substring appears in the larger String.
 
 
A null or empty ("") String input returns 0.
 
 
 StrUtils.countMatches(null, *)       = 0
 StrUtils.countMatches("", *)         = 0
 StrUtils.countMatches("abba", null)  = 0
 StrUtils.countMatches("abba", "")    = 0
 StrUtils.countMatches("abba", "a")   = 2
 StrUtils.countMatches("abba", "ab")  = 1
 StrUtils.countMatches("abba", "xxx") = 0
 
参数:
str - the String to check, may be null
sub - the substring to count, may be null
返回:
the number of occurrences, 0 if either String is null







isAlpha
public static boolean isAlpha(String str)
Checks if the String contains only unicode letters.
 
 
null will return false.
 An empty String ("") will return true.
 
 
 StrUtils.isAlpha(null)   = false
 StrUtils.isAlpha("")     = true
 StrUtils.isAlpha("  ")   = false
 StrUtils.isAlpha("abc")  = true
 StrUtils.isAlpha("ab2c") = false
 StrUtils.isAlpha("ab-c") = false
 
参数:
str - the String to check, may be null
返回:
true if only contains letters, and is non-null







isAlphaSpace
public static boolean isAlphaSpace(String str)
Checks if the String contains only unicode letters and
 space (' ').
 
 
null will return false
 An empty String ("") will return true.
 
 
 StrUtils.isAlphaSpace(null)   = false
 StrUtils.isAlphaSpace("")     = true
 StrUtils.isAlphaSpace("  ")   = true
 StrUtils.isAlphaSpace("abc")  = true
 StrUtils.isAlphaSpace("ab c") = true
 StrUtils.isAlphaSpace("ab2c") = false
 StrUtils.isAlphaSpace("ab-c") = false
 
参数:
str - the String to check, may be null
返回:
true if only contains letters and space,
 and is non-null







isAlphanumeric
public static boolean isAlphanumeric(String str)
Checks if the String contains only unicode letters or digits.
 
 
null will return false.
 An empty String ("") will return true.
 
 
 StrUtils.isAlphanumeric(null)   = false
 StrUtils.isAlphanumeric("")     = true
 StrUtils.isAlphanumeric("  ")   = false
 StrUtils.isAlphanumeric("abc")  = true
 StrUtils.isAlphanumeric("ab c") = false
 StrUtils.isAlphanumeric("ab2c") = true
 StrUtils.isAlphanumeric("ab-c") = false
 
参数:
str - the String to check, may be null
返回:
true if only contains letters or digits,
 and is non-null







isAlphanumericSpace
public static boolean isAlphanumericSpace(String str)
Checks if the String contains only unicode letters, digits
 or space (' ').
 
 
null will return false.
 An empty String ("") will return true.
 
 
 StrUtils.isAlphanumeric(null)   = false
 StrUtils.isAlphanumeric("")     = true
 StrUtils.isAlphanumeric("  ")   = true
 StrUtils.isAlphanumeric("abc")  = true
 StrUtils.isAlphanumeric("ab c") = true
 StrUtils.isAlphanumeric("ab2c") = true
 StrUtils.isAlphanumeric("ab-c") = false
 
参数:
str - the String to check, may be null
返回:
true if only contains letters, digits or space,
 and is non-null







isNumeric
public static boolean isNumeric(String str)
Checks if the String contains only unicode digits.
 A decimal point is not a unicode digit and returns false.
 
 
null will return false.
 An empty String ("") will return true.
 
 
 StrUtils.isNumeric(null)   = false
 StrUtils.isNumeric("")     = true
 StrUtils.isNumeric("  ")   = false
 StrUtils.isNumeric("123")  = true
 StrUtils.isNumeric("12 3") = false
 StrUtils.isNumeric("ab2c") = false
 StrUtils.isNumeric("12-3") = false
 StrUtils.isNumeric("12.3") = false
 
参数:
str - the String to check, may be null
返回:
true if only contains digits, and is non-null







isNumericSpace
public static boolean isNumericSpace(String str)
Checks if the String contains only unicode digits or space
 (' ').
 A decimal point is not a unicode digit and returns false.
 
 
null will return false.
 An empty String ("") will return true.
 
 
 StrUtils.isNumeric(null)   = false
 StrUtils.isNumeric("")     = true
 StrUtils.isNumeric("  ")   = true
 StrUtils.isNumeric("123")  = true
 StrUtils.isNumeric("12 3") = true
 StrUtils.isNumeric("ab2c") = false
 StrUtils.isNumeric("12-3") = false
 StrUtils.isNumeric("12.3") = false
 
参数:
str - the String to check, may be null
返回:
true if only contains digits or space,
 and is non-null







isWhitespace
public static boolean isWhitespace(String str)
Checks if the String contains only whitespace.
 
 
null will return false.
 An empty String ("") will return true.
 
 
 StrUtils.isWhitespace(null)   = false
 StrUtils.isWhitespace("")     = true
 StrUtils.isWhitespace("  ")   = true
 StrUtils.isWhitespace("abc")  = false
 StrUtils.isWhitespace("ab2c") = false
 StrUtils.isWhitespace("ab-c") = false
 
参数:
str - the String to check, may be null
返回:
true if only contains whitespace, and is non-null
从以下版本开始:
  2.0







defaultString
public static String defaultString(String str)
Returns either the passed in String,
 or if the String is null, an empty String ("").
 
 
 StrUtils.defaultString(null)  = ""
 StrUtils.defaultString("")    = ""
 StrUtils.defaultString("bat") = "bat"
 
参数:
str - the String to check, may be null
返回:
the passed in String, or the empty String if it
 was null
另请参阅:
String.valueOf(Object)







defaultString
public static String defaultString(String str,
                   String defaultStr)
Returns either the passed in String, or if the String is
 null, the value of defaultStr.
 
 
 StrUtils.defaultString(null, "NULL")  = "NULL"
 StrUtils.defaultString("", "NULL")    = ""
 StrUtils.defaultString("bat", "NULL") = "bat"
 
参数:
str - the String to check, may be null
defaultStr - the default String to return
                   if the input is null, may be null
返回:
the passed in String, or the default if it was null
另请参阅:
String.valueOf(Object)







defaultIfEmpty
public static String defaultIfEmpty(String str,
                    String defaultStr)
Returns either the passed in String, or if the String is
 empty or null, the value of defaultStr.
 
 
 StrUtils.defaultIfEmpty(null, "NULL")  = "NULL"
 StrUtils.defaultIfEmpty("", "NULL")    = "NULL"
 StrUtils.defaultIfEmpty("bat", "NULL") = "bat"
 
参数:
str - the String to check, may be null
defaultStr - the default String to return
                   if the input is empty ("") or null, may be null
返回:
the passed in String, or the default







reverse
public static String reverse(String str)
Reverses a String as per StringBuffer.reverse().
 
 
A null String returns null.
 
 
 StrUtils.reverse(null)  = null
 StrUtils.reverse("")    = ""
 StrUtils.reverse("bat") = "tab"
 
参数:
str - the String to reverse, may be null
返回:
the reversed String, null if null String input







abbreviate
public static String abbreviate(String str,
                int maxWidth)
Abbreviates a String using ellipses. This will turn
 "Now is the time for all good men" into "Now is the time for..."
 
 
Specifically:
 

 If str is less than maxWidth characters
 long, return it.
 Else abbreviate it to (substring(str, 0, max-3) + "...").
 If maxWidth is less than 4, throw an
 IllegalArgumentException.
 In no case will it return a String of length greater than
 maxWidth.
 
 
 
 
 StrUtils.abbreviate(null, *)      = null
 StrUtils.abbreviate("", 4)        = ""
 StrUtils.abbreviate("abcdefg", 6) = "abc..."
 StrUtils.abbreviate("abcdefg", 7) = "abcdefg"
 StrUtils.abbreviate("abcdefg", 8) = "abcdefg"
 StrUtils.abbreviate("abcdefg", 4) = "a..."
 StrUtils.abbreviate("abcdefg", 3) = IllegalArgumentException
 
参数:
str - the String to check, may be null
maxWidth - maximum length of result String, must be at least 4
返回:
abbreviated String, null if null String input
抛出:
IllegalArgumentException - if the width is too small
从以下版本开始:
  2.0







abbreviate
public static String abbreviate(String str,
                int offset,
                int maxWidth)
Abbreviates a String using ellipses. This will turn
 "Now is the time for all good men" into "...is the time for..."
 
 
Works like 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.
 

 
In no case will it return a String of length greater than
 maxWidth.
 
 
 StrUtils.abbreviate(null, *, *)                = null
 StrUtils.abbreviate("", 0, 4)                  = ""
 StrUtils.abbreviate("abcdefghijklmno", -1, 10) = "abcdefg..."
 StrUtils.abbreviate("abcdefghijklmno", 0, 10)  = "abcdefg..."
 StrUtils.abbreviate("abcdefghijklmno", 1, 10)  = "abcdefg..."
 StrUtils.abbreviate("abcdefghijklmno", 4, 10)  = "abcdefg..."
 StrUtils.abbreviate("abcdefghijklmno", 5, 10)  = "...fghi..."
 StrUtils.abbreviate("abcdefghijklmno", 6, 10)  = "...ghij..."
 StrUtils.abbreviate("abcdefghijklmno", 8, 10)  = "...ijklmno"
 StrUtils.abbreviate("abcdefghijklmno", 10, 10) = "...ijklmno"
 StrUtils.abbreviate("abcdefghijklmno", 12, 10) = "...ijklmno"
 StrUtils.abbreviate("abcdefghij", 0, 3)        = IllegalArgumentException
 StrUtils.abbreviate("abcdefghij", 5, 6)        = IllegalArgumentException
 
参数:
str - the String to check, may be null
offset - left edge of source String
maxWidth - maximum length of result String, must be at least 4
返回:
abbreviated String, null if null String input
抛出:
IllegalArgumentException - if the width is too small
从以下版本开始:
  2.0







difference
public static String difference(String str1,
                String str2)
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.)
 
 
For example,
 difference("i am a machine", "i am a robot") -> "robot".
 
 
 StrUtils.difference(null, null) = null
 StrUtils.difference("", "") = ""
 StrUtils.difference("", "abc") = "abc"
 StrUtils.difference("abc", "") = ""
 StrUtils.difference("abc", "abc") = ""
 StrUtils.difference("ab", "abxyz") = "xyz"
 StrUtils.difference("abcde", "abxyz") = "xyz"
 StrUtils.difference("abcde", "xyz") = "xyz"
 
参数:
str1 - the first String, may be null
str2 - the second String, may be null
返回:
the portion of str2 where it differs from str1; returns the
 empty String if they are equal
从以下版本开始:
  2.0







indexOfDifference
public static int indexOfDifference(String str1,
                    String str2)
Compares two Strings, and returns the index at which the
 Strings begin to differ.
 
 
For example,
 indexOfDifference("i am a machine", "i am a robot") -> 7
 
 
 StrUtils.indexOfDifference(null, null) = -1
 StrUtils.indexOfDifference("", "") = -1
 StrUtils.indexOfDifference("", "abc") = 0
 StrUtils.indexOfDifference("abc", "") = 0
 StrUtils.indexOfDifference("abc", "abc") = -1
 StrUtils.indexOfDifference("ab", "abxyz") = 2
 StrUtils.indexOfDifference("abcde", "abxyz") = 2
 StrUtils.indexOfDifference("abcde", "xyz") = 0
 
参数:
str1 - the first String, may be null
str2 - the second String, may be null
返回:
the index where str2 and str1 begin to differ; -1 if they are equal
从以下版本开始:
  2.0







indexOfDifference
public static int indexOfDifference(String[] strs)
Compares all Strings in an array and returns the index at which the
 Strings begin to differ.
 
 
For example,
 indexOfDifference(new String[] {"i am a machine", "i am a robot"}) -> 7
 
 
 StrUtils.indexOfDifference(null) = -1
 StrUtils.indexOfDifference(new String[] {}) = -1
 StrUtils.indexOfDifference(new String[] {"abc"}) = -1
 StrUtils.indexOfDifference(new String[] {null, null}) = -1
 StrUtils.indexOfDifference(new String[] {"", ""}) = -1
 StrUtils.indexOfDifference(new String[] {"", null}) = 0
 StrUtils.indexOfDifference(new String[] {"abc", null, null}) = 0
 StrUtils.indexOfDifference(new String[] {null, null, "abc"}) = 0
 StrUtils.indexOfDifference(new String[] {"", "abc"}) = 0
 StrUtils.indexOfDifference(new String[] {"abc", ""}) = 0
 StrUtils.indexOfDifference(new String[] {"abc", "abc"}) = -1
 StrUtils.indexOfDifference(new String[] {"abc", "a"}) = 1
 StrUtils.indexOfDifference(new String[] {"ab", "abxyz"}) = 2
 StrUtils.indexOfDifference(new String[] {"abcde", "abxyz"}) = 2
 StrUtils.indexOfDifference(new String[] {"abcde", "xyz"}) = 0
 StrUtils.indexOfDifference(new String[] {"xyz", "abcde"}) = 0
 StrUtils.indexOfDifference(new String[] {"i am a machine", "i am a robot"}) = 7
 
参数:
strs - array of strings, entries may be null
返回:
the index where the strings begin to differ; -1 if they are all equal
从以下版本开始:
  2.4







getCommonPrefix
public static String getCommonPrefix(String[] strs)
Compares all Strings in an array and returns the initial sequence of
 characters that is common to all of them.
 
 
For example,
 getCommonPrefix(new String[] {"i am a machine", "i am a robot"}) -> "i am a "
 
 
 StrUtils.getCommonPrefix(null) = ""
 StrUtils.getCommonPrefix(new String[] {}) = ""
 StrUtils.getCommonPrefix(new String[] {"abc"}) = "abc"
 StrUtils.getCommonPrefix(new String[] {null, null}) = ""
 StrUtils.getCommonPrefix(new String[] {"", ""}) = ""
 StrUtils.getCommonPrefix(new String[] {"", null}) = ""
 StrUtils.getCommonPrefix(new String[] {"abc", null, null}) = ""
 StrUtils.getCommonPrefix(new String[] {null, null, "abc"}) = ""
 StrUtils.getCommonPrefix(new String[] {"", "abc"}) = ""
 StrUtils.getCommonPrefix(new String[] {"abc", ""}) = ""
 StrUtils.getCommonPrefix(new String[] {"abc", "abc"}) = "abc"
 StrUtils.getCommonPrefix(new String[] {"abc", "a"}) = "a"
 StrUtils.getCommonPrefix(new String[] {"ab", "abxyz"}) = "ab"
 StrUtils.getCommonPrefix(new String[] {"abcde", "abxyz"}) = "ab"
 StrUtils.getCommonPrefix(new String[] {"abcde", "xyz"}) = ""
 StrUtils.getCommonPrefix(new String[] {"xyz", "abcde"}) = ""
 StrUtils.getCommonPrefix(new String[] {"i am a machine", "i am a robot"}) = "i am a "
 
参数:
strs - array of String objects, entries may be null
返回:
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.
从以下版本开始:
  2.4







getLevenshteinDistance
public static int getLevenshteinDistance(String s,
                         String t)
Find the Levenshtein distance between two Strings.
 
 
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).
 
 
The previous implementation of the Levenshtein distance algorithm
 was from http://www.merriampark.com/ld.htm
 
 
Chas Emerick has written an implementation in Java, which avoids an OutOfMemoryError
 which can occur when my Java implementation is used with very large strings.

 This implementation of the Levenshtein distance algorithm
 is from http://www.merriampark.com/ldjava.htm
 
 
 StrUtils.getLevenshteinDistance(null, *)             = IllegalArgumentException
 StrUtils.getLevenshteinDistance(*, null)             = IllegalArgumentException
 StrUtils.getLevenshteinDistance("","")               = 0
 StrUtils.getLevenshteinDistance("","a")              = 1
 StrUtils.getLevenshteinDistance("aaapppp", "")       = 7
 StrUtils.getLevenshteinDistance("frog", "fog")       = 1
 StrUtils.getLevenshteinDistance("fly", "ant")        = 3
 StrUtils.getLevenshteinDistance("elephant", "hippo") = 7
 StrUtils.getLevenshteinDistance("hippo", "elephant") = 7
 StrUtils.getLevenshteinDistance("hippo", "zzzzzzzz") = 8
 StrUtils.getLevenshteinDistance("hello", "hallo")    = 1
 
参数:
s - the first String, must not be null
t - the second String, must not be null
返回:
result distance
抛出:
IllegalArgumentException - if either String input null







startsWith
public static boolean startsWith(String str,
                 String prefix)
Check if a String starts with a specified prefix.
 
 
nulls are handled without exceptions. Two null
 references are considered to be equal. The comparison is case sensitive.
 
 
 StrUtils.startsWith(null, null)      = true
 StrUtils.startsWith(null, "abcdef")  = false
 StrUtils.startsWith("abc", null)     = false
 StrUtils.startsWith("abc", "abcdef") = true
 StrUtils.startsWith("abc", "ABCDEF") = false
 
参数:
str - the String to check, may be null
prefix - the prefix to find, may be null
返回:
true if the String starts with the prefix, case sensitive, or
 both null
从以下版本开始:
  2.4
另请参阅:
String.startsWith(String)







startsWithIgnoreCase
public static boolean startsWithIgnoreCase(String str,
                           String prefix)
Case insensitive check if a String starts with a specified prefix.
 
 
nulls are handled without exceptions. Two null
 references are considered to be equal. The comparison is case insensitive.
 
 
 StrUtils.startsWithIgnoreCase(null, null)      = true
 StrUtils.startsWithIgnoreCase(null, "abcdef")  = false
 StrUtils.startsWithIgnoreCase("abc", null)     = false
 StrUtils.startsWithIgnoreCase("abc", "abcdef") = true
 StrUtils.startsWithIgnoreCase("abc", "ABCDEF") = true
 
参数:
str - the String to check, may be null
prefix - the prefix to find, may be null
返回:
true if the String starts with the prefix, case insensitive, or
 both null
从以下版本开始:
  2.4
另请参阅:
String.startsWith(String)







endsWith
public static boolean endsWith(String str,
               String suffix)
Check if a String ends with a specified suffix.
 
 
nulls are handled without exceptions. Two null
 references are considered to be equal. The comparison is case sensitive.
 
 
 StrUtils.endsWith(null, null)      = true
 StrUtils.endsWith(null, "abcdef")  = false
 StrUtils.endsWith("def", null)     = false
 StrUtils.endsWith("def", "abcdef") = true
 StrUtils.endsWith("def", "ABCDEF") = false
 
参数:
str - the String to check, may be null
suffix - the suffix to find, may be null
返回:
true if the String ends with the suffix, case sensitive, or
 both null
从以下版本开始:
  2.4
另请参阅:
String.endsWith(String)







endsWithIgnoreCase
public static boolean endsWithIgnoreCase(String str,
                         String suffix)
Case insensitive check if a String ends with a specified suffix.
 
 
nulls are handled without exceptions. Two null
 references are considered to be equal. The comparison is case insensitive.
 
 
 StrUtils.endsWithIgnoreCase(null, null)      = true
 StrUtils.endsWithIgnoreCase(null, "abcdef")  = false
 StrUtils.endsWithIgnoreCase("def", null)     = false
 StrUtils.endsWithIgnoreCase("def", "abcdef") = true
 StrUtils.endsWithIgnoreCase("def", "ABCDEF") = false
 
参数:
str - the String to check, may be null
suffix - the suffix to find, may be null
返回:
true if the String ends with the suffix, case insensitive, or
 both null
从以下版本开始:
  2.4
另请参阅:
String.endsWith(String)

类 StrUtils

字段概要

构造器概要

方法概要

从类继承的方法 java.lang.Object

字段详细资料

EMPTY

INDEX_NOT_FOUND

构造器详细资料

StrUtils

方法详细资料

isEmpty

isNotEmpty

isBlank

isNotBlank

trim

trimToNull

trimToEmpty

strip

stripToNull

stripToEmpty

strip

stripStart

stripEnd

stripAll

stripAll

equals

equalsIgnoreCase

indexOf

indexOf

indexOf

ordinalIndexOf

indexOf

lastIndexOf

lastIndexOf

lastIndexOf

lastIndexOf

contains

contains

containsIgnoreCase

indexOfAny

indexOfAny

containsAny

containsAny

indexOfAnyBut

indexOfAnyBut

containsOnly

containsOnly

containsNone

containsNone

indexOfAny

lastIndexOfAny

substring

substring

left

right

mid

substringBefore

substringAfter

substringBeforeLast

substringAfterLast

substringBetween

substringBetween

substringsBetween

getNestedString

getNestedString

split

split

split

split

splitByWholeSeparator

splitByWholeSeparator

splitByWholeSeparatorPreserveAllTokens

splitByWholeSeparatorPreserveAllTokens

splitPreserveAllTokens

splitPreserveAllTokens

splitPreserveAllTokens

splitPreserveAllTokens

splitByCharacterType

splitByCharacterTypeCamelCase