String (Groovy JDK enhancements)

Methods Summary

Methods
Return type	Name and parameters
`Object`	`asType(Class c)` Provides a method to perform custom 'dynamic' type conversion to the given class using the `as` operator.
`Pattern`	`bitwiseNegate()` Turns a String into a regular expression Pattern
`String`	`capitalize()` Convenience method to capitalize the first letter of a string (typically the first letter of a word).
`String`	`center(Number numberOfChars)` Pad a String to a minimum length specified by `numberOfChars` by adding the space character around it as many times as needed so that it remains centered.
`String`	`center(Number numberOfChars, String padding)` Pad a String to a minimum length specified by `numberOfChars`, appending the supplied padding String around the original as many times as needed keeping it centered.
`String`	`collectReplacements(Closure transform)` Iterate through this String a character at a time collecting either the original character or a transformed replacement String.
`boolean`	`contains(String text)` Provide an implementation of contains() like Collection#contains(Object) to make Strings more polymorphic.
`int`	`count(String text)` Count the number of occurrences of a substring.
`byte[]`	`decodeBase64()` Decode the String from Base64 into a byte array.
`byte[]`	`decodeHex()` Decodes a hex string to a byte array.
`String`	`denormalize()` Return a String with lines (separated by LF, CR/LF, or CR) terminated by the platform specific line separator.
`Object`	`eachLine(Closure closure)` Iterates through this String line by line.
`Object`	`eachLine(int firstLine, Closure closure)` Iterates through this String line by line.
`String`	`eachMatch(String regex, Closure closure)` Process each regex group matched substring of the given string.
`String`	`eachMatch(Pattern pattern, Closure closure)` Process each regex group matched substring of the given pattern.
`Process`	`execute()` Executes the command specified by `self` as a command-line process.
`Process`	`execute(String[] envp, File dir)` Executes the command specified by `self` with environment defined by `envp` and under the working directory `dir`.
`Process`	`execute(List envp, File dir)` Executes the command specified by `self` with environment defined by `envp` and under the working directory `dir`.
`String`	`expand()` Expands all tabs into spaces with tabStops of size 8.
`String`	`expand(int tabStop)` Expands all tabs into spaces.
`String`	`expandLine(int tabStop)` Expands all tabs into spaces.
`String`	`find(String regex)` Finds the first occurrence of a regular expression String within a String.
`String`	`find(String regex, Closure closure)` Returns the result of calling a closure with the first occurrence of a regular expression found within a String.
`String`	`find(Pattern pattern)` Finds the first occurrence of a compiled regular expression Pattern within a String.
`String`	`find(Pattern pattern, Closure closure)` Returns the result of calling a closure with the first occurrence of a compiled regular expression found within a String.
`List`	`findAll(String regex)` Returns a (possibly empty) list of all occurrences of a regular expression (in String format) found within a String.
`List`	`findAll(String regex, Closure closure)` Finds all occurrences of a regular expression string within a String.
`List`	`findAll(Pattern pattern)` Returns a (possibly empty) list of all occurrences of a regular expression (in Pattern format) found within a String.
`List`	`findAll(Pattern pattern, Closure closure)` Finds all occurrences of a compiled regular expression Pattern within a String.
`String`	`getAt(EmptyRange range)` Support the range subscript operator for String with EmptyRange
`String`	`getAt(IntRange range)` Support the range subscript operator for String with IntRange
`String`	`getAt(Range range)` Support the range subscript operator for String
`String`	`getAt(int index)` Support the subscript operator for String.
`String`	`getAt(Collection indices)` Select a List of characters from a String using a Collection to identify the indices to be selected.
`char[]`	`getChars()` Converts the given String into an array of characters.
`boolean`	`isAllWhitespace()` True if a String only contains whitespace characters.
`boolean`	`isBigDecimal()` Determine if a String can be parsed into a BigDecimal.
`boolean`	`isBigInteger()` Determine if a String can be parsed into a BigInteger.
`boolean`	`isCase(Object switchValue)` 'Case' implementation for a String, which uses String#equals(Object) in order to allow Strings to be used in switch statements.
`boolean`	`isDouble()` Determine if a String can be parsed into a Double.
`boolean`	`isFloat()` Determine if a String can be parsed into a Float.
`boolean`	`isInteger()` Determine if a String can be parsed into an Integer.
`boolean`	`isLong()` Determine if a String can be parsed into a Long.
`boolean`	`isNumber()` Determine if a String can be parsed into a Number.
`StringBuffer`	`leftShift(Object value)` Overloads the left shift operator to provide an easy way to append multiple objects as string representations to a String.
`boolean`	`matches(Pattern pattern)` Tells whether or not self matches the given compiled regular expression Pattern.
`String`	`minus(Object target)` Remove a part of a String.
`String`	`minus(Pattern pattern)` Remove a part of a String.
`String`	`multiply(Number factor)` Repeat a String a certain number of times.
`String`	`next()` This method is called by the ++ operator for the class String.
`String`	`normalize()` Return a String with linefeeds and carriage returns normalized to linefeeds.
`String`	`padLeft(Number numberOfChars)` Pad a String to a minimum length specified by `numberOfChars` by adding the space character to the left as many times as needed.
`String`	`padLeft(Number numberOfChars, String padding)` Pad a String to a minimum length specified by `numberOfChars`, adding the supplied padding String as many times as needed to the left.
`String`	`padRight(Number numberOfChars)` Pad a String to a minimum length specified by `numberOfChars` by adding the space character to the right as many times as needed.
`String`	`padRight(Number numberOfChars, String padding)` Pad a String to a minimum length specified by `numberOfChars`, adding the supplied padding String as many times as needed to the right.
`String`	`plus(CharSequence value)` Appends the String representation of the given operand to this string.
`String`	`plus(Object value)` Appends the String representation of the given operand to this string.
`String`	`previous()` This method is called by the -- operator for the class String.
`List`	`readLines()` Return the lines of a String as a List of Strings.
`String`	`replaceAll(String regex, Closure closure)` Replaces all occurrences of a captured group by the result of a closure on that text.
`String`	`replaceAll(Pattern pattern, Closure closure)` Replaces all occurrences of a captured group by the result of a closure call on that text.
`String`	`replaceAll(Pattern pattern, String replacement)` Replaces all substrings of a String that match the given compiled regular expression with the given replacement.
`String`	`replaceFirst(String regex, Closure closure)` Replaces the first occurrence of a captured group by the result of a closure call on that text.
`String`	`replaceFirst(Pattern pattern, Closure closure)` Replaces the first occurrence of a captured group by the result of a closure call on that text.
`String`	`replaceFirst(Pattern pattern, String replacement)` Replaces the first substring of a String that matches the given compiled regular expression with the given replacement.
`String`	`reverse()` Creates a new string which is the reverse (backwards) of this string
`int`	`size()` Provide the standard Groovy `size()` method for `String`.
`String[]`	`split()` Convenience method to split a string (with whitespace as delimiter) Like tokenize, but returns an Array of Strings instead of a List
`Object`	`splitEachLine(String regex, Closure closure)` Iterates through the given String line by line, splitting each line using the given separator.
`Object`	`splitEachLine(Pattern pattern, Closure closure)` Iterates through the given String line by line, splitting each line using the given separator Pattern.
`String`	`stripIndent()` Strip leading spaces from every line in a String.
`String`	`stripIndent(int numChars)` Strip `numChar` leading characters from every line in a String.
`String`	`stripMargin()` Strip leading whitespace/control characters followed by '\|' from every line in a String.
`String`	`stripMargin(char marginChar)` Strip leading whitespace/control characters followed by `marginChar` from every line in a String.
`String`	`stripMargin(String marginChar)` Strip leading whitespace/control characters followed by `marginChar` from every line in a String.
`BigDecimal`	`toBigDecimal()` Parse a String into a BigDecimal
`BigInteger`	`toBigInteger()` Parse a String into a BigInteger
`Boolean`	`toBoolean()` Converts the given string into a Boolean object.
`Character`	`toCharacter()` Converts the given string into a Character object using the first character in the string.
`Double`	`toDouble()` Parse a String into a Double
`Float`	`toFloat()` Parse a String into a Float
`Integer`	`toInteger()` Parse a String into an Integer
`List`	`toList()` Converts the given String into a List of strings of one character.
`Long`	`toLong()` Parse a String into a Long
`Set`	`toSet()` Converts the given String into a Set of unique strings of one character.
`Short`	`toShort()` Parse a String into a Short
`URI`	`toURI()` Transforms a String representing a URI into a URI object.
`URL`	`toURL()` Transforms a String representing a URL into a URL object.
`List`	`tokenize()` Tokenize a String (with a whitespace as the delimiter).
`List`	`tokenize(Character token)` Tokenize a String based on the given character delimiter.
`List`	`tokenize(String token)` Tokenize a String based on the given string delimiter.
`String`	`tr(String sourceSet, String replacementSet)` Translates a string by replacing characters from the sourceSet with characters from replacementSet.
`String`	`unexpand()` Replaces sequences of whitespaces with tabs using tabStops of size 8.
`String`	`unexpand(int tabStop)` Replaces sequences of whitespaces with tabs.
`String`	`unexpandLine(int tabStop)` Replaces sequences of whitespaces with tabs within a line.

Methods inherited from class java.lang.Object

addShutdownHook, any, any, asBoolean, asType, collect, collect, collect, dump, each, eachWithIndex, every, every, find, find, findAll, findAll, findIndexOf, findIndexOf, findIndexValues, findIndexValues, findLastIndexOf, findLastIndexOf, findResult, findResult, getAt, getMetaClass, getMetaPropertyValues, getProperties, grep, grep, hasProperty, identity, inject, inject, inspect, invokeMethod, is, isCase, iterator, metaClass, print, print, printf, printf, println, println, println, putAt, respondsTo, respondsTo, setMetaClass, split, sprintf, sprintf, toString, use, use, use, with, withTraits

Methods inherited from interface java.lang.CharSequence

asBoolean, asType, bitwiseNegate, capitalize, center, center, contains, count, denormalize, drop, dropWhile, eachLine, eachLine, eachMatch, eachMatch, expand, expand, expandLine, find, find, find, find, findAll, findAll, findAll, findAll, getAt, getAt, getAt, getAt, getAt, getChars, isAllWhitespace, isBigDecimal, isBigInteger, isCase, isDouble, isFloat, isInteger, isLong, isNumber, leftShift, matches, minus, multiply, next, normalize, padLeft, padLeft, padRight, padRight, plus, previous, readLines, replaceAll, replaceAll, replaceAll, replaceAll, replaceFirst, replaceFirst, replaceFirst, replaceFirst, reverse, size, split, splitEachLine, splitEachLine, stripIndent, stripIndent, stripMargin, stripMargin, stripMargin, take, takeWhile, toBigDecimal, toBigInteger, toDouble, toFloat, toInteger, toList, toLong, toSet, toShort, toURI, toURL, tokenize, tokenize, tokenize, tr, unexpand, unexpand, unexpandLine

Methods inherited from interface java.lang.Comparable

numberAwareCompareTo

- Methods Detail
  - public Object asType(Class c)
    
    Provides a method to perform custom 'dynamic' type conversion to the given class using the as operator. Example: '123' as Double
    By default, the following types are supported:
    - List
    - BigDecimal
    - BigInteger
    - Long
    - Integer
    - Short
    - Byte
    - Character
    - Double
    - Float
    - File
    - Subclasses of Enum (Java 5 and above)
    If any other type is given, the call is delegated to DefaultGroovyMethods#asType(Object, Class).
    
    Parameters:
    
    c - the desired class
    
    Returns:
    
    the converted object
    
    Since:
    
    1.0
  - public Pattern bitwiseNegate()
    
    Turns a String into a regular expression Pattern
    
    Returns:
    
    the regular expression pattern
    
    Since:
    
    1.5.0
  - public String capitalize()
    
    Convenience method to capitalize the first letter of a string (typically the first letter of a word). Example usage:
```
assert 'h'.capitalize() == 'H'
assert 'hello'.capitalize() == 'Hello'
assert 'hello world'.capitalize() == 'Hello world'
assert 'Hello World' ==
    'hello world'.split(' ').collect{ it.capitalize() }.join(' ')
```
    Returns:
    
    The capitalized String
    
    Since:
    
    1.7.3
  - public String center(Number numberOfChars)
    
    Pad a String to a minimum length specified by numberOfChars by adding the space character around it as many times as needed so that it remains centered. If the String is already the same size or bigger than the target numberOfChars, then the original String is returned. An example:
```
['A', 'BB', 'CCC', 'DDDD'].each{ println '|' + it.center(6) + '|' }
```
    will produce output like:
```
|  A   |
|  BB  |
| CCC  |
| DDDD |
```
    Parameters:
    
    numberOfChars - the total minimum number of characters of the resulting string
    
    Returns:
    
    the String centered with padded characters around it
    
    Since:
    
    1.0
    
    See Also:
    
    String#center(Number, String)
  - public String center(Number numberOfChars, String padding)
    
    Pad a String to a minimum length specified by numberOfChars, appending the supplied padding String around the original as many times as needed keeping it centered. If the String is already the same size or bigger than the target numberOfChars, then the original String is returned. An example:
```
['A', 'BB', 'CCC', 'DDDD'].each{ println '|' + it.center(6, '+') + '|' }
```
    will produce output like:
```
|++A+++|
|++BB++|
|+CCC++|
|+DDDD+|
```
    Parameters:
    
    numberOfChars - the total minimum number of characters of the resulting string
    
    padding - the characters used for padding
    
    Returns:
    
    the String centered with padded characters around it
    
    Since:
    
    1.0
  - public String collectReplacements(Closure transform)
    
    Iterate through this String a character at a time collecting either the original character or a transformed replacement String. The transform Closure should return null to indicate that no transformation is required for the given character.
```
assert "Groovy".collectReplacements{ it == 'o' ? '_O_' : null } == 'Gr_O__O_vy'
assert "B&W".collectReplacements{ it == '&' ? '&' : null } == 'B&W'
```
    Parameters:
    
    Returns:
    
    A new string in which all characters that require escaping have been replaced with the corresponding replacements as determined by the transform Closure.
  - public boolean contains(String text)
    
    Provide an implementation of contains() like Collection#contains(Object) to make Strings more polymorphic. This method is not required on JDK 1.5 onwards
    
    Parameters:
    
    text - a String to look for
    
    Returns:
    
    true if this string contains the given text
    
    Since:
    
    1.0
  - public int count(String text)
    
    Count the number of occurrences of a substring.
    
    Parameters:
    
    text - a substring
    
    Returns:
    
    the number of occurrences of the given string inside this String
    
    Since:
    
    1.0
  - public byte[] decodeBase64()
    
    Decode the String from Base64 into a byte array.
    
    Returns:
    
    the decoded bytes as an array
    
    Since:
    
    1.0
  - public byte[] decodeHex()
    
    Decodes a hex string to a byte array. The hex string can contain either upper case or lower case letters.
    
    Returns:
    
    decoded byte array
  - public String denormalize()
    
    Return a String with lines (separated by LF, CR/LF, or CR) terminated by the platform specific line separator.
    
    Returns:
    
    the denormalized string
    
    Since:
    
    1.6.0
  - public Object eachLine(Closure closure)
    
    Iterates through this String line by line. Each line is passed to the given 1 or 2 arg closure. If a 2 arg closure is found the line count is passed as the second argument.
    
    Parameters:
    
    closure - a closure
    
    Returns:
    
    the last value returned by the closure
    
    Since:
    
    1.5.5
    
    See Also:
    
    String#eachLine(int, groovy.lang.Closure)
  - public Object eachLine(int firstLine, Closure closure)
    
    Iterates through this String line by line. Each line is passed to the given 1 or 2 arg closure. If a 2 arg closure is found the line count is passed as the second argument.
    
    Parameters:
    
    firstLine - the line number value used for the first line (default is 1, set to 0 to start counting from 0)
    
    closure - a closure (arg 1 is line, optional arg 2 is line number)
    
    Returns:
    
    the last value returned by the closure
    
    Since:
    
    1.5.7
  - public String eachMatch(String regex, Closure closure)
    
    Process each regex group matched substring of the given string. If the closure parameter takes one argument, an array with all match groups is passed to it. If the closure takes as many arguments as there are match groups, then each parameter will be one match group.
    
    Parameters:
    
    regex - a Regex string
    
    closure - a closure with one parameter or as much parameters as groups
    
    Returns:
    
    the source string
    
    Since:
    
    1.6.0
  - public String eachMatch(Pattern pattern, Closure closure)
    
    Process each regex group matched substring of the given pattern. If the closure parameter takes one argument, an array with all match groups is passed to it. If the closure takes as many arguments as there are match groups, then each parameter will be one match group.
    
    Parameters:
    
    pattern - a regex Pattern
    
    closure - a closure with one parameter or as much parameters as groups
    
    Returns:
    
    the source string
    
    Since:
    
    1.6.1
  - public Process execute()
    
    Executes the command specified by self as a command-line process.
    For more control over Process construction you can use java.lang.ProcessBuilder.
    
    Returns:
    
    the Process which has just started for this command line representation
    
    Since:
    
    1.0
  - public Process execute(String[] envp, File dir)
    
    Executes the command specified by self with environment defined by envp and under the working directory dir.
    For more control over Process construction you can use java.lang.ProcessBuilder.
    
    Parameters:
    
    envp - an array of Strings, each element of which has environment variable settings in the format name=value, or null if the subprocess should inherit the environment of the current process.
    
    dir - the working directory of the subprocess, or null if the subprocess should inherit the working directory of the current process.
    
    Returns:
    
    the Process which has just started for this command line representation.
    
    Since:
    
    1.0
  - public Process execute(List envp, File dir)
    
    Executes the command specified by self with environment defined by envp and under the working directory dir.
    For more control over Process construction you can use java.lang.ProcessBuilder.
    
    Parameters:
    
    envp - a List of Objects (converted to Strings using toString), each member of which has environment variable settings in the format name=value, or null if the subprocess should inherit the environment of the current process.
    
    dir - the working directory of the subprocess, or null if the subprocess should inherit the working directory of the current process.
    
    Returns:
    
    the Process which has just started for this command line representation.
    
    Since:
    
    1.0
  - public String expand()
    
    Expands all tabs into spaces with tabStops of size 8.
    
    Returns:
    
    The expanded String
    
    Since:
    
    1.7.3
    
    See Also:
    
    String#expand(int)
  - public String expand(int tabStop)
    
    Expands all tabs into spaces. If the String has multiple lines, expand each line - restarting tab stops at the start of each line.
    
    Parameters:
    
    tabStop - The number of spaces a tab represents
    
    Returns:
    
    The expanded String
    
    Since:
    
    1.7.3
  - public String expandLine(int tabStop)
    
    Expands all tabs into spaces. Assumes the String represents a single line of text.
    
    Parameters:
    
    tabStop - The number of spaces a tab represents
    
    Returns:
    
    The expanded String
    
    Since:
    
    1.7.3
  - public String find(String regex)
    
    Finds the first occurrence of a regular expression String within a String. If the regex doesn't match, null will be returned.
    For example, if the regex doesn't match the result is null:
```
    assert null == "New York, NY".find(/\d{5}/)
```
    If it does match, we get the matching string back:
```
     assert "10292" == "New York, NY 10292-0098".find(/\d{5}/)
```
    If we have capture groups in our expression, we still get back the full match
```
     assert "10292-0098" == "New York, NY 10292-0098".find(/(\d{5})-?(\d{4})/)
```
    Parameters:
    
    regex - the capturing regex
    
    Returns:
    
    a String containing the matched portion, or null if the regex doesn't match
    
    Since:
    
    1.6.1
  - public String find(String regex, Closure closure)
    
    Returns the result of calling a closure with the first occurrence of a regular expression found within a String. If the regex doesn't match, the closure will not be called and find will return null.
    For example, if the regex doesn't match, the result is null:
```
    assert null == "New York, NY".find(~/\d{5}/) { match -> return "-$match-"}
```
    If it does match and we don't have any capture groups in our regex, there is a single parameter on the closure that the match gets passed to:
```
     assert "-10292-" == "New York, NY 10292-0098".find(~/\d{5}/) { match -> return "-$match-"}
```
    If we have capture groups in our expression, our closure has one parameter for the match, followed by one for each of the capture groups:
```
     assert "10292" == "New York, NY 10292-0098".find(~/(\d{5})-?(\d{4})/) { match, zip, plusFour ->
         assert match == "10292-0098"
         assert zip == "10292"
         assert plusFour == "0098"
         return zip
     }
```
    If we have capture groups in our expression, and our closure has one parameter, the closure will be passed an array with the first element corresponding to the whole match, followed by an element for each of the capture groups:
```
     assert "10292" == "New York, NY 10292-0098".find(~/(\d{5})-?(\d{4})/) { match, zip, plusFour ->
         assert array[0] == "10292-0098"
         assert array[1] == "10292"
         assert array[2] == "0098"
         return array[1]
     }
```
    If a capture group is optional, and doesn't match, then the corresponding value for that capture group passed to the closure will be null as illustrated here:
```
     assert "2339999" == "adsf 233-9999 adsf".find(~/(\d{3})?-?(\d{3})-(\d{4})/) { match, areaCode, exchange, stationNumber ->
         assert "233-9999" == match
         assert null == areaCode
         assert "233" == exchange
         assert "9999" == stationNumber
         return "$exchange$stationNumber"
     }
```
    Parameters:
    
    regex - the capturing regex string
    
    closure - the closure that will be passed the full match, plus each of the capturing groups (if any)
    
    Returns:
    
    a String containing the result of the closure (calling toString() if needed), or null if the regex pattern doesn't match
    
    Since:
    
    1.6.1
  - public String find(Pattern pattern)
    
    Finds the first occurrence of a compiled regular expression Pattern within a String. If the pattern doesn't match, null will be returned.
    For example, if the pattern doesn't match the result is null:
```
    assert null == "New York, NY".find(~/\d{5}/)
```
    If it does match, we get the matching string back:
```
     assert "10292" == "New York, NY 10292-0098".find(~/\d{5}/)
```
    If we have capture groups in our expression, the groups are ignored and we get back the full match:
```
     assert "10292-0098" == "New York, NY 10292-0098".find(~/(\d{5})-?(\d{4})/)
```
    If you need to work with capture groups, then use the closure version of this method or use Groovy's matcher operators or use eachMatch.
    
    Parameters:
    
    pattern - the compiled regex Pattern
    
    Returns:
    
    a String containing the matched portion, or null if the regex pattern doesn't match
    
    Since:
    
    1.6.1
  - public String find(Pattern pattern, Closure closure)
    
    Returns the result of calling a closure with the first occurrence of a compiled regular expression found within a String. If the regex doesn't match, the closure will not be called and find will return null.
    For example, if the pattern doesn't match, the result is null:
```
    assert null == "New York, NY".find(~/\d{5}/) { match -> return "-$match-"}
```
    If it does match and we don't have any capture groups in our regex, there is a single parameter on the closure that the match gets passed to:
```
     assert "-10292-" == "New York, NY 10292-0098".find(~/\d{5}/) { match -> return "-$match-"}
```
    If we have capture groups in our expression, our closure has one parameter for the match, followed by one for each of the capture groups:
```
     assert "10292" == "New York, NY 10292-0098".find(~/(\d{5})-?(\d{4})/) { match, zip, plusFour ->
         assert match == "10292-0098"
         assert zip == "10292"
         assert plusFour == "0098"
         return zip
     }
```
    If we have capture groups in our expression, and our closure has one parameter, the closure will be passed an array with the first element corresponding to the whole match, followed by an element for each of the capture groups:
```
     assert "10292" == "New York, NY 10292-0098".find(~/(\d{5})-?(\d{4})/) { match, zip, plusFour ->
         assert array[0] == "10292-0098"
         assert array[1] == "10292"
         assert array[2] == "0098"
         return array[1]
     }
```
    If a capture group is optional, and doesn't match, then the corresponding value for that capture group passed to the closure will be null as illustrated here:
```
     assert "2339999" == "adsf 233-9999 adsf".find(~/(\d{3})?-?(\d{3})-(\d{4})/) { match, areaCode, exchange, stationNumber ->
         assert "233-9999" == match
         assert null == areaCode
         assert "233" == exchange
         assert "9999" == stationNumber
         return "$exchange$stationNumber"
     }
```
    Parameters:
    
    pattern - the compiled regex Pattern
    
    closure - the closure that will be passed the full match, plus each of the capturing groups (if any)
    
    Returns:
    
    a String containing the result of calling the closure (calling toString() if needed), or null if the regex pattern doesn't match
    
    Since:
    
    1.6.1
  - public List findAll(String regex)
    
    Returns a (possibly empty) list of all occurrences of a regular expression (in String format) found within a String.
    For example, if the regex doesn't match, it returns an empty list:
```
assert [] == "foo".findAll(/(\w*) Fish/)
```
    Any regular expression matches are returned in a list, and all regex capture groupings are ignored, only the full match is returned:
```
def expected = ["One Fish", "Two Fish", "Red Fish", "Blue Fish"]
assert expected == "One Fish, Two Fish, Red Fish, Blue Fish".findAll(/(\w*) Fish/)
```
    If you need to work with capture groups, then use the closure version of this method or use Groovy's matcher operators or use eachMatch.
    
    Parameters:
    
    regex - the capturing regex String
    
    Returns:
    
    a List containing all full matches of the regex within the string, an empty list will be returned if there are no matches
    
    Since:
    
    1.6.1
  - public List findAll(String regex, Closure closure)
    
    Finds all occurrences of a regular expression string within a String. Any matches are passed to the specified closure. The closure is expected to have the full match in the first parameter. If there are any capture groups, they will be placed in subsequent parameters.
    If there are no matches, the closure will not be called, and an empty List will be returned.
    For example, if the regex doesn't match, it returns an empty list:
```
assert [] == "foo".findAll(/(\w*) Fish/) { match, firstWord -> return firstWord }
```
    Any regular expression matches are passed to the closure, if there are no capture groups, there will be one parameter for the match:
```
assert ["couldn't", "wouldn't"] == "I could not, would not, with a fox.".findAll(/.ould/) { match -> "${match}n't"}
```
    If there are capture groups, the first parameter will be the match followed by one parameter for each capture group:
```
def orig = "There's a Wocket in my Pocket"
assert ["W > Wocket", "P > Pocket"] == orig.findAll(/(.)ocket/) { match, firstLetter -> "$firstLetter > $match" }
```
    Parameters:
    
    regex - the capturing regex String
    
    closure - will be passed the full match plus each of the capturing groups (if any)
    
    Returns:
    
    a List containing all results from calling the closure with each full match (and potentially capturing groups) of the regex within the String, an empty list will be returned if there are no matches
    
    Since:
    
    1.6.1
  - public List findAll(Pattern pattern)
    
    Returns a (possibly empty) list of all occurrences of a regular expression (in Pattern format) found within a String.
    For example, if the pattern doesn't match, it returns an empty list:
```
assert [] == "foo".findAll(~/(\w*) Fish/)
```
    Any regular expression matches are returned in a list, and all regex capture groupings are ignored, only the full match is returned:
```
def expected = ["One Fish", "Two Fish", "Red Fish", "Blue Fish"]
assert expected == "One Fish, Two Fish, Red Fish, Blue Fish".findAll(~/(\w*) Fish/)
```
    Parameters:
    
    pattern - the compiled regex Pattern
    
    Returns:
    
    a List containing all full matches of the Pattern within the string, an empty list will be returned if there are no matches
    
    Since:
    
    1.6.1
  - public List findAll(Pattern pattern, Closure closure)
    
    Finds all occurrences of a compiled regular expression Pattern within a String. Any matches are passed to the specified closure. The closure is expected to have the full match in the first parameter. If there are any capture groups, they will be placed in subsequent parameters.
    If there are no matches, the closure will not be called, and an empty List will be returned.
    For example, if the pattern doesn't match, it returns an empty list:
```
assert [] == "foo".findAll(~/(\w*) Fish/) { match, firstWord -> return firstWord }
```
    Any regular expression matches are passed to the closure, if there are no capture groups, there will be one parameter for the match:
```
assert ["couldn't", "wouldn't"] == "I could not, would not, with a fox.".findAll(~/.ould/) { match -> "${match}n't"}
```
    If there are capture groups, the first parameter will be the match followed by one parameter for each capture group:
```
def orig = "There's a Wocket in my Pocket"
assert ["W > Wocket", "P > Pocket"] == orig.findAll(~/(.)ocket/) { match, firstLetter -> "$firstLetter > $match" }
```
    Parameters:
    
    pattern - the compiled regex Pattern
    
    closure - will be passed the full match plus each of the capturing groups (if any)
    
    Returns:
    
    a List containing all results from calling the closure with each full match (and potentially capturing groups) of the regex pattern within the String, an empty list will be returned if there are no matches
    
    Since:
    
    1.6.1
  - public String getAt(EmptyRange range)
    
    Support the range subscript operator for String with EmptyRange
    
    Parameters:
    
    range - an EmptyRange
    
    Returns:
    
    the resulting String
    
    Since:
    
    1.5.0
  - public String getAt(IntRange range)
    
    Support the range subscript operator for String with IntRange
    
    Parameters:
    
    range - an IntRange
    
    Returns:
    
    the resulting String
    
    Since:
    
    1.0
  - public String getAt(Range range)
    
    Support the range subscript operator for String
    
    Parameters:
    
    range - a Range
    
    Returns:
    
    a substring corresponding to the Range
    
    Since:
    
    1.0
  - public String getAt(int index)
    
    Support the subscript operator for String.
    
    Parameters:
    
    index - the index of the Character to get
    
    Returns:
    
    the Character at the given index
    
    Since:
    
    1.0
  - public String getAt(Collection indices)
    
    Select a List of characters from a String using a Collection to identify the indices to be selected.
    
    Parameters:
    
    indices - a Collection of indices
    
    Returns:
    
    a String consisting of the characters at the given indices
    
    Since:
    
    1.0
  - public char[] getChars()
    
    Converts the given String into an array of characters. Alias for toCharArray.
    
    Returns:
    
    an array of characters
    
    Since:
    
    1.6.0
    
    See Also:
    
    String#toCharArray()
  - public boolean isAllWhitespace()
    
    True if a String only contains whitespace characters.
    
    Returns:
    
    true If all characters are whitespace characters
    
    Since:
    
    1.6
    
    See Also:
    
    Character#isWhitespace(char)
  - public boolean isBigDecimal()
    
    Determine if a String can be parsed into a BigDecimal.
    
    Returns:
    
    true if the string can be parsed
    
    Since:
    
    1.5.0
  - public boolean isBigInteger()
    
    Determine if a String can be parsed into a BigInteger.
    
    Returns:
    
    true if the string can be parsed
    
    Since:
    
    1.5.0
  - public boolean isCase(Object switchValue)
    
    'Case' implementation for a String, which uses String#equals(Object) in order to allow Strings to be used in switch statements. For example:
```
switch( str ) {
  case 'one' :
  // etc...
}
```
    Note that this returns true for the case where both the 'switch' and 'case' operand is null.
    
    Parameters:
    
    switchValue - the switch value
    
    Returns:
    
    true if the switchValue's toString() equals the caseValue
    
    Since:
    
    1.0
  - public boolean isDouble()
    
    Determine if a String can be parsed into a Double.
    
    Returns:
    
    true if the string can be parsed
    
    Since:
    
    1.5.0
  - public boolean isFloat()
    
    Determine if a String can be parsed into a Float.
    
    Returns:
    
    true if the string can be parsed
    
    Since:
    
    1.5.0
  - public boolean isInteger()
    
    Determine if a String can be parsed into an Integer.
    
    Returns:
    
    true if the string can be parsed
    
    Since:
    
    1.5.0
  - public boolean isLong()
    
    Determine if a String can be parsed into a Long.
    
    Returns:
    
    true if the string can be parsed
    
    Since:
    
    1.5.0
  - public boolean isNumber()
    
    Determine if a String can be parsed into a Number. Synonym for 'isBigDecimal()'.
    
    Returns:
    
    true if the string can be parsed
    
    Since:
    
    1.5.0
    
    See Also:
    
    String#isBigDecimal()
  - public StringBuffer leftShift(Object value)
    
    Overloads the left shift operator to provide an easy way to append multiple objects as string representations to a String.
    
    Parameters:
    
    value - an Object
    
    Returns:
    
    a StringBuffer built from this string
    
    Since:
    
    1.0
  - public boolean matches(Pattern pattern)
    
    Tells whether or not self matches the given compiled regular expression Pattern.
    
    Parameters:
    
    pattern - the regex Pattern to which the string of interest is to be matched
    
    Returns:
    
    true if the string matches
    
    Since:
    
    1.6.1
    
    See Also:
    
    String#matches(String)
  - public String minus(Object target)
    
    Remove a part of a String. This replaces the first occurrence of target.toString() within self with '' and returns the result.
    
    Parameters:
    
    target - an object representing the part to remove
    
    Returns:
    
    a String minus the part to be removed
    
    Since:
    
    1.0
  - public String minus(Pattern pattern)
    
    Remove a part of a String. This replaces the first occurrence of the regex pattern within self with '' and returns the result.
    
    Parameters:
    
    pattern - a Pattern representing the part to remove
    
    Returns:
    
    a String minus the part to be removed
    
    Since:
    
    2.2.0
  - public String multiply(Number factor)
    
    Repeat a String a certain number of times.
    
    Parameters:
    
    factor - the number of times the String should be repeated
    
    Returns:
    
    a String composed of a repetition
    
    Since:
    
    1.0
  - public String next()
    
    This method is called by the ++ operator for the class String. It increments the last character in the given string. If the character in the string is Character.MAX_VALUE a Character.MIN_VALUE will be appended. The empty string is incremented to a string consisting of the character Character.MIN_VALUE.
    
    Returns:
    
    an incremented String
    
    Since:
    
    1.0
  - public String normalize()
    
    Return a String with linefeeds and carriage returns normalized to linefeeds.
    
    Returns:
    
    the normalized string
    
    Since:
    
    1.6.0
  - public String padLeft(Number numberOfChars)
    
    Pad a String to a minimum length specified by numberOfChars by adding the space character to the left as many times as needed. If the String is already the same size or bigger than the target numberOfChars, then the original String is returned. An example:
```
println 'Numbers:'
[1, 10, 100, 1000].each{ println it.toString().padLeft(5) }
```
    will produce output like:
```
Numbers:
    1
   10
  100
 1000
```
    Parameters:
    
    numberOfChars - the total minimum number of characters of the resulting string
    
    Returns:
    
    the String padded to the left
    
    Since:
    
    1.0
    
    See Also:
    
    String#padLeft(Number, String)
  - public String padLeft(Number numberOfChars, String padding)
    
    Pad a String to a minimum length specified by numberOfChars, adding the supplied padding String as many times as needed to the left. If the String is already the same size or bigger than the target numberOfChars, then the original String is returned. An example:
```
println 'Numbers:'
[1, 10, 100, 1000].each{ println it.toString().padLeft(5, '*') }
[2, 20, 200, 2000].each{ println it.toString().padLeft(5, '*_') }
```
    will produce output like:
```
Numbers:
****1
***10
**100
*1000
*_*_2
*_*20
*_200
*2000
```
    Parameters:
    
    numberOfChars - the total minimum number of characters of the resulting string
    
    padding - the characters used for padding
    
    Returns:
    
    the String padded to the left
    
    Since:
    
    1.0
  - public String padRight(Number numberOfChars)
    
    Pad a String to a minimum length specified by numberOfChars by adding the space character to the right as many times as needed. If the String is already the same size or bigger than the target numberOfChars, then the original String is returned. An example:
```
['A', 'BB', 'CCC', 'DDDD'].each{ println it.padRight(5) + it.size() }
```
    will produce output like:
```
A    1
BB   2
CCC  3
DDDD 4
```
    Parameters:
    
    numberOfChars - the total minimum number of characters of the resulting string
    
    Returns:
    
    the String padded to the right
    
    Since:
    
    1.0
  - public String padRight(Number numberOfChars, String padding)
    
    Pad a String to a minimum length specified by numberOfChars, adding the supplied padding String as many times as needed to the right. If the String is already the same size or bigger than the target numberOfChars, then the original String is returned. An example:
```
['A', 'BB', 'CCC', 'DDDD'].each{ println it.padRight(5, '#') + it.size() }
```
    will produce output like:
```
A####1
BB###2
CCC##3
DDDD#4
```
    Parameters:
    
    numberOfChars - the total minimum number of characters of the resulting string
    
    padding - the characters used for padding
    
    Returns:
    
    the String padded to the right
    
    Since:
    
    1.0
  - public String plus(CharSequence value)
    
    Appends the String representation of the given operand to this string.
    
    Parameters:
    
    value - any CharSequence
    
    Returns:
    
    the new string with the object appended
    
    Since:
    
    2.2
  - public String plus(Object value)
    
    Appends the String representation of the given operand to this string.
    
    Parameters:
    
    value - any Object
    
    Returns:
    
    the new string with the object appended
    
    Since:
    
    1.0
  - public String previous()
    
    This method is called by the -- operator for the class String. It decrements the last character in the given string. If the character in the string is Character.MIN_VALUE it will be deleted. The empty string can't be decremented.
    
    Returns:
    
    a String with a decremented digit at the end
    
    Since:
    
    1.0
  - public List readLines()
    
    Return the lines of a String as a List of Strings.
    
    Returns:
    
    a list of lines
    
    Since:
    
    1.5.5
  - public String replaceAll(String regex, Closure closure)
    
    Replaces all occurrences of a captured group by the result of a closure on that text.
    For examples,
```
    assert "hellO wOrld" == "hello world".replaceAll("(o)") { it[0].toUpperCase() }

    assert "FOOBAR-FOOBAR-" == "foobar-FooBar-".replaceAll("(([fF][oO]{2})[bB]ar)", { Object[] it -> it[0].toUpperCase() })

    Here,
         it[0] is the global string of the matched group
         it[1] is the first string in the matched group
         it[2] is the second string in the matched group

    assert "FOO-FOO-" == "foobar-FooBar-".replaceAll("(([fF][oO]{2})[bB]ar)", { x, y, z -> z.toUpperCase() })

    Here,
         x is the global string of the matched group
         y is the first string in the matched group
         z is the second string in the matched group
```
    Note that unlike String.replaceAll(String regex, String replacement), where the replacement string treats '$' and '\' specially (for group substitution), the result of the closure is converted to a string and that value is used literally for the replacement.
    
    Parameters:
    
    regex - the capturing regex
    
    closure - the closure to apply on each captured group
    
    Returns:
    
    a String with replaced content
    
    Since:
    
    1.0
    
    See Also:
    
    Matcher#quoteReplacement(String)
    
    String#replaceAll(java.util.regex.Pattern, groovy.lang.Closure)
  - public String replaceAll(Pattern pattern, Closure closure)
    
    Replaces all occurrences of a captured group by the result of a closure call on that text.
    For examples,
```
    assert "hellO wOrld" == "hello world".replaceAll(~"(o)") { it[0].toUpperCase() }

    assert "FOOBAR-FOOBAR-" == "foobar-FooBar-".replaceAll(~"(([fF][oO]{2})[bB]ar)", { it[0].toUpperCase() })

    Here,
         it[0] is the global string of the matched group
         it[1] is the first string in the matched group
         it[2] is the second string in the matched group

    assert "FOOBAR-FOOBAR-" == "foobar-FooBar-".replaceAll(~"(([fF][oO]{2})[bB]ar)", { Object[] it -> it[0].toUpperCase() })

    Here,
         it[0] is the global string of the matched group
         it[1] is the first string in the matched group
         it[2] is the second string in the matched group

    assert "FOO-FOO-" == "foobar-FooBar-".replaceAll("(([fF][oO]{2})[bB]ar)", { x, y, z -> z.toUpperCase() })

    Here,
         x is the global string of the matched group
         y is the first string in the matched group
         z is the second string in the matched group
```
    Note that unlike String.replaceAll(String regex, String replacement), where the replacement string treats '$' and '\' specially (for group substitution), the result of the closure is converted to a string and that value is used literally for the replacement.
    
    Parameters:
    
    pattern - the capturing regex Pattern
    
    closure - the closure to apply on each captured group
    
    Returns:
    
    a String with replaced content
    
    Since:
    
    1.6.8
    
    See Also:
    
    Matcher#quoteReplacement(String)
  - public String replaceAll(Pattern pattern, String replacement)
    
    Replaces all substrings of a String that match the given compiled regular expression with the given replacement.
    Note that backslashes (\) and dollar signs ($) in the replacement string may cause the results to be different than if it were being treated as a literal replacement string; see Matcher#replaceAll. Use Matcher#quoteReplacement to suppress the special meaning of these characters, if desired.
```
assert "foo".replaceAll('o', 'X') == 'fXX'
```
    Parameters:
    
    pattern - the regex Pattern to which the string of interest is to be matched
    
    replacement - the string to be substituted for the first match
    
    Returns:
    
    The resulting String
    
    Since:
    
    1.6.1
    
    See Also:
    
    String#replaceAll(String, String)
  - public String replaceFirst(String regex, Closure closure)
    
    Replaces the first occurrence of a captured group by the result of a closure call on that text.
    For example (with some replaceAll variants thrown in for comparison purposes),
```
assert "hellO world" == "hello world".replaceFirst("(o)") { it[0].toUpperCase() } // first match
assert "hellO wOrld" == "hello world".replaceAll("(o)") { it[0].toUpperCase() }   // all matches

assert '1-FISH, two fish' == "one fish, two fish".replaceFirst(/([a-z]{3})\s([a-z]{4})/) { [one:1, two:2][it[1]] + '-' + it[2].toUpperCase() }
assert '1-FISH, 2-FISH' == "one fish, two fish".replaceAll(/([a-z]{3})\s([a-z]{4})/) { [one:1, two:2][it[1]] + '-' + it[2].toUpperCase() }
```
    Parameters:
    
    regex - the capturing regex
    
    closure - the closure to apply on the first captured group
    
    Returns:
    
    a String with replaced content
    
    Since:
    
    1.7.7
    
    See Also:
    
    Matcher#quoteReplacement(String)
    
    String#replaceFirst(java.util.regex.Pattern, groovy.lang.Closure)
  - public String replaceFirst(Pattern pattern, Closure closure)
    
    Replaces the first occurrence of a captured group by the result of a closure call on that text.
    For example (with some replaceAll variants thrown in for comparison purposes),
```
assert "hellO world" == "hello world".replaceFirst(~"(o)") { it[0].toUpperCase() } // first match
assert "hellO wOrld" == "hello world".replaceAll(~"(o)") { it[0].toUpperCase() }   // all matches

assert '1-FISH, two fish' == "one fish, two fish".replaceFirst(~/([a-z]{3})\s([a-z]{4})/) { [one:1, two:2][it[1]] + '-' + it[2].toUpperCase() }
assert '1-FISH, 2-FISH' == "one fish, two fish".replaceAll(~/([a-z]{3})\s([a-z]{4})/) { [one:1, two:2][it[1]] + '-' + it[2].toUpperCase() }
```
    Parameters:
    
    pattern - the capturing regex Pattern
    
    closure - the closure to apply on the first captured group
    
    Returns:
    
    a String with replaced content
    
    Since:
    
    1.7.7
    
    See Also:
    
    String#replaceAll(java.util.regex.Pattern, groovy.lang.Closure)
  - public String replaceFirst(Pattern pattern, String replacement)
    
    Replaces the first substring of a String that matches the given compiled regular expression with the given replacement.
    Note that backslashes (\) and dollar signs ($) in the replacement string may cause the results to be different than if it were being treated as a literal replacement string; see Matcher#replaceFirst. Use Matcher#quoteReplacement to suppress the special meaning of these characters, if desired.
```
assert "foo".replaceFirst('o', 'X') == 'fXo'
```
    Parameters:
    
    pattern - the regex Pattern to which the string of interest is to be matched
    
    replacement - the string to be substituted for the first match
    
    Returns:
    
    The resulting String
    
    Since:
    
    1.6.1
    
    See Also:
    
    String#replaceFirst(String, String)
  - public String reverse()
    
    Creates a new string which is the reverse (backwards) of this string
    
    Returns:
    
    a new string with all the characters reversed.
    
    Since:
    
    1.0
    
    See Also:
    
    StringBuilder#reverse()
  - public int size()
    
    Provide the standard Groovy size() method for String.
    
    Returns:
    
    the length of the String
    
    Since:
    
    1.0
  - public String[] split()
    
    Convenience method to split a string (with whitespace as delimiter) Like tokenize, but returns an Array of Strings instead of a List
    
    Returns:
    
    String[] result of split
    
    Since:
    
    1.5.0
  - public Object splitEachLine(String regex, Closure closure)
    
    Iterates through the given String line by line, splitting each line using the given separator. The list of tokens for each line is then passed to the given closure.
    
    Parameters:
    
    regex - the delimiting regular expression
    
    closure - a closure
    
    Returns:
    
    the last value returned by the closure
    
    Since:
    
    1.5.5
    
    See Also:
    
    String#split(String)
  - public Object splitEachLine(Pattern pattern, Closure closure)
    
    Iterates through the given String line by line, splitting each line using the given separator Pattern. The list of tokens for each line is then passed to the given closure.
    
    Parameters:
    
    pattern - the regular expression Pattern for the delimiter
    
    closure - a closure
    
    Returns:
    
    the last value returned by the closure
    
    Since:
    
    1.6.8
    
    See Also:
    
    Pattern#split(CharSequence)
  - public String stripIndent()
    
    Strip leading spaces from every line in a String. The line with the least number of leading spaces determines the number to remove. Lines only containing whitespace are ignored when calculating the number of leading spaces to strip.
```
assert '  A\n B\nC' == '   A\n  B\n C'.stripIndent()
```
    Returns:
    
    the stripped String
    
    Since:
    
    1.7.3
    
    See Also:
    
    String#stripIndent(int)
  - public String stripIndent(int numChars)
    
    Strip numChar leading characters from every line in a String.
```
assert 'DEF\n456' == '''ABCDEF\n123456'''.stripIndent(3)
```
    Parameters:
    
    numChars - The number of characters to strip
    
    Returns:
    
    the stripped String
    
    Since:
    
    1.7.3
  - public String stripMargin()
    
    Strip leading whitespace/control characters followed by '|' from every line in a String.
```
assert 'ABC\n123\n456' == '''ABC
                            |123
                            |456'''.stripMargin()
```
    Returns:
    
    the stripped String
    
    Since:
    
    1.7.3
    
    See Also:
    
    String#stripMargin(char)
  - public String stripMargin(char marginChar)
    
    Strip leading whitespace/control characters followed by marginChar from every line in a String.
```
assert 'ABC\n123\n456' == '''ABC
                            *123
                            *456'''.stripMargin('*')
```
    Parameters:
    
    marginChar - Any character that serves as margin delimiter
    
    Returns:
    
    the stripped String
    
    Since:
    
    1.7.3
  - public String stripMargin(String marginChar)
    
    Strip leading whitespace/control characters followed by marginChar from every line in a String.
    
    Parameters:
    
    marginChar - Any character that serves as margin delimiter
    
    Returns:
    
    the stripped String
    
    Since:
    
    1.7.3
    
    See Also:
    
    String#stripMargin(char)
  - public BigDecimal toBigDecimal()
    
    Parse a String into a BigDecimal
    
    Returns:
    
    a BigDecimal
    
    Since:
    
    1.0
  - public BigInteger toBigInteger()
    
    Parse a String into a BigInteger
    
    Returns:
    
    a BigInteger
    
    Since:
    
    1.0
  - public Boolean toBoolean()
    
    Converts the given string into a Boolean object. If the trimmed string is "true", "y" or "1" (ignoring case) then the result is true otherwise it is false.
    
    Returns:
    
    The Boolean value
    
    Since:
    
    1.0
  - public Character toCharacter()
    
    Converts the given string into a Character object using the first character in the string.
    
    Returns:
    
    the first Character
    
    Since:
    
    1.0
  - public Double toDouble()
    
    Parse a String into a Double
    
    Returns:
    
    a Double
    
    Since:
    
    1.0
  - public Float toFloat()
    
    Parse a String into a Float
    
    Returns:
    
    a Float
    
    Since:
    
    1.0
  - public Integer toInteger()
    
    Parse a String into an Integer
    
    Returns:
    
    an Integer
    
    Since:
    
    1.0
  - public List toList()
    
    Converts the given String into a List of strings of one character.
    
    Returns:
    
    a List of characters (a 1-character String)
    
    Since:
    
    1.0
  - public Long toLong()
    
    Parse a String into a Long
    
    Returns:
    
    a Long
    
    Since:
    
    1.0
  - public Set toSet()
    
    Converts the given String into a Set of unique strings of one character.
    Example usage:
```
assert 'groovy'.toSet() == ['v', 'g', 'r', 'o', 'y'] as Set
assert "abc".toSet().iterator()[0] instanceof String
```
    Returns:
    
    a Set of unique character Strings (each a 1-character String)
    
    Since:
    
    1.8.0
  - public Short toShort()
    
    Parse a String into a Short
    
    Returns:
    
    a Short
    
    Since:
    
    1.5.7
  - public URI toURI()
    
    Transforms a String representing a URI into a URI object.
    
    Returns:
    
    a URI
    
    Since:
    
    1.0
  - public URL toURL()
    
    Transforms a String representing a URL into a URL object.
    
    Returns:
    
    a URL
    
    Since:
    
    1.0
  - public List tokenize()
    
    Tokenize a String (with a whitespace as the delimiter).
    
    Returns:
    
    a List of tokens
    
    Since:
    
    1.0
    
    See Also:
    
    StringTokenizer#StringTokenizer(String)
  - public List tokenize(Character token)
    
    Tokenize a String based on the given character delimiter. For example:
```
char pathSep = ':'
assert "/tmp:/usr".tokenize(pathSep) == ["/tmp", "/usr"]
```
    Parameters:
    
    token - the delimiter
    
    Returns:
    
    a List of tokens
    
    Since:
    
    1.7.2
    
    See Also:
    
    StringTokenizer#StringTokenizer(String, String)
  - public List tokenize(String token)
    
    Tokenize a String based on the given string delimiter.
    
    Parameters:
    
    token - the delimiter
    
    Returns:
    
    a List of tokens
    
    Since:
    
    1.0
    
    See Also:
    
    StringTokenizer#StringTokenizer(String, String)
  - public String tr(String sourceSet, String replacementSet)
    
    Translates a string by replacing characters from the sourceSet with characters from replacementSet. If the first character from sourceSet appears in the string, it will be replaced with the first character from replacementSet. If the second character from sourceSet appears in the string, it will be replaced with the second character from replacementSet. and so on for all provided replacement characters.
    Here is an example which converts the vowels in a word from lower to uppercase:
```
assert 'hello'.tr('aeiou', 'AEIOU') == 'hEllO'
```
    A character range using regex-style syntax can also be used, e.g. here is an example which converts a word from lower to uppercase:
```
assert 'hello'.tr('a-z', 'A-Z') == 'HELLO'
```
    Hyphens at the start or end of sourceSet or replacementSet are treated as normal hyphens and are not considered to be part of a range specification. Similarly, a hyphen immediately after an earlier range is treated as a normal hyphen. So, '-x', 'x-' have no ranges while 'a-c-e' has the range 'a-c' plus the '-' character plus the 'e' character.
    Unlike the unix tr command, Groovy's tr command supports reverse ranges, e.g.:
```
assert 'hello'.tr('z-a', 'Z-A') == 'HELLO'
```
    If replacementSet is smaller than sourceSet, then the last character from replacementSet is used as the replacement for all remaining source characters as shown here:
```
assert 'Hello World!'.tr('a-z', 'A') == 'HAAAA WAAAA!'
```
    If sourceSet contains repeated characters, the last specified replacement is used as shown here:
```
assert 'Hello World!'.tr('lloo', '1234') == 'He224 W4r2d!'
```
    The functionality provided by tr can be achieved using regular expressions but tr provides a much more compact notation and efficient implementation for certain scenarios.
    
    Parameters:
    
    sourceSet - the set of characters to translate from
    
    replacementSet - the set of replacement characters
    
    Returns:
    
    The resulting translated String
    
    Since:
    
    1.7.3
    
    See Also:
    
    StringUtil#tr(String, String, String)
  - public String unexpand()
    
    Replaces sequences of whitespaces with tabs using tabStops of size 8.
    
    Returns:
    
    The unexpanded String
    
    Since:
    
    1.7.3
    
    See Also:
    
    String#unexpand(int)
  - public String unexpand(int tabStop)
    
    Replaces sequences of whitespaces with tabs.
    
    Parameters:
    
    tabStop - The number of spaces a tab represents
    
    Returns:
    
    The unexpanded String
    
    Since:
    
    1.7.3
  - public String unexpandLine(int tabStop)
    
    Replaces sequences of whitespaces with tabs within a line.
    
    Parameters:
    
    tabStop - The number of spaces a tab represents
    
    Returns:
    
    The unexpanded String
    
    Since:
    
    1.7.3

Class String

Methods Summary

Methods inherited from class java.lang.Object

Methods inherited from interface java.lang.CharSequence

Methods inherited from interface java.lang.Comparable

Methods Detail

public Object asType(Class c)

public Pattern bitwiseNegate()

public String capitalize()

public String center(Number numberOfChars)

public String center(Number numberOfChars, String padding)

public String collectReplacements(Closure transform)

public boolean contains(String text)

public int count(String text)

public byte[] decodeBase64()

public byte[] decodeHex()

public String denormalize()

public Object eachLine(Closure closure)

public Object eachLine(int firstLine, Closure closure)

public String eachMatch(String regex, Closure closure)

public String eachMatch(Pattern pattern, Closure closure)

public Process execute()

public Process execute(String[] envp, File dir)

public Process execute(List envp, File dir)

public String expand()

public String expand(int tabStop)

public String expandLine(int tabStop)

public String find(String regex)

public String find(String regex, Closure closure)

public String find(Pattern pattern)

public String find(Pattern pattern, Closure closure)

public List findAll(String regex)

public List findAll(String regex, Closure closure)

public List findAll(Pattern pattern)

public List findAll(Pattern pattern, Closure closure)

public String getAt(EmptyRange range)

public String getAt(IntRange range)

public String getAt(Range range)

public String getAt(int index)

public String getAt(Collection indices)

public char[] getChars()

public boolean isAllWhitespace()

public boolean isBigDecimal()

public boolean isBigInteger()

public boolean isCase(Object switchValue)

public boolean isDouble()

public boolean isFloat()

public boolean isInteger()

public boolean isLong()

public boolean isNumber()

public StringBuffer leftShift(Object value)

public boolean matches(Pattern pattern)

public String minus(Object target)

public String minus(Pattern pattern)

public String multiply(Number factor)

public String next()

public String normalize()

public String padLeft(Number numberOfChars)

public String padLeft(Number numberOfChars, String padding)

public String padRight(Number numberOfChars)

public String padRight(Number numberOfChars, String padding)

public String plus(CharSequence value)

public String plus(Object value)

public String previous()

public List readLines()

public String replaceAll(String regex, Closure closure)

public String replaceAll(Pattern pattern, Closure closure)

public String replaceAll(Pattern pattern, String replacement)

public String replaceFirst(String regex, Closure closure)

public String replaceFirst(Pattern pattern, Closure closure)

public String replaceFirst(Pattern pattern, String replacement)

public String reverse()

public int size()

public String[] split()

public Object splitEachLine(String regex, Closure closure)

public Object splitEachLine(Pattern pattern, Closure closure)

public String stripIndent()

public String stripIndent(int numChars)

public String stripMargin()

public String stripMargin(char marginChar)