Package: java.lang

## Interface CharSequence

- - ### Methods Summary

    Methods
    Return type | Name and parameters
    --- | ---
    `boolean` | `asBoolean()` Coerce a string (an instance of CharSequence) to a boolean value.
    `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 CharSequence into a regular expression Pattern
    `String` | `capitalize()` Convenience method to capitalize the first letter of a CharSequence (typically the first letter of a word).
    `String` | `center(Number numberOfChars)` Pad a CharSequence 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, CharSequence padding)` Pad a CharSequence to a minimum length specified by `numberOfChars`, appending the supplied padding CharSequence around the original as many times as needed keeping it centered.
    `boolean` | `contains(CharSequence text)` Provide an implementation of contains() like Collection#contains(Object) to make CharSequences more polymorphic.
    `int` | `count(CharSequence text)` Count the number of occurrences of a sub CharSequence.
    `String` | `denormalize()` Return a CharSequence with lines (separated by LF, CR/LF, or CR) terminated by the platform specific line separator.
    `String` | `digest(String algorithm)` digest the CharSequence instance
    `CharSequence` | `drop(int num)` Drops the given number of chars from the head of this CharSequence if they are available.
    `String` | `dropWhile(Closure condition)` Create a suffix of the given CharSequence by dropping as many characters as possible from the front of the original CharSequence such that calling the given closure condition evaluates to true when passed each of the dropped characters.
    `Object` | `eachLine(Closure closure)` Iterates through this CharSequence line by line.
    `Object` | `eachLine(int firstLine, Closure closure)` Iterates through this CharSequence line by line.
    `Object` | `eachMatch(CharSequence regex, Closure closure)` Process each regex group matched substring of the given CharSequence.
    `Object` | `eachMatch(Pattern pattern, Closure closure)` Process each regex group matched substring of the given pattern.
    `boolean` | `endsWithAny(CharSequence suffixes)` Tests if this CharSequence ends with any specified suffixes.
    `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(CharSequence regex)` Finds the first occurrence of a regular expression String within a String.
    `String` | `find(CharSequence regex, Closure closure)` Returns the result of calling a closure with the first occurrence of a regular expression found within a CharSequence.
    `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(CharSequence regex)` Returns a (possibly empty) list of all occurrences of a regular expression (provided as a CharSequence) found within a CharSequence.
    `List` | `findAll(CharSequence regex, Closure closure)` Finds all occurrences of a regular expression string within a CharSequence.
    `List` | `findAll(Pattern pattern)` Returns a (possibly empty) list of all occurrences of a regular expression (in Pattern format) found within a CharSequence.
    `List` | `findAll(Pattern pattern, Closure closure)` Finds all occurrences of a compiled regular expression Pattern within a CharSequence.
    `String` | `getAt(EmptyRange range)` Support the range subscript operator for CharSequence or StringBuffer with EmptyRange
    `CharSequence` | `getAt(IntRange range)` Support the range subscript operator for CharSequence with IntRange
    `CharSequence` | `getAt(Range range)` Support the range subscript operator for CharSequence
    `CharSequence` | `getAt(int index)` Support the subscript operator for CharSequence.
    `String` | `getAt(Collection indices)` Select a List of characters from a CharSequence using a Collection to identify the indices to be selected.
    `char[]` | `getChars()` Converts the given CharSequence into an array of characters.
    `boolean` | `isAllWhitespace()` True if a CharSequence only contains whitespace characters.
    `boolean` | `isBigDecimal()` Determine if a CharSequence can be parsed as a BigDecimal.
    `boolean` | `isBigInteger()` Determine if a CharSequence can be parsed as a BigInteger.
    `boolean` | `isBlank()` Tests if this CharSequence is blank
    `boolean` | `isCase(Object switchValue)` 'Case' implementation for a CharSequence, which uses equals between the toString() of the caseValue and the switchValue.
    `boolean` | `isDouble()` Determine if a CharSequence can be parsed as a Double.
    `boolean` | `isFloat()` Determine if a CharSequence can be parsed as a Float.
    `boolean` | `isInteger()` Determine if a CharSequence can be parsed as an Integer.
    `boolean` | `isLong()` Determine if a CharSequence can be parsed as a Long.
    `boolean` | `isNumber()` Determine if a CharSequence can be parsed as a Number.
    `StringBuilder` | `leftShift(Object value)` Overloads the left shift operator to provide an easy way to append multiple objects as string representations to a CharSequence.
    `boolean` | `matches(Pattern pattern)` Tells whether or not a CharSequence matches the given compiled regular expression Pattern.
    `String` | `md5()` Calculate md5 of the CharSequence instance
    `String` | `minus(Object target)` Remove a part of a CharSequence by replacing the first occurrence of target within self with '' and returns the result.
    `String` | `minus(Pattern pattern)` Remove a part of a CharSequence.
    `String` | `multiply(Number factor)` Repeat a CharSequence a certain number of times.
    `String` | `next()` This method is called by the ++ operator for the class CharSequence.
    `String` | `normalize()` Return a String with linefeeds and carriage returns normalized to linefeeds.
    `String` | `padLeft(Number numberOfChars)` Pad a CharSequence to a minimum length specified by `numberOfChars` by adding the space character to the left as many times as needed.
    `String` | `padLeft(Number numberOfChars, CharSequence padding)` Pad a CharSequence to a minimum length specified by `numberOfChars`, adding the supplied padding CharSequence as many times as needed to the left.
    `String` | `padRight(Number numberOfChars)` Pad a CharSequence to a minimum length specified by `numberOfChars` by adding the space character to the right as many times as needed.
    `String` | `padRight(Number numberOfChars, CharSequence padding)` Pad a CharSequence to a minimum length specified by `numberOfChars`, adding the supplied padding CharSequence as many times as needed to the right.
    `String` | `plus(Object value)` Appends the String representation of the given operand to this CharSequence.
    `String` | `previous()` This method is called by the -- operator for the class CharSequence.
    `List` | `readLines()` Return the lines of a CharSequence as a List of String.
    `String` | `replace(int capacity, Map replacements)` Replaces all occurrences of replacement CharSequences (supplied via a map) within a provided CharSequence with control over the internally created StringBuilder's capacity.
    `String` | `replace(Map replacements)` Replaces all occurrences of replacement CharSequences (supplied via a map) within a provided CharSequence.
    `String` | `replaceAll(CharSequence regex, Closure closure)` Replaces all occurrences of a captured group by the result of calling a closure on that text.
    `String` | `replaceAll(CharSequence regex, CharSequence replacement)` Replaces each substring of this CharSequence that matches the given regular expression with the given replacement.
    `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, CharSequence replacement)` Replaces all substrings of a CharSequence that match the given compiled regular expression with the given replacement.
    `String` | `replaceFirst(CharSequence regex, Closure closure)` Replaces the first occurrence of a captured group by the result of a closure call on that text.
    `String` | `replaceFirst(CharSequence regex, CharSequence replacement)` Replaces the first substring of this CharSequence that matches the given regular expression with the given replacement.
    `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, CharSequence replacement)` Replaces the first substring of a CharSequence that matches the given compiled regular expression with the given replacement.
    `String` | `reverse()` Creates a String which is the reverse (backwards) of this CharSequence
    `String` | `sha256()` Calculate SHA-256 of the CharSequence instance
    `int` | `size()` Provide the standard Groovy `size()` method for `CharSequence`.
    `String[]` | `split()` Convenience method to split a CharSequence (with whitespace as delimiter).
    `Object` | `splitEachLine(CharSequence regex, Closure closure)` Iterates through the given CharSequence line by line, splitting each line using the given regex delimiter.
    `Object` | `splitEachLine(Pattern pattern, Closure closure)` Iterates through the given CharSequence line by line, splitting each line using the given separator Pattern.
    `boolean` | `startsWithAny(CharSequence prefixes)` Tests if this CharSequence starts with any specified prefixes.
    `String` | `stripIndent()` Strip leading spaces from every line in a CharSequence.
    `String` | `stripIndent(int numChars)` Strip `numChar` leading characters from every line in a CharSequence.
    `String` | `stripMargin()` Strip leading whitespace/control characters followed by '|' from every line in a CharSequence.
    `String` | `stripMargin(char marginChar)` Strip leading whitespace/control characters followed by `marginChar` from every line in a CharSequence.
    `String` | `stripMargin(CharSequence marginChar)` Strip leading whitespace/control characters followed by `marginChar` from every line in a CharSequence.
    `CharSequence` | `take(int num)` Returns the first `num` elements from this CharSequence.
    `String` | `takeWhile(Closure condition)` Returns the longest prefix of this CharSequence where each element passed to the given closure evaluates to true.
    `BigDecimal` | `toBigDecimal()` Parse a CharSequence into a BigDecimal
    `BigInteger` | `toBigInteger()` Parse a CharSequence into a BigInteger
    `Double` | `toDouble()` Parse a CharSequence into a Double
    `Float` | `toFloat()` Parse a CharSequence into a Float
    `Integer` | `toInteger()` Parse a CharSequence into an Integer
    `List` | `toList()` Converts the given CharSequence into a List of Strings of one character.
    `Long` | `toLong()` Parse a CharSequence into a Long
    `Set` | `toSet()` Converts the given CharSequence into a Set of unique Strings of one character.
    `Short` | `toShort()` Parse a CharSequence into a Short
    `URI` | `toURI()` Transforms a CharSequence representing a URI into a URI object.
    `URL` | `toURL()` Transforms a CharSequence representing a URL into a URL object.
    `List` | `tokenize()` Tokenize a CharSequence (with a whitespace as the delimiter).
    `List` | `tokenize(CharSequence delimiters)` Tokenize a CharSequence based on the given CharSequence.
    `List` | `tokenize(Character delimiter)` Tokenize a CharSequence based on the given character delimiter.
    `String` | `tr(CharSequence sourceSet, CharSequence replacementSet)` Translates a CharSequence by replacing characters from the sourceSet with characters from replacementSet.
    `String` | `uncapitalize()` Convenience method to uncapitalize the first letter of a CharSequence (typically the first letter of a word).
    `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 Detail

    - #### public boolean asBoolean()

      Coerce a string (an instance of CharSequence) to a boolean value. A string is coerced to false if it is of length 0, and to true otherwise.

      Returns:
        the boolean value
      Since:
        1.7.0

    - #### public Object asType(Class c)

      Provides a method to perform custom 'dynamic' type conversion to the given class using the `as` operator.

      Parameters:
        `c` - the desired class
      Returns:
        the converted object
      Since:
        1.8.2
      See Also:
        String#asType(Class)

    - #### public Pattern bitwiseNegate()

      Turns a CharSequence into a regular expression Pattern

      Returns:
        the regular expression pattern
      Since:
        1.8.2

    - #### public String capitalize()

      Convenience method to capitalize the first letter of a CharSequence (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:
        A String containing the capitalized toString() of the CharSequence
      Since:
        1.8.2
      See Also:
        String#capitalize()

    - #### public String center(Number numberOfChars)

      Pad a CharSequence 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 result
      Returns:
        the centered toString() of this CharSequence with padded characters around it
      Since:
        1.8.2
      See Also:
        String#center(Number)

    - #### public String center(Number numberOfChars, CharSequence padding)

      Pad a CharSequence to a minimum length specified by `numberOfChars`, appending the supplied padding CharSequence 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 CharSequence
        `padding` - the characters used for padding
      Returns:
        the centered toString() of this CharSequence with padded characters around it
      Since:
        1.8.2
      See Also:
        String#center(Number, String)

    - #### public boolean contains(CharSequence text)

      Provide an implementation of contains() like Collection#contains(Object) to make CharSequences more polymorphic.

      Parameters:
        `text` - the CharSequence to look for
      Returns:
        true if this CharSequence contains the given text
      Since:
        1.8.2
      See Also:
        String#contains(String)

    - #### public int count(CharSequence text)

      Count the number of occurrences of a sub CharSequence.

      Parameters:
        `text` - a sub CharSequence
      Returns:
        the number of occurrences of the given CharSequence inside this CharSequence
      Since:
        1.8.2
      See Also:
        String#count(String)

    - #### public String denormalize()

      Return a CharSequence with lines (separated by LF, CR/LF, or CR) terminated by the platform specific line separator.

      Returns:
        the denormalized toString() of this CharSequence
      Since:
        1.8.2
      See Also:
        String#denormalize()

    - #### public String digest(String algorithm)

      digest the CharSequence instance

      Parameters:
      Returns:
        digested value
      Since:
        2.5.0
      See Also:
        MessageDigest#getInstance(java.lang.String)

    - #### public CharSequence drop(int num)

      Drops the given number of chars from the head of this CharSequence if they are available.

              def text = "Groovy"
              assert text.drop( 0 ) == 'Groovy'
              assert text.drop( 2 ) == 'oovy'
              assert text.drop( 7 ) == ''

      Parameters:
        `num` - the number of characters to drop from this String
      Returns:
        a CharSequence consisting of all characters except the first `num` ones, or else an empty String, if this CharSequence has less than `num` characters.
      Since:
        1.8.1

    - #### public String dropWhile(Closure condition)

      Create a suffix of the given CharSequence by dropping as many characters as possible from the front of the original CharSequence such that calling the given closure condition evaluates to true when passed each of the dropped characters.

          def text = "Groovy"
          assert text.dropWhile{ false } == 'Groovy'
          assert text.dropWhile{ true } == ''
          assert text.dropWhile{ it < 'Z' } == 'roovy'
          assert text.dropWhile{ it != 'v' } == 'vy'

      Parameters:
        `condition` - the closure that while continuously evaluating to true will cause us to drop elements from the front of the original CharSequence
      Returns:
        the shortest suffix of the given CharSequence such that the given closure condition evaluates to true for each element dropped from the front of the CharSequence
      Since:
        2.0.0

    - #### public Object eachLine(Closure closure)

      Iterates through this CharSequence 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.8.2
      See Also:
        String#eachLine(groovy.lang.Closure)

    - #### public Object eachLine(int firstLine, Closure closure)

      Iterates through this CharSequence 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.8.2
      See Also:
        String#eachLine(int, groovy.lang.Closure)

    - #### public Object eachMatch(CharSequence regex, Closure closure)

      Process each regex group matched substring of the given CharSequence. 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 CharSequence
        `closure` - a closure with one parameter or as much parameters as groups
      Returns:
        the source CharSequence
      Since:
        1.8.2
      See Also:
        String#eachMatch(String, groovy.lang.Closure)

    - #### public Object 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 CharSequence
      Since:
        1.8.2
      See Also:
        String#eachMatch(java.util.regex.Pattern, groovy.lang.Closure)

    - #### public boolean endsWithAny(CharSequence suffixes)

      Tests if this CharSequence ends with any specified suffixes.

      Parameters:
      Returns:
        `true` if this CharSequence ends with any specified suffixes
      Since:
        2.4.14

    - #### public String expand()

      Expands all tabs into spaces with tabStops of size 8.

      Returns:
        The expanded toString() of this CharSequence
      Since:
        1.8.2
      See Also:
        String#expand()

    - #### public String expand(int tabStop)

      Expands all tabs into spaces. If the CharSequence 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 toString() of this CharSequence
      Since:
        1.8.2
      See Also:
        String#expand(int)

    - #### public String expandLine(int tabStop)

      Expands all tabs into spaces. Assumes the CharSequence represents a single line of text.

      Parameters:
        `tabStop` - The number of spaces a tab represents
      Returns:
        The expanded toString() of this CharSequence
      Since:
        1.8.2
      See Also:
        String#expandLine(int)

    - #### public String find(CharSequence 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 "New York, NY".find(/\d{5}/) == null

      If it does match, we get the matching string back:

               assert "New York, NY 10292-0098".find(/\d{5}/) == "10292"

      If we have capture groups in our expression, we still get back the full match

               assert "New York, NY 10292-0098".find(/(\d{5})-?(\d{4})/) == "10292-0098"

      Parameters:
        `regex` - the capturing regex
      Returns:
        a String containing the matched portion, or null if the regex doesn't match
      Since:
        1.8.2
      See Also:
        String#find(java.util.regex.Pattern)

    - #### public String find(CharSequence regex, Closure closure)

      Returns the result of calling a closure with the first occurrence of a regular expression found within a CharSequence. If the regex doesn't match, the closure will not be called and find will return null.

      Parameters:
        `regex` - the capturing regex CharSequence
        `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.8.2
      See Also:
        String#find(java.util.regex.Pattern, groovy.lang.Closure)

    - #### 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 "New York, NY".find(~/\d{5}/) == null

      If it does match, we get the matching string back:

               assert "New York, NY 10292-0098".find(~/\d{5}/) == "10292"

      If we have capture groups in our expression, the groups are ignored and we get back the full match:

               assert "New York, NY 10292-0098".find(~/(\d{5})-?(\d{4})/) == "10292-0098"

      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.8.2
      See Also:
        String#find(java.util.regex.Pattern)

    - #### 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 "New York, NY".find(~/\d{5}/) { match -> return "-$match-"} == null

      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 "New York, NY 10292-0098".find(~/\d{5}/) { match -> return "-$match-"} == "-10292-"

      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 "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
               } == "10292"

      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 "New York, NY 10292-0098".find(~/(\d{5})-?(\d{4})/) { array ->
                   assert array[0] == "10292-0098"
                   assert array[1] == "10292"
                   assert array[2] == "0098"
                   return array[1]
               } == "10292"

      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 "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"
               } == "2339999"

      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.8.2
      See Also:
        String#find(java.util.regex.Pattern, groovy.lang.Closure)

    - #### public List findAll(CharSequence regex)

      Returns a (possibly empty) list of all occurrences of a regular expression (provided as a CharSequence) found within a CharSequence.

      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 "One Fish, Two Fish, Red Fish, Blue Fish".findAll(/(\w*) Fish/) == expected

      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 CharSequence
      Returns:
        a List containing all full matches of the regex within the CharSequence, an empty list will be returned if there are no matches
      Since:
        1.8.2
      See Also:
        CharSequence#findAll(Pattern)

    - #### public List findAll(CharSequence regex, Closure closure)

      Finds all occurrences of a regular expression string within a CharSequence. 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 "I could not, would not, with a fox.".findAll(/.ould/) { match -> "${match}n't"} == ["couldn't", "wouldn'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 orig.findAll(/(.)ocket/) { match, firstLetter -> "$firstLetter > $match" } == ["W > Wocket", "P > Pocket"]

      Parameters:
        `regex` - the capturing regex CharSequence
        `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 CharSequence, an empty list will be returned if there are no matches
      Since:
        1.8.2
      See Also:
        CharSequence#findAll(Pattern, groovy.lang.Closure)

    - #### public List findAll(Pattern pattern)

      Returns a (possibly empty) list of all occurrences of a regular expression (in Pattern format) found within a CharSequence.

      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 "One Fish, Two Fish, Red Fish, Blue Fish".findAll(~/(\w*) Fish/) == expected

      Parameters:
        `pattern` - the compiled regex Pattern
      Returns:
        a List containing all full matches of the Pattern within the CharSequence, an empty list will be returned if there are no matches
      Since:
        1.8.2
      See Also:
        String#findAll(java.util.regex.Pattern)

    - #### public List findAll(Pattern pattern, Closure closure)

      Finds all occurrences of a compiled regular expression Pattern within a CharSequence. 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 "I could not, would not, with a fox.".findAll(~/.ould/) { match -> "${match}n't"} == ["couldn't", "wouldn'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 orig.findAll(~/(.)ocket/) { match, firstLetter -> "$firstLetter > $match" } == ["W > Wocket", "P > Pocket"]

      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 CharSequence, an empty list will be returned if there are no matches
      Since:
        1.8.2
      See Also:
        String#findAll(java.util.regex.Pattern, groovy.lang.Closure)

    - #### public String getAt(EmptyRange range)

      Support the range subscript operator for CharSequence or StringBuffer with EmptyRange

      Parameters:
        `range` - an EmptyRange
      Returns:
        the empty String
      Since:
        1.5.0

    - #### public CharSequence getAt(IntRange range)

      Support the range subscript operator for CharSequence with IntRange

      Parameters:
        `range` - an IntRange
      Returns:
        the subsequence CharSequence
      Since:
        1.0

    - #### public CharSequence getAt(Range range)

      Support the range subscript operator for CharSequence

      Parameters:
        `range` - a Range
      Returns:
        the subsequence CharSequence
      Since:
        1.0

    - #### public CharSequence getAt(int index)

      Support the subscript operator for CharSequence.

      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 CharSequence 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 CharSequence into an array of characters.

      Returns:
        an array of characters
      Since:
        1.8.2
      See Also:
        String#getChars()

    - #### public boolean isAllWhitespace()

      True if a CharSequence only contains whitespace characters.

      Returns:
        true If all characters are whitespace characters
      Since:
        1.8.2
      See Also:
        String#isAllWhitespace()

    - #### public boolean isBigDecimal()

      Determine if a CharSequence can be parsed as a BigDecimal.

      Returns:
        true if the CharSequence can be parsed
      Since:
        1.8.2
      See Also:
        String#isBigDecimal()

    - #### public boolean isBigInteger()

      Determine if a CharSequence can be parsed as a BigInteger.

      Returns:
        true if the CharSequence can be parsed
      Since:
        1.8.2
      See Also:
        String#isBigInteger()

    - #### public boolean isBlank()

      Tests if this CharSequence is blank

      Returns:
        `true` if this CharSequence is blank
      Since:
        2.5.0

    - #### public boolean isCase(Object switchValue)

      'Case' implementation for a CharSequence, which uses equals between the toString() of the caseValue and the switchValue. This allows CharSequence values 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.8.2

    - #### public boolean isDouble()

      Determine if a CharSequence can be parsed as a Double.

      Returns:
        true if the CharSequence can be parsed
      Since:
        1.8.2
      See Also:
        String#isDouble()

    - #### public boolean isFloat()

      Determine if a CharSequence can be parsed as a Float.

      Returns:
        true if the CharSequence can be parsed
      Since:
        1.8.2
      See Also:
        String#isFloat()

    - #### public boolean isInteger()

      Determine if a CharSequence can be parsed as an Integer.

      Returns:
        true if the CharSequence can be parsed
      Since:
        1.8.2
      See Also:
        String#isInteger()

    - #### public boolean isLong()

      Determine if a CharSequence can be parsed as a Long.

      Returns:
        true if the CharSequence can be parsed
      Since:
        1.8.2
      See Also:
        String#isLong()

    - #### public boolean isNumber()

      Determine if a CharSequence can be parsed as a Number. Synonym for 'isBigDecimal()'.

      Returns:
        true if the CharSequence can be parsed
      Since:
        1.8.2
      See Also:
        CharSequence#isBigDecimal()

    - #### public StringBuilder leftShift(Object value)

      Overloads the left shift operator to provide an easy way to append multiple objects as string representations to a CharSequence.

      Parameters:
        `value` - an Object
      Returns:
        a StringBuilder built from this CharSequence
      Since:
        1.8.2

    - #### public boolean matches(Pattern pattern)

      Tells whether or not a CharSequence 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 CharSequence matches
      Since:
        1.8.2
      See Also:
        String#matches(String)

    - #### public String md5()

      Calculate md5 of the CharSequence instance

      Returns:
        md5 value
      Since:
        2.5.0

    - #### public String minus(Object target)

      Remove a part of a CharSequence by replacing the first occurrence of target within self with '' and returns the result.

      Parameters:
        `target` - an object representing the part to remove
      Returns:
        a String containing the original minus the part to be removed
      Since:
        1.8.2
      See Also:
        String#minus(Object)

    - #### public String minus(Pattern pattern)

      Remove a part of a CharSequence. This replaces the first occurrence of the 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 CharSequence a certain number of times.

      Parameters:
        `factor` - the number of times the CharSequence should be repeated
      Returns:
        a String composed of a repetition
      Since:
        1.8.2

    - #### public String next()

      This method is called by the ++ operator for the class CharSequence. It increments the last character in the given CharSequence. If the last character in the CharSequence is Character.MAX_VALUE a Character.MIN_VALUE will be appended. The empty CharSequence is incremented to a string consisting of the character Character.MIN_VALUE.

      Returns:
        a value obtained by incrementing the toString() of the CharSequence
      Since:
        1.8.2

    - #### public String normalize()

      Return a String with linefeeds and carriage returns normalized to linefeeds.

      Returns:
        the normalized toString() for the CharSequence
      Since:
        1.8.2
      See Also:
        String#normalize()

    - #### public String padLeft(Number numberOfChars)

      Pad a CharSequence 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 CharSequence
      Returns:
        the CharSequence padded to the left as a String
      Since:
        1.8.2
      See Also:
        CharSequence#padLeft(Number, CharSequence)

    - #### public String padLeft(Number numberOfChars, CharSequence padding)

      Pad a CharSequence to a minimum length specified by `numberOfChars`, adding the supplied padding CharSequence as many times as needed to the left. If the CharSequence is already the same size or bigger than the target `numberOfChars`, then the toString() of the original CharSequence 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 CharSequence
        `padding` - the characters used for padding
      Returns:
        the CharSequence padded to the left as a String
      Since:
        1.8.2
      See Also:
        String#padLeft(Number, String)

    - #### public String padRight(Number numberOfChars)

      Pad a CharSequence to a minimum length specified by `numberOfChars` by adding the space character to the right as many times as needed. If the CharSequence is already the same size or bigger than the target `numberOfChars`, then the toString() of the original CharSequence 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 CharSequence padded to the right as a String
      Since:
        1.8.2
      See Also:
        String#padRight(Number)

    - #### public String padRight(Number numberOfChars, CharSequence padding)

      Pad a CharSequence to a minimum length specified by `numberOfChars`, adding the supplied padding CharSequence as many times as needed to the right. If the CharSequence is already the same size or bigger than the target `numberOfChars`, then the toString() of the original CharSequence 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 CharSequence
        `padding` - the characters used for padding
      Returns:
        the CharSequence padded to the right as a String
      Since:
        1.8.2

    - #### public String plus(Object value)

      Appends the String representation of the given operand to this CharSequence.

      Parameters:
        `value` - any Object
      Returns:
        the original toString() of the CharSequence with the object appended
      Since:
        1.8.2

    - #### public String previous()

      This method is called by the -- operator for the class CharSequence. It decrements the last character in the given CharSequence. If the last character in the CharSequence is Character.MIN_VALUE it will be deleted. The empty CharSequence can't be decremented.

      Returns:
        a String with a decremented character at the end
      Since:
        1.8.2
      See Also:
        String#previous()

    - #### public List readLines()

      Return the lines of a CharSequence as a List of String.

      Returns:
        a list of lines
      Since:
        1.8.2

    - #### public String replace(int capacity, Map replacements)

      Replaces all occurrences of replacement CharSequences (supplied via a map) within a provided CharSequence with control over the internally created StringBuilder's capacity. This method uses a StringBuilder internally. Java auto-expands a StringBuilder's capacity if needed. In rare circumstances, the overhead involved with repeatedly expanding the StringBuilder may become significant. If you have measured the performance of your application and found this to be a significant bottleneck, use this variant to have complete control over the internally created StringBuilder's capacity.

          assert 'foobar'.replace(9, [r:'rbaz']) == 'foobarbaz'
          assert 'foobar'.replace(1, [fooba:'']) == 'r'

      Parameters:
        `capacity` - an optimization parameter, set to size after replacements or a little larger to avoid resizing overheads
        `replacements` - a map of before (key) and after (value) pairs processed in the natural order of the map
      Returns:
        a String formed from the provided CharSequence after performing all of the replacements

    - #### public String replace(Map replacements)

      Replaces all occurrences of replacement CharSequences (supplied via a map) within a provided CharSequence.

          assert 'foobar'.replace(f:'b', foo:'bar') == 'boobar'
          assert 'foobar'.replace(foo:'bar', f:'b') == 'barbar'
          def replacements = [foo:'bar', f:'b', b: 'f', bar:'boo']
          assert 'foobar'.replace(replacements) == 'barfar'

      Parameters:
        `replacements` - a map of before (key) and after (value) pairs processed in the natural order of the map
      Returns:
        a String formed from the provided CharSequence after performing all of the replacements

    - #### public String replaceAll(CharSequence regex, Closure closure)

      Replaces all occurrences of a captured group by the result of calling a closure on that text.

      Examples:

              assert "hello world".replaceAll("(o)") { it[0].toUpperCase() } == "hellO wOrld"

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

              // 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-".replaceAll("(([fF][oO]{2})[bB]ar)", { x, y, z -> z.toUpperCase() }) == "FOO-FOO-"

              // 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:
        the toString() of the CharSequence with content replaced
      Since:
        1.8.2
      See Also:
        String#replaceAll(java.util.regex.Pattern, groovy.lang.Closure)

    - #### public String replaceAll(CharSequence regex, CharSequence replacement)

      Replaces each substring of this CharSequence that matches the given regular expression with the given replacement.

      Parameters:
        `regex` - the capturing regex
        `replacement` - the string to be substituted for each match
      Returns:
        the toString() of the CharSequence with content replaced
      Since:
        1.8.2
      See Also:
        String#replaceAll(String, String)

    - #### 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".replaceAll(~"(o)") { it[0].toUpperCase() } == "hellO wOrld"

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

              // 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-".replaceAll(~"(([fF][oO]{2})[bB]ar)", { Object[] it -> it[0].toUpperCase() }) == "FOOBAR-FOOBAR-"

              // 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-".replaceAll("(([fF][oO]{2})[bB]ar)", { x, y, z -> z.toUpperCase() }) == "FOO-FOO-"

              // 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:
        the toString() of the CharSequence with replaced content
      Since:
        1.8.2
      See Also:
        Matcher#quoteReplacement(String)

    - #### public String replaceAll(Pattern pattern, CharSequence replacement)

      Replaces all substrings of a CharSequence 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 CharSequence of interest is to be matched
        `replacement` - the CharSequence to be substituted for the first match
      Returns:
        The resulting `String`
      Since:
        1.8.2
      See Also:
        String#replaceAll(java.util.regex.Pattern, String)

    - #### public String replaceFirst(CharSequence 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".replaceFirst("(o)") { it[0].toUpperCase() } == "hellO world" // first match
          assert "hello world".replaceAll("(o)") { it[0].toUpperCase() } == "hellO wOrld" // all matches

          assert "one fish, two fish".replaceFirst(/([a-z]{3})\s([a-z]{4})/) { [one:1, two:2][it[1]] + '-' + it[2].toUpperCase() } == '1-FISH, two fish'
          assert "one fish, two fish".replaceAll(/([a-z]{3})\s([a-z]{4})/) { [one:1, two:2][it[1]] + '-' + it[2].toUpperCase() } == '1-FISH, 2-FISH'

      Parameters:
        `regex` - the capturing regex
        `closure` - the closure to apply on the first captured group
      Returns:
        a CharSequence with replaced content
      Since:
        1.8.2
      See Also:
        String#replaceFirst(String, groovy.lang.Closure)

    - #### public String replaceFirst(CharSequence regex, CharSequence replacement)

      Replaces the first substring of this CharSequence that matches the given regular expression with the given replacement.

      Parameters:
        `regex` - the capturing regex
        `replacement` - the CharSequence to be substituted for each match
      Returns:
        a CharSequence with replaced content
      Since:
        1.8.2
      See Also:
        String#replaceFirst(String, String)

    - #### 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 CharSequence with replaced content
      Since:
        1.8.2

    - #### public String replaceFirst(Pattern pattern, CharSequence replacement)

      Replaces the first substring of a CharSequence 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 CharSequence of interest is to be matched
        `replacement` - the CharSequence to be substituted for the first match
      Returns:
        The resulting `String`
      Since:
        1.8.2
      See Also:
        String#replaceFirst(java.util.regex.Pattern, String)

    - #### public String reverse()

      Creates a String which is the reverse (backwards) of this CharSequence

      Returns:
        a new String with all the characters reversed.
      Since:
        1.8.2
      See Also:
        String#reverse()

    - #### public String sha256()

      Calculate SHA-256 of the CharSequence instance

      Returns:
        SHA-256 value
      Since:
        2.5.3

    - #### public int size()

      Provide the standard Groovy `size()` method for `CharSequence`.

      Returns:
        the length of the CharSequence
      Since:
        1.8.2

    - #### public String[] split()

      Convenience method to split a CharSequence (with whitespace as delimiter). Similar to tokenize, but returns an Array of String instead of a List.

      Returns:
        String[] result of split
      Since:
        1.8.2
      See Also:
        String#split()

    - #### public Object splitEachLine(CharSequence regex, Closure closure)

      Iterates through the given CharSequence line by line, splitting each line using the given regex delimiter. 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.8.2
      See Also:
        CharSequence#splitEachLine(java.util.regex.Pattern, groovy.lang.Closure)

    - #### public Object splitEachLine(Pattern pattern, Closure closure)

      Iterates through the given CharSequence 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.8.2

    - #### public boolean startsWithAny(CharSequence prefixes)

      Tests if this CharSequence starts with any specified prefixes.

      Parameters:
      Returns:
        `true` if this CharSequence starts with any specified prefixes.
      Since:
        2.4.14

    - #### public String stripIndent()

      Strip leading spaces from every line in a CharSequence. 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 toString() of the CharSequence
      Since:
        1.8.2
      See Also:
        String#stripIndent()

    - #### public String stripIndent(int numChars)

      Strip `numChar` leading characters from every line in a CharSequence.

          assert 'DEF\n456' == '''ABCDEF\n123456'''.stripIndent(3)

      Parameters:
        `numChars` - The number of characters to strip
      Returns:
        the stripped String
      Since:
        1.8.2

    - #### public String stripMargin()

      Strip leading whitespace/control characters followed by '|' from every line in a CharSequence.

          assert 'ABC\n123\n456' == '''ABC
                                      |123
                                      |456'''.stripMargin()

      Returns:
        the stripped String
      Since:
        1.8.2
      See Also:
        CharSequence#stripMargin(char)

    - #### public String stripMargin(char marginChar)

      Strip leading whitespace/control characters followed by `marginChar` from every line in a CharSequence.

          assert 'ABC\n123\n456' == '''ABC
                                      *123
                                      *456'''.stripMargin('*')

      Parameters:
        `marginChar` - Any character that serves as margin delimiter
      Returns:
        the stripped String
      Since:
        1.8.2
      See Also:
        String#stripMargin(char)

    - #### public String stripMargin(CharSequence marginChar)

      Strip leading whitespace/control characters followed by `marginChar` from every line in a CharSequence.

      Parameters:
        `marginChar` - Any character that serves as margin delimiter
      Returns:
        the stripped CharSequence
      Since:
        1.8.2
      See Also:
        String#stripMargin(String)

    - #### public CharSequence take(int num)

      Returns the first `num` elements from this CharSequence.

          def text = "Groovy"
          assert text.take( 0 ) == ''
          assert text.take( 2 ) == 'Gr'
          assert text.take( 7 ) == 'Groovy'

      Parameters:
        `num` - the number of chars to take from this CharSequence
      Returns:
        a CharSequence consisting of the first `num` chars, or else the whole CharSequence if it has less then `num` elements.
      Since:
        1.8.1

    - #### public String takeWhile(Closure condition)

      Returns the longest prefix of this CharSequence where each element passed to the given closure evaluates to true.

          def text = "Groovy"
          assert text.takeWhile{ it < 'A' } == ''
          assert text.takeWhile{ it < 'Z' } == 'G'
          assert text.takeWhile{ it != 'v' } == 'Groo'
          assert text.takeWhile{ it < 'z' } == 'Groovy'

      Parameters:
        `condition` - the closure that must evaluate to true to continue taking elements
      Returns:
        a prefix of elements in the CharSequence where each element passed to the given closure evaluates to true
      Since:
        2.0.0

    - #### public BigDecimal toBigDecimal()

      Parse a CharSequence into a BigDecimal

      Returns:
        a BigDecimal
      Since:
        1.8.2
      See Also:
        String#toBigDecimal()

    - #### public BigInteger toBigInteger()

      Parse a CharSequence into a BigInteger

      Returns:
        a BigInteger
      Since:
        1.8.2
      See Also:
        String#toBigInteger()

    - #### public Double toDouble()

      Parse a CharSequence into a Double

      Returns:
        a Double
      Since:
        1.8.2
      See Also:
        String#toDouble()

    - #### public Float toFloat()

      Parse a CharSequence into a Float

      Returns:
        a Float
      Since:
        1.8.2
      See Also:
        String#toFloat()

    - #### public Integer toInteger()

      Parse a CharSequence into an Integer

      Returns:
        an Integer
      Since:
        1.8.2

    - #### public List toList()

      Converts the given CharSequence into a List of Strings of one character.

      Returns:
        a List of characters (a 1-character String)
      Since:
        1.8.2
      See Also:
        String#toSet()

    - #### public Long toLong()

      Parse a CharSequence into a Long

      Returns:
        a Long
      Since:
        1.8.2
      See Also:
        String#toLong()

    - #### public Set toSet()

      Converts the given CharSequence into a Set of unique Strings of one character.

      Returns:
        a Set of unique characters (each a 1-character String)
      Since:
        1.8.2
      See Also:
        String#toSet()

    - #### public Short toShort()

      Parse a CharSequence into a Short

      Returns:
        a Short
      Since:
        1.8.2

    - #### public URI toURI()

      Transforms a CharSequence representing a URI into a URI object.

      Returns:
        a URI
      Since:
        1.8.2

    - #### public URL toURL()

      Transforms a CharSequence representing a URL into a URL object.

      Returns:
        a URL
      Since:
        1.8.2

    - #### public List tokenize()

      Tokenize a CharSequence (with a whitespace as the delimiter).

      Returns:
        a List of tokens
      Since:
        1.8.2
      See Also:
        StringTokenizer#StringTokenizer(String)

    - #### public List tokenize(CharSequence delimiters)

      Tokenize a CharSequence based on the given CharSequence. Each character in the CharSequence is a separate delimiter.

      Parameters:
        `delimiters` - the delimiters
      Returns:
        a List of tokens
      Since:
        1.8.2
      See Also:
        StringTokenizer#StringTokenizer(String, String)

    - #### public List tokenize(Character delimiter)

      Tokenize a CharSequence based on the given character delimiter. For example:

          char pathSep = ':'
          assert "/tmp:/usr".tokenize(pathSep) == ["/tmp", "/usr"]

      Parameters:
        `delimiter` - the delimiter
      Returns:
        a List of tokens
      Since:
        1.8.2
      See Also:
        StringTokenizer#StringTokenizer(String, String)

    - #### public String tr(CharSequence sourceSet, CharSequence replacementSet)

      Translates a CharSequence by replacing characters from the sourceSet with characters from replacementSet. If the first character from sourceSet appears in the CharSequence, it will be replaced with the first character from replacementSet. If the second character from sourceSet appears in the CharSequence, 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.8.2
      See Also:
        StringUtil#tr(String, String, String)

    - #### public String uncapitalize()

      Convenience method to uncapitalize the first letter of a CharSequence (typically the first letter of a word). Example usage:

          assert 'H'.uncapitalize() == 'h'
          assert 'Hello'.uncapitalize() == 'hello'
          assert 'Hello world'.uncapitalize() == 'hello world'
          assert 'Hello World'.uncapitalize() == 'hello World'
          assert 'hello world' ==
              'Hello World'.split(' ').collect{ it.uncapitalize() }.join(' ')

      Returns:
        A String containing the uncapitalized toString() of the CharSequence
      Since:
        2.4.8

    - #### public String unexpand()

      Replaces sequences of whitespaces with tabs using tabStops of size 8.

      Returns:
        an unexpanded String
      Since:
        1.8.2
      See Also:
        String#unexpand()

    - #### public String unexpand(int tabStop)

      Replaces sequences of whitespaces with tabs.

      Parameters:
        `tabStop` - The number of spaces a tab represents
      Returns:
        an unexpanded String
      Since:
        1.8.2

    - #### public String unexpandLine(int tabStop)

      Replaces sequences of whitespaces with tabs within a line.

      Parameters:
        `tabStop` - The number of spaces a tab represents
      Returns:
        an unexpanded String
      Since:
        1.8.2