[Java] Class StringGroovyMethods

public class StringGroovyMethods
extends DefaultGroovyMethodsSupport

Method Detail

public static boolean asBoolean(CharSequence chars)

Coerces a CharSequence to a boolean value. A sequence string is coerced to false if it is of length 0, and to true otherwise.

Parameters:

chars - the character sequence

Returns:

the boolean value

Since:

1.7.0

public static boolean asBoolean(Matcher matcher)

Coerces a Matcher instance to a boolean value.

Parameters:

matcher - the matcher

Returns:

the boolean value

Since:

1.7.0

<T> public static T asType(CharSequence self, Class<T> c)

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

Parameters:

self - a CharSequence

c - the desired class

Returns:

the converted object

Since:

1.8.2

See Also:

asType(String,Class)

<T> @SuppressWarnings("unchecked") public static T asType(GString self, Class<T> c)

Converts the GString to a File, or delegates to the default DefaultGroovyMethods.asType.

Parameters:

self - a GString

c - the desired class

Returns:

the converted object

Since:

1.5.0

<T> @SuppressWarnings("unchecked") public static T asType(String self, Class<T> 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

If any other type is given, the call is delegated to DefaultGroovyMethods.asType.

Parameters:

self - a String

c - the desired class

Returns:

the converted object

Since:

1.0

public static Pattern bitwiseNegate(CharSequence self)

Turns a CharSequence into a regular expression Pattern.

Parameters:

self - a String to convert into a regular expression

Returns:

the regular expression pattern

Since:

1.8.2

public static String capitalize(CharSequence self)

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(' ')
 

Parameters:

self - The CharSequence to capitalize

Returns:

A String containing the capitalized toString() of the CharSequence

Since:

1.8.2

public static String center(CharSequence self, Number numberOfChars)

Pads 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:

self - a CharSequence object

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

public static String center(CharSequence self, 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:

self - a CharSequence object

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

public static String collectReplacements(String self, @ClosureParams(value=FromString.class, conflictResolutionStrategy=PickFirstResolver.class, options={"String", "Character"}) Closure<String> transform)

Iterates 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 "Groovy".collectReplacements{ it.equalsIgnoreCase('O') ? '_O_' : null } == 'Gr_O__O_vy'
 assert "Groovy".collectReplacements{ char c -> c == 'o' ? '_O_' : null } == 'Gr_O__O_vy'
 assert "Groovy".collectReplacements{ Character c -> c == 'o' ? '_O_' : null } == 'Gr_O__O_vy'
 assert "B&W".collectReplacements{ it == '&' ? '&' : null } == 'B&W'
 

Parameters:

self - the original String

Returns:

A new string in which all characters that require escaping have been replaced with the corresponding replacements as determined by the transform Closure.

Since:

2.1.0

public static String collectReplacements(String self, List<Function<Character, Optional<String>>> transforms)

Iterates through this String a character at a time collecting either the original character or a transformed replacement String. The return value is an Optional either having a value equal to the transformed replacement String or empty() to indicate that no transformation is required.

 import java.util.function.Function
 import static java.util.Optional.*

 Function<Character, Optional<String>> xform1 = s -> s == 'o' ? of('_O') : empty()
 Function<Character, Optional<String>> xform2 = { it == 'G' ? of('G_') : empty() }
 assert "Groovy".collectReplacements([xform1, xform2]) == 'G_r_O_Ovy'
 

Parameters:

self - the original String

transforms - one or more transforms which potentially convert a single character to a transformed string

Returns:

A new string in which all characters that require escaping have been replaced with the corresponding replacements as determined by the transform function.

Since:

3.0.6

public static boolean contains(CharSequence self, CharSequence text)

Provides an implementation of contains() like Collection.contains to make CharSequences more polymorphic.

Parameters:

self - a CharSequence

text - the CharSequence to look for

Returns:

true if this CharSequence contains the given text

Since:

1.8.2

public static boolean containsIgnoreCase(CharSequence self, CharSequence searchString)

Checks whether this CharSequence contains the searchString ignoring the caseConsiderations.

Parameters:

self - the original CharSequence

searchString - CharSequence being checked against this

Returns:

true if the character sequence represented by the argument exists in this CharSequence ignoring the case considerations. false otherwise. Returns false if the argument is null

Since:

3.0.0

public static int count(CharSequence self, CharSequence text)

Counts the number of occurrences of a sub CharSequence.

Parameters:

self - a CharSequence

text - a sub CharSequence

Returns:

the number of occurrences of the given CharSequence inside this CharSequence

Since:

1.8.2

public static String denormalize(CharSequence self)

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

Parameters:

self - a CharSequence object

Returns:

the denormalized toString() of this CharSequence

Since:

1.8.2

public static CharSequence drop(CharSequence self, 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:

self - the original CharSequence

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 static String drop(GString self, int num)

A GString variant of the equivalent CharSequence method.

Parameters:

self - the original GString

num - the number of characters to drop from this GString

Returns:

a String consisting of all characters except the first num ones, or else an empty String, if the toString() of this GString has less than num characters.

Since:

2.3.7

See Also:

drop(String,int)

public static String drop(String self, int num)

A String variant of the equivalent CharSequence method.

Parameters:

self - the original String

num - the number of characters to drop from this String

Returns:

a String consisting of all characters except the first num ones, or else an empty String, if the String has less than num characters.

Since:

2.5.5

See Also:

drop(CharSequence,int)

public static CharSequence dropRight(CharSequence self, int num)

Returns new CharSequence after removing the right num chars. Returns empty String if the num is greater than the length of the CharSequence.

 def text = "groovy"

 assert text.dropRight(  3 ) == 'gro'
 assert text.dropRight(  6 ) == ''
 assert text.dropRight(  0 ) == 'groovy'
 assert text.dropRight( -1 ) == 'groovy'
 assert text.dropRight( 10 ) == ''
 

Parameters:

self - the original CharSequence

num - number of characters

Returns:

CharSequence after removing the right num chars and empty of the num is greater than the length of the CharSequence

Since:

3.0.0

public static String dropRight(String self, int num)

A String variant of the equivalent CharSequence method dropRight(CharSequence,int).

Parameters:

self - the original CharSequence

num - number of characters

Returns:

String after removing the right num chars and empty of the num is greater than the length of the CharSequence

Since:

3.0.0

public static String dropRight(GString self, int num)

A GString variant of the equivalent CharSequence method dropRight(CharSequence,int).

Parameters:

self - the original CharSequence

num - number of characters

Returns:

String after removing the right num chars and empty of the num is greater than the length of the CharSequence

Since:

3.0.0

@SuppressWarnings("unchecked") public static String dropWhile(CharSequence self, @ClosureParams(value=FromString.class, conflictResolutionStrategy=PickFirstResolver.class, options={"String", "Character"}) Closure condition)

Creates 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:

self - the original CharSequence

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 static String dropWhile(GString self, @ClosureParams(value=FromString.class, conflictResolutionStrategy=PickFirstResolver.class, options={"String", "Character"}) Closure condition)

A GString variant of the equivalent CharSequence method.

Parameters:

self - the original GString

condition - the closure that while continuously evaluating to true will cause us to drop elements from the front of the original GString

Returns:

the shortest suffix of the given GString such that the given closure condition evaluates to true for each element dropped from the front of the CharSequence

Since:

2.3.7

See Also:

dropWhile(CharSequence,Closure)

@Deprecated public static CharSequence dropWhile$$bridge(CharSequence self, @ClosureParams(value=FromString.class, conflictResolutionStrategy=PickFirstResolver.class, options={"String", "Character"}) Closure condition)

<T> public static T eachLine(CharSequence self, @ClosureParams(value=FromString.class, options={"String","String,Integer"}) Closure<T> 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.

throws:

java.io.IOException if an error occurs

Parameters:

self - a CharSequence

closure - a closure

Returns:

the last value returned by the closure

Since:

1.8.2

<T> public static T eachLine(CharSequence self, int firstLine, @ClosureParams(value=FromString.class, options={"String","String,Integer"}) Closure<T> 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.

throws:

java.io.IOException if an error occurs

Parameters:

self - a CharSequence

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

<T extends CharSequence> public static T eachMatch(T self, CharSequence regex, @ClosureParams(value=FromString.class, options={"List","String[]"}) Closure closure)

Processes 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:

self - the source CharSequence

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:

eachMatch(String,String,Closure)

<T extends CharSequence> public static T eachMatch(T self, Pattern pattern, @ClosureParams(value=FromString.class, options={"List","String[]"}) Closure closure)

Processes 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:

self - the source CharSequence

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:

eachMatch(String,Pattern,Closure)

public static String eachMatch(String self, Pattern pattern, @ClosureParams(value=FromString.class, options={"List","String[]"}) Closure closure)

Processes 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:

self - the source string

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 static String eachMatch(String self, String regex, @ClosureParams(value=FromString.class, options={"List","String[]"}) 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:

self - the source string

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 static boolean endsWithAny(CharSequence self, CharSequence suffixes)

Tests if this CharSequence ends with any specified suffixes.

Parameters:

suffixes - the suffixes.

Returns:

true if this CharSequence ends with any specified suffixes

Since:

2.4.14

public static boolean endsWithIgnoreCase(CharSequence self, CharSequence searchString)

Checks whether this CharSequence ends with the searchString ignoring the case considerations.

Parameters:

self - the original CharSequence

searchString - CharSequence bring checked against this

Returns:

true if the character sequence represented by the argument is a suffix of this CharSequence ignoring the case considerations. false otherwise. Returns false if the argument is null

Since:

3.0.0

public static String expand(CharSequence self)

Expands all tabs into spaces with tabStops of size 8.

Parameters:

self - A CharSequence to expand

Returns:

The expanded toString() of this CharSequence

Since:

1.8.2

public static String expand(CharSequence self, 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:

self - A CharSequence to expand

tabStop - The number of spaces a tab represents

Returns:

The expanded toString() of this CharSequence

Since:

1.8.2

public static String expandLine(CharSequence self, int tabStop)

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

Parameters:

self - A line to expand

tabStop - The number of spaces a tab represents

Returns:

The expanded toString() of this CharSequence

Since:

1.8.2

public static String find(CharSequence self, 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:

self - a CharSequence

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:

find(CharSequence,Pattern)

public static String find(CharSequence self, CharSequence regex, @ClosureParams(value=FromString.class, options={"java.util.List","java.lang.String[]"}) 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:

self - a CharSequence

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:

find(CharSequence,Pattern,Closure)

public static String find(CharSequence self, 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:

self - a CharSequence

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

public static String find(CharSequence self, Pattern pattern, @ClosureParams(value=FromString.class, options={"java.util.List","java.lang.String[]"}) 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:

self - a CharSequence

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

public static List<String> findAll(CharSequence self, 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:

self - a CharSequence

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:

findAll(CharSequence,Pattern)

<T> public static List<T> findAll(CharSequence self, CharSequence regex, @ClosureParams(value=FromString.class, options={"java.util.List","java.lang.String[]"}) Closure<T> 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:

self - a CharSequence

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:

findAll(CharSequence,Pattern,Closure)

public static List<String> findAll(CharSequence self, 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:

self - a CharSequence

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

<T> public static List<T> findAll(CharSequence self, Pattern pattern, @ClosureParams(value=FromString.class, options={"java.util.List","java.lang.String[]"}) Closure<T> 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:

self - a CharSequence

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

public static String getAt(CharSequence self, Collection indices)

Selects a List of characters from a CharSequence using a Collection to identify the indices to be selected.

Parameters:

self - a CharSequence

indices - a Collection of indices

Returns:

a String consisting of the characters at the given indices

Since:

1.0

public static String getAt(CharSequence self, EmptyRange range)

Supports the range subscript operator for CharSequence or StringBuffer with EmptyRange

Parameters:

self - a CharSequence

range - an EmptyRange

Returns:

the empty String

Since:

1.5.0

public static CharSequence getAt(CharSequence self, int index)

Supports the subscript operator for CharSequence.

Parameters:

self - a CharSequence

index - the index of the Character to get

Returns:

the Character at the given index

Since:

1.0

public static String getAt(GString self, int index)

Supports the subscript operator for GString.

Parameters:

self - a GString

index - the index of the Character to get

Returns:

the Character at the given index

Since:

2.3.7

public static CharSequence getAt(CharSequence self, IntRange range)

Supports the range subscript operator for CharSequence with IntRange.

Parameters:

self - a CharSequence

range - an IntRange

Returns:

the subsequence CharSequence

Since:

1.0

public static String getAt(GString self, IntRange range)

Supports the range subscript operator for GString with IntRange.

Parameters:

self - a GString

range - an IntRange

Returns:

the String of characters corresponding to the provided range

Since:

2.3.7

public static CharSequence getAt(CharSequence self, Range range)

Supports the range subscript operator for CharSequence.

Parameters:

self - a CharSequence

range - a Range

Returns:

the subsequence CharSequence

Since:

1.0

public static String getAt(GString self, Range range)

Supports the range subscript operator for GString.

Parameters:

self - a GString

range - a Range

Returns:

the String of characters corresponding to the provided range

Since:

2.3.7

public static List getAt(Matcher self, Collection indices)

Selects a List of values from a Matcher using a Collection to identify the indices to be selected.

Parameters:

self - a Matcher

indices - a Collection of indices

Returns:

a String of the values at the given indices

Since:

1.6.0

public static Object getAt(Matcher self, int index)

Supports the subscript operator, e.g. matcher[index], for a Matcher.

For an example using no group match,

    def p = /ab[d|f]/
    def m = "abcabdabeabf" =~ p
    assert 2 == m.count
    assert 2 == m.size() // synonym for m.getCount()
    assert ! m.hasGroup()
    assert 0 == m.groupCount()
    def matches = ["abd", "abf"]
    for (i in 0..<m.count) {
      assert m[i] == matches[i]
    }
 

For an example using group matches,

    def p = /(?:ab([c|d|e|f]))/
    def m = "abcabdabeabf" =~ p
    assert 4 == m.count
    assert m.hasGroup()
    assert 1 == m.groupCount()
    def matches = [["abc", "c"], ["abd", "d"], ["abe", "e"], ["abf", "f"]]
    for (i in 0..<m.count) {
      assert m[i] == matches[i]
    }
 

For another example using group matches,

    def m = "abcabdabeabfabxyzabx" =~ /(?:ab([d|x-z]+))/
    assert 3 == m.count
    assert m.hasGroup()
    assert 1 == m.groupCount()
    def matches = [["abd", "d"], ["abxyz", "xyz"], ["abx", "x"]]
    for (i in 0..<m.count) {
      assert m[i] == matches[i]
    }
 

Parameters:

self - a Matcher

index - an index

Returns:

object a matched String if no groups matched, list of matched groups otherwise.

Since:

1.0

public static String getAt(String self, int index)

Supports the subscript operator for String.

Parameters:

self - a String

index - the index of the Character to get

Returns:

the Character at the given index

Since:

1.0

public static String getAt(String self, IntRange range)

Supports the range subscript operator for String with IntRange.

Parameters:

self - a String

range - an IntRange

Returns:

the resulting String

Since:

1.0

public static String getAt(String self, Range range)

Supports the range subscript operator for String.

Parameters:

self - a String

range - a Range

Returns:

a substring corresponding to the Range

Since:

1.0

public static char[] getChars(CharSequence self)

Converts the given CharSequence into an array of characters.

Parameters:

self - a CharSequence

Returns:

an array of characters

Since:

1.8.2

public static int getCount(Matcher self)

Finds the number of Strings matched to the given Matcher.

Parameters:

self - a Matcher

Returns:

int the number of Strings matched to the given matcher.

Since:

1.0

public static boolean hasGroup(Matcher self)

Checks whether a Matcher contains a group or not.

Parameters:

self - a Matcher

Returns:

boolean true if matcher contains at least one group.

Since:

1.0

public boolean hasNext()

public static boolean isAllWhitespace(CharSequence self)

Returns true if a CharSequence only contains whitespace characters.

Parameters:

self - The CharSequence to check the characters in

Returns:

true If all characters are whitespace characters

Since:

1.8.2

public static Boolean isAtLeast(String left, String right)

Compares a String representing a number to another. A fluent API style alias for compareTo on BigDecimal.

Parameters:

left - a String representing a number

right - a String representing a number

Returns:

true if the value represented by left is equal to or bigger than the value represented by right

Since:

3.0.1

public static boolean isBigDecimal(CharSequence self)

Determines if a CharSequence can be parsed as a BigDecimal.

Parameters:

self - a CharSequence

Returns:

true if the CharSequence can be parsed

Since:

1.8.2

public static boolean isBigInteger(CharSequence self)

Determines if a CharSequence can be parsed as a BigInteger.

Parameters:

self - a CharSequence

Returns:

true if the CharSequence can be parsed

Since:

1.8.2

public static boolean isBlank(CharSequence self)

Tests if this CharSequence is blank.

Returns:

true if this CharSequence is blank

Since:

2.5.0

See Also:

isAllWhitespace(CharSequence)

public static boolean isCase(CharSequence caseValue, 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:

caseValue - the case value

switchValue - the switch value

Returns:

true if the switchValue's toString() equals the caseValue

Since:

1.8.2

public static boolean isCase(Pattern caseValue, Object switchValue)

'Case' implementation for the Pattern class, which allows testing a String against a number of regular expressions.

For example:

switch( str ) {
   case ~/one/ :
     // the regex 'one' matches the value of str
 }
 

Note that this returns true for the case where both the pattern and the 'switch' values are null.

Parameters:

caseValue - the case value

switchValue - the switch value

Returns:

true if the switchValue is deemed to match the caseValue

Since:

1.0

public static boolean isDouble(CharSequence self)

Determines if a CharSequence can be parsed as a Double.

Parameters:

self - a CharSequence

Returns:

true if the CharSequence can be parsed

Since:

1.8.2

public static boolean isFloat(CharSequence self)

Determines if a CharSequence can be parsed as a Float.

Parameters:

self - a CharSequence

Returns:

true if the CharSequence can be parsed

Since:

1.8.2

public static boolean isInteger(CharSequence self)

Determines if a CharSequence can be parsed as an Integer.

Parameters:

self - a CharSequence

Returns:

true if the CharSequence can be parsed

Since:

1.8.2

public static boolean isLong(CharSequence self)

Determines if a CharSequence can be parsed as a Long.

Parameters:

self - a CharSequence

Returns:

true if the CharSequence can be parsed

Since:

1.8.2

public static boolean isNumber(CharSequence self)

Determines if a CharSequence can be parsed as a Number.

Parameters:

self - a CharSequence

Returns:

true if the CharSequence can be parsed

Since:

1.8.2

See Also:

isBigDecimal(CharSequence)

public static Iterator iterator(Matcher self)

Returns an Iterator which traverses each match.

Parameters:

self - a Matcher object

Returns:

an Iterator for a Matcher

Since:

1.0

See Also:

Matcher.group

public static StringBuilder leftShift(CharSequence self, Object value)

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

Parameters:

self - a CharSequence

value - an Object

Returns:

a StringBuilder built from this CharSequence

Since:

1.8.2

public static StringBuffer leftShift(String self, Object value)

public static StringBuffer leftShift(StringBuffer self, Object value)

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

Parameters:

self - a StringBuffer

value - a value to append

Returns:

the StringBuffer on which this operation was invoked

Since:

1.0

public static StringBuilder leftShift(StringBuilder self, Object value)

Overloads the left shift operator to provide syntactic sugar for appending to a StringBuilder.

Parameters:

self - a StringBuilder

value - an Object

Returns:

the original StringBuilder

Since:

1.8.2

public static boolean matches(CharSequence self, Pattern pattern)

Determines if a CharSequence matches the given regular expression.

Parameters:

self - the CharSequence that is to be matched

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

public static boolean matchesPartially(Matcher self)

Given a matcher that matches a string against a pattern, returns true when the string matches the pattern or if a longer string, could match the pattern. For example:

     def emailPattern = /\w+@\w+\.\w{2,}/

     def matcher = "john@doe" =~ emailPattern
     assert matcher.matchesPartially()

     matcher = "[email protected]" =~ emailPattern
     assert matcher.matchesPartially()

     matcher = "john@@" =~ emailPattern
     assert !matcher.matchesPartially()
 

Parameters:

self - the Matcher

Returns:

true if more input to the String could make the matcher match the associated pattern, false otherwise.

Since:

2.0.0

public static String minus(CharSequence self, Object target)

Removes a part of a CharSequence by replacing the first occurrence of target within self with empty string and returns the result.

Parameters:

self - a CharSequence

target - an object representing the part to remove

Returns:

a String containing the original minus the part to be removed

Since:

1.8.2

public static String minus(CharSequence self, Pattern pattern)

Removes a part of a CharSequence. This replaces the first occurrence of the pattern within self with empty string and returns the result.

Parameters:

self - a String

pattern - a Pattern representing the part to remove

Returns:

a String minus the part to be removed

Since:

2.2.0

public static String multiply(CharSequence self, Number factor)

Repeats a CharSequence a certain number of times.

throws:

IllegalArgumentException if the number of repetitions is < 0

Parameters:

self - a CharSequence to be repeated

factor - the number of times the CharSequence should be repeated

Returns:

a String composed of a repetition

Since:

1.8.2

public Object next()

public static String next(CharSequence self)

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

Parameters:

self - a CharSequence

Returns:

a value obtained by incrementing the toString() of the CharSequence

Since:

1.8.2

public static String normalize(CharSequence self)

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

Parameters:

self - a CharSequence object

Returns:

the normalized toString() for the CharSequence

Since:

1.8.2

public static String padLeft(CharSequence self, Number numberOfChars)

Pads 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:

self - a CharSequence object

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:

padLeft(CharSequence,Number,CharSequence)

public static String padLeft(CharSequence self, Number numberOfChars, CharSequence padding)

Pads 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:

self - a CharSequence object

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

public static String padRight(CharSequence self, Number numberOfChars)

Pads 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:

self - a CharSequence object

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

public static String padRight(CharSequence self, Number numberOfChars, CharSequence padding)

Pads 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:

self - a CharSequence object

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 static String plus(CharSequence left, Object right)

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

Parameters:

left - a CharSequence

right - any Object

Returns:

the original toString() of the CharSequence with the object appended

Since:

1.8.2

public static String plus(Number left, String right)

Appends a String to the string representation of this number.

Parameters:

left - a Number

right - a String

Returns:

a String

Since:

1.0

public static String plus(String left, CharSequence right)

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

Parameters:

left - a String

right - any CharSequence

Returns:

the new string with the object appended

Since:

2.2

public static String plus(StringBuffer left, String right)

Appends a String to this StringBuffer.

Parameters:

left - a StringBuffer

right - a String

Returns:

a String

Since:

1.0

public static String previous(CharSequence self)

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

Parameters:

self - a CharSequence

Returns:

a String with a decremented character at the end

Since:

1.8.2

public static void putAt(StringBuffer self, EmptyRange range, Object value)

Supports the range subscript operator for StringBuffer.

Parameters:

self - a StringBuffer

range - a Range

value - the object that's toString() will be inserted

Since:

1.0

public static void putAt(StringBuffer self, IntRange range, Object value)

Supports the range subscript operator for StringBuffer. Index values are treated as characters within the buffer.

Parameters:

self - a StringBuffer

range - a Range

value - the object that's toString() will be inserted

Since:

1.0

public static List<String> readLines(CharSequence self)

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

Parameters:

self - a CharSequence object

Returns:

a list of lines

Since:

1.8.2

public void remove()

public static String replace(CharSequence self, Map<CharSequence, CharSequence> 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:

self - a CharSequence

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

Since:

2.5.0

public static String replace(CharSequence self, int capacity, Map<CharSequence, CharSequence> 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:

self - a CharSequence

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

Since:

2.5.0

public static String replaceAll(CharSequence self, CharSequence regex, CharSequence replacement)

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

throws:

java.util.regex.PatternSyntaxException if the regular expression's syntax is invalid

Parameters:

self - a CharSequence

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

public static String replaceAll(CharSequence self, CharSequence regex, @ClosureParams(value=FromString.class, options={"List","String[]"}) 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.

throws:

java.util.regex.PatternSyntaxException if the regular expression's syntax is invalid

Parameters:

self - a CharSequence

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:

replaceAll(CharSequence,Pattern,Closure)

public static String replaceAll(CharSequence self, 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:

self - the CharSequence that is to be matched

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 toString() of the CharSequence with content replaced

Since:

1.8.2

public static String replaceAll(CharSequence self, Pattern pattern, @ClosureParams(value=FromString.class, options={"List","String[]"}) 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:

self - a CharSequence

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

public static String replaceFirst(CharSequence self, CharSequence regex, CharSequence replacement)

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

throws:

java.util.regex.PatternSyntaxException if the regular expression's syntax is invalid

Parameters:

self - a CharSequence

regex - the capturing regex

replacement - the CharSequence to be substituted for each match

Since:

1.8.2

See Also:

String.replaceFirst

public static String replaceFirst(CharSequence self, CharSequence regex, @ClosureParams(value=FromString.class, options={"List","String[]"}) 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'
 

throws:

java.util.regex.PatternSyntaxException if the regular expression's syntax is invalid

Parameters:

self - a CharSequence

regex - the capturing regex

closure - the closure to apply on the first captured group

Since:

1.8.2

public static String replaceFirst(CharSequence self, 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:

self - the CharSequence that is to be matched

pattern - the regex Pattern to which the CharSequence of interest is to be matched

replacement - the CharSequence to be substituted for the first match

Since:

1.8.2

public static String replaceFirst(CharSequence self, Pattern pattern, @ClosureParams(value=FromString.class, options={"List","String[]"}) 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:

self - a CharSequence

pattern - the capturing regex Pattern

closure - the closure to apply on the first captured group

Since:

1.8.2

public static String reverse(CharSequence self)

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

Parameters:

self - a CharSequence

Returns:

a new String with all the characters reversed.

Since:

1.8.2

public static void setIndex(Matcher self, int index)

Sets the position of the given Matcher to the given index.

Parameters:

self - a Matcher

index - the index number

Since:

1.0

public static int size(CharSequence self)

Provides the standard Groovy size() method for CharSequence.

Parameters:

self - a CharSequence

Returns:

the length of the CharSequence

Since:

1.8.2

public static long size(Matcher self)

Provides the standard Groovy size() method for Matcher.

Parameters:

self - a matcher object

Returns:

the matcher's size (count)

Since:

1.5.0

@Deprecated public static int size(String self)

Provides the standard Groovy size() method for String.

Parameters:

self - a String

Returns:

the length of the String

Since:

1.0

See Also:

size(CharSequence)

@Deprecated public static int size(StringBuffer self)

Provides the standard Groovy size() method for StringBuffer.

Parameters:

self - a StringBuffer

Returns:

the length of the StringBuffer

Since:

1.0

See Also:

size(CharSequence)

public static String[] split(CharSequence self)

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

Parameters:

self - the CharSequence to split

Returns:

String[] result of split

Since:

1.8.2

<T> public static T splitEachLine(CharSequence self, CharSequence regex, @ClosureParams(value=FromString.class,options={"List","String[]"},conflictResolutionStrategy=PickFirstResolver.class) Closure<T> 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.

throws:

java.io.IOException if an error occurs

throws:

java.util.regex.PatternSyntaxException if the regular expression's syntax is invalid

Parameters:

self - a CharSequence

regex - the delimiting regular expression

closure - a closure

Returns:

the last value returned by the closure

Since:

1.8.2

See Also:

splitEachLine(CharSequence,Pattern,Closure)

<T> public static T splitEachLine(CharSequence self, Pattern pattern, @ClosureParams(value=FromString.class,options={"List","String[]"},conflictResolutionStrategy=PickFirstResolver.class) Closure<T> 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:

self - a CharSequence

pattern - the regular expression Pattern for the delimiter

closure - a closure

Returns:

the last value returned by the closure

Since:

1.8.2

public static boolean startsWithAny(CharSequence self, CharSequence prefixes)

Tests if this CharSequence starts with any specified prefixes.

Parameters:

prefixes - the prefixes.

Returns:

true if this CharSequence starts with any specified prefixes.

Since:

2.4.14

public static boolean startsWithIgnoreCase(CharSequence self, CharSequence searchString)

Checks whether this CharSequence starts with the searchString ignoring the case considerations.

Parameters:

self - the original CharSequence

searchString - CharSequence being checked against this

Returns:

true if the character sequence represented by the argument is a prefix of this CharSequence ignoring the case considerations. false otherwise. Returns false if the argument is null

Since:

3.0.0

public static String stripIndent(CharSequence self)

Strips 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()
 

Parameters:

self - a CharSequence to strip the leading spaces from

Returns:

the stripped toString() of the CharSequence

Since:

1.8.2

@Incubating public static String stripIndent(CharSequence self, boolean forceGroovyBehavior)

Same logic as stripIndent(CharSequence) if forceGroovyBehavior is true, otherwise Java 13's stripIndent will be invoked.

Parameters:

self - The CharSequence to strip the leading spaces from

forceGroovyBehavior - force groovy behavior to avoid conflicts with Java13's stripIndent

Since:

3.0.0

public static String stripIndent(CharSequence self, int numChars)

Strips numChars leading characters from every line in a CharSequence.

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

Parameters:

self - The CharSequence to strip the characters from

numChars - The number of characters to strip

Returns:

the stripped String

Since:

1.8.2

public static String stripMargin(CharSequence self)

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

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

Parameters:

self - The CharSequence to strip the margin from

Returns:

the stripped String

Since:

1.8.2

See Also:

stripMargin(CharSequence,char)

public static String stripMargin(CharSequence self, char marginChar)

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

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

Parameters:

self - The CharSequence to strip the margin from

marginChar - Any character that serves as margin delimiter

Returns:

the stripped String

Since:

1.8.2

public static String stripMargin(CharSequence self, CharSequence marginChar)

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

Parameters:

self - The CharSequence to strip the margin from

marginChar - Any character that serves as margin delimiter

Returns:

the stripped CharSequence

Since:

1.8.2

public static CharSequence take(CharSequence self, 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:

self - the original CharSequence

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 static String take(GString self, int num)

A GString variant of the equivalent CharSequence method.

Parameters:

self - the original GString

num - the number of chars to take from this GString

Returns:

a String consisting of the first num chars, or else the whole GString if it has less then num elements.

Since:

2.3.7

public static String take(String self, int num)

A String variant of the equivalent CharSequence method.

Parameters:

self - the original String

num - the number of chars to take from this String

Returns:

a String consisting of the first num chars, or else the whole String if it has less then num elements.

Since:

2.5.5

public static CharSequence takeAfter(CharSequence self, CharSequence searchString)

Returns the CharSequence that exists after the first occurrence of the given searchString in this CharSequence.

 def text = "Groovy development. Groovy team"
 assert text.takeAfter( 'Groovy' )           == ' development. Groovy team'
 assert text.takeAfter( 'team' )             == ''
 assert text.takeAfter( '' )                 == ''
 assert text.takeAfter( 'Unavailable text' ) == ''
 assert text.takeAfter( null )               == ''
 

Parameters:

self - the original CharSequence

searchString - CharSequence that is searched in this CharSequence

Returns:

CharSequence that is after the given searchString and empty string if it does not exist

Since:

3.0.0

public static String takeAfter(String self, CharSequence searchString)

A String variant of the equivalent CharSequence method takeAfter(CharSequence,CharSequence).

Parameters:

self - the original CharSequence

searchString - String that is searched in this CharSequence

Returns:

String that is after the given searchString and empty string if it does not exist

Since:

3.0.0

public static String takeAfter(GString self, CharSequence searchString)

A GString variant of the equivalent CharSequence method takeAfter(CharSequence,CharSequence).

Parameters:

self - the original CharSequence

searchString - CharSequence that is searched in this CharSequence

Returns:

String that is after the given searchString and empty string if it does not exist

Since:

3.0.0

public static CharSequence takeBefore(CharSequence self, CharSequence searchString)

Returns the CharSequence that exists before the first occurrence of the given searchString in this CharSequence.

 def text = "Groovy development. Groovy team"

 assert text.takeBefore( ' Groovy ' )         == 'Groovy development.'
 assert text.takeBefore( ' ' )                == 'Groovy'
 assert text.takeBefore( 'Unavailable text' ) == ''
 assert text.takeBefore( null )               == ''
 

Parameters:

self - the original CharSequence

searchString - CharSequence that is searched in this CharSequence

Returns:

CharSequence that is before the given searchString

Since:

3.0.0

public static String takeBefore(GString self, String searchString)

A GString variant of the equivalent CharSequence method takeBefore(CharSequence,CharSequence).

Parameters:

self - the original CharSequence

searchString - CharSequence that is searched in this CharSequence

Returns:

String that is before the given searchString

Since:

3.0.0

public static String takeBefore(String self, String searchString)

A String variant of the equivalent CharSequence method takeBefore(CharSequence,CharSequence).

Parameters:

self - the original CharSequence

searchString - CharSequence that is searched in this CharSequence

Returns:

String that is before the given searchString

Since:

3.0.0

public static CharSequence takeBetween(CharSequence self, CharSequence from, CharSequence to)

Returns the CharSequence that is in between the first occurrence of the given from and to CharSequences and empty if the unavailable inputs are given.

 def text = "Groovy"

 assert text.takeBetween( 'r', 'v' ) == 'oo'
 assert text.takeBetween( 'r', 'z' ) == ''
 assert text.takeBetween( 'a', 'r' ) == ''
 

Parameters:

self - the original CharSequence

from - beginning of search

to - end of search

Returns:

the CharSequence that is in between the given two CharSequences and empty if the unavailable inputs are given

Since:

3.0.0

See Also:

takeBetween(CharSequence,CharSequence,CharSequence,int)

public static String takeBetween(String self, CharSequence from, CharSequence to)

A String variant of the equivalent CharSequence method takeBetween(CharSequence,CharSequence,CharSequence).

Parameters:

self - the original CharSequence

from - beginning of search

to - end of search

Returns:

String that is in between the given two CharSequences and empty if the unavailable inputs are given

Since:

3.0.0

public static String takeBetween(GString self, CharSequence from, CharSequence to)

A GString variant of the equivalent CharSequence method takeBetween(CharSequence,CharSequence,CharSequence).

Parameters:

self - the original CharSequence

from - beginning of search

to - end of search

Returns:

String that is in between the given two CharSequences and empty if the unavailable inputs are given

Since:

3.0.0

public static CharSequence takeBetween(CharSequence self, CharSequence enclosure)

Takes the characters between the first occurrence of the two subsequent enclosure strings.

 def text = "name = 'some name'"

 assert text.takeBetween( "'" ) == 'some name'
 assert text.takeBetween( 'z' ) == ''
 

Parameters:

self - Original CharSequence

enclosure - Enclosure CharSequence

Returns:

CharSequence between the 2 subsequent enclosure strings

Since:

3.0.0

See Also:

takeBetween(CharSequence,CharSequence,int)

public static String takeBetween(String self, CharSequence enclosure)

A String variant of the equivalent CharSequence method takeBetween(CharSequence,CharSequence).

Parameters:

self - Original String

enclosure - Enclosure CharSequence

Returns:

String between the 2 subsequent enclosure strings

Since:

3.0.0

public static String takeBetween(GString self, CharSequence enclosure)

A GString variant of the equivalent CharSequence method takeBetween(CharSequence,CharSequence).

Parameters:

self - Original GString

enclosure - Enclosure CharSequence

Returns:

String between the 2 subsequent enclosure strings

Since:

3.0.0

public static CharSequence takeBetween(CharSequence self, CharSequence from, CharSequence to, int occurrence)

Returns the CharSequence that is in between the given the nth (specified by occurrence) pair of from and to CharSequences and empty if the unavailable inputs are given.

 def text = "t1=10 ms, t2=100 ms"

 assert text.takeBetween( '=', ' ', 0 ) == '10'
 assert text.takeBetween( '=', ' ', 1 ) == '100'
 assert text.takeBetween( 't1', 'z' ) == ''
 

Parameters:

self - the original CharSequence

from - beginning of search

to - end of search

occurrence - nth occurrence that is to be returned. 0 represents first one

Returns:

the CharSequence that is in between the given the nth (specified by occurrence) pair of from and to CharSequences and empty if the unavailable inputs are given.

Since:

3.0.0

See Also:

takeBetween(CharSequence,CharSequence,CharSequence)

public static String takeBetween(String self, CharSequence from, CharSequence to, int occurrence)

A String variant of the equivalent CharSequence method takeBetween(CharSequence,CharSequence,CharSequence,int).

Parameters:

self - the original String

from - beginning of search

to - end of search

occurrence - nth occurrence that is to be returned. 0 represents first one

Returns:

the String that is in between the given nth (specified by occurrence) pair of from and to CharSequences and empty if the unavailable inputs are given.

Since:

3.0.0

public static String takeBetween(GString self, CharSequence from, CharSequence to, int occurrence)

A GString variant of the equivalent CharSequence method takeBetween(CharSequence,CharSequence,CharSequence,int).

Parameters:

self - the original GString

from - beginning of search

to - end of search

occurrence - nth occurrence that is to be returned. 0 represents first one

Returns:

the String that is in between the given nth (specified by occurrence) pair of from and to CharSequences and empty if the unavailable inputs are given.

Since:

3.0.0

public static CharSequence takeBetween(CharSequence self, CharSequence enclosure, int occurrence)

Takes the characters between nth (specified by occurrence) pair of enclosure strings.

 def text = "t1='10' ms, t2='100' ms"

 assert text.takeBetween( "'", 0 ) == '10'
 assert text.takeBetween( "'", 1 ) == '100'
 assert text.takeBetween( "'", 2 ) == ''
 

Parameters:

self - Original CharSequence

enclosure - Enclosure CharSequence

occurrence - nth occurrence being returned

Returns:

CharSequence between the nth occurrence of pair of enclosure strings

Since:

3.0.0

See Also:

takeBetween(CharSequence,CharSequence,int)

public static String takeBetween(String self, CharSequence enclosure, int occurrence)

A String variant of the equivalent CharSequence method takeBetween(CharSequence,CharSequence,int).

Parameters:

self - Original String

enclosure - Enclosure CharSequence

occurrence - nth occurrence being returned

Returns:

String between the nth occurrence of pair of enclosure strings

Since:

3.0.0

public static String takeBetween(GString self, CharSequence enclosure, int occurrence)

A GString variant of the equivalent CharSequence method takeBetween(CharSequence,CharSequence,int).

Parameters:

self - Original GString

enclosure - Enclosure CharSequence

occurrence - nth occurrence being returned

Returns:

String between the nth occurrence of pair of enclosure strings

Since:

3.0.0

public static CharSequence takeRight(CharSequence self, int num)

Returns the last num elements from this CharSequence.

 def text = "Groovy"
 assert text.takeRight( 0 ) == ''
 assert text.takeRight( 2 ) == 'vy'
 assert text.takeRight( 7 ) == 'Groovy'
 

Parameters:

self - the original CharSequence

num - the number of chars to take from this CharSequence from the right

Returns:

a CharSequence consisting of the last num chars, or else the whole CharSequence if it has less than num elements.

Since:

3.0.0

public static String takeRight(String self, int num)

A GString variant of the equivalent CharSequence method takeRight(CharSequence,int).

Parameters:

self - the original CharSequence

num - the number of chars to take from this CharSequence from the right

Returns:

a String consisting of the last num chars, or else the whole CharSequence if it has less than num elements.

Since:

3.0.0

public static String takeRight(GString self, int num)

A String variant of the equivalent CharSequence method takeRight(CharSequence,int).

Parameters:

self - the original GString

num - the number of chars to take from this GString from the right

Returns:

a String consisting of the last num chars, or else the whole GString if it has less than num elements.

Since:

3.0.0

@SuppressWarnings("unchecked") public static String takeWhile(CharSequence self, @ClosureParams(value=FromString.class, conflictResolutionStrategy=PickFirstResolver.class, options={"String", "Character"}) 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:

self - the original CharSequence

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 static String takeWhile(GString self, @ClosureParams(value=FromString.class, conflictResolutionStrategy=PickFirstResolver.class, options={"String", "Character"}) Closure condition)

A GString variant of the equivalent GString method.

Parameters:

self - the original GString

condition - the closure that must evaluate to true to continue taking elements

Returns:

a prefix of elements in the GString where each element passed to the given closure evaluates to true

Since:

2.3.7

@Deprecated public static CharSequence takeWhile$$bridge(CharSequence self, @ClosureParams(value=FromString.class, conflictResolutionStrategy=PickFirstResolver.class, options={"String", "Character"}) Closure condition)

public static BigDecimal toBigDecimal(CharSequence self)

Parses a CharSequence into a BigDecimal

Parameters:

self - a CharSequence

Returns:

a BigDecimal

Since:

1.8.2

public static BigInteger toBigInteger(CharSequence self)

Parses a CharSequence into a BigInteger

Parameters:

self - a CharSequence

Returns:

a BigInteger

Since:

1.8.2

public static Boolean toBoolean(String self)

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.

Parameters:

self - a String

Returns:

The Boolean value

Since:

1.0

public static Character toCharacter(String self)

Converts the given string into a Character object using the first character in the string.

Parameters:

self - a String

Returns:

the first Character

Since:

1.0

public static Double toDouble(CharSequence self)

Parses a CharSequence into a Double.

Parameters:

self - a CharSequence

Returns:

a Double

Since:

1.8.2

public static Float toFloat(CharSequence self)

Parses a CharSequence into a Float.

Parameters:

self - a CharSequence

Returns:

a Float

Since:

1.8.2

public static Integer toInteger(CharSequence self)

Parses a CharSequence into an Integer.

Parameters:

self - a CharSequence

Returns:

an Integer

Since:

1.8.2

public static List<String> toList(CharSequence self)

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

Parameters:

self - a CharSequence

Returns:

a List of characters (a 1-character String)

Since:

1.8.2

public static Long toLong(CharSequence self)

Parses a CharSequence into a Long

Parameters:

self - a CharSequence

Returns:

a Long

Since:

1.8.2

public static Set<String> toSet(CharSequence self)

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

Parameters:

self - a CharSequence

Returns:

a Set of unique characters (each a 1-character String)

Since:

1.8.2

public static Short toShort(CharSequence self)

Parses a CharSequence into a Short.

Parameters:

self - a CharSequence

Returns:

a Short

Since:

1.8.2

@SuppressWarnings("unchecked") public static List<String> tokenize(CharSequence self)

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

Parameters:

self - a CharSequence

Returns:

a List of tokens

Since:

1.8.2

See Also:

StringTokenizer.StringTokenizer

public static List<String> tokenize(CharSequence self, Character delimiter)

Tokenizes a CharSequence based on the given character delimiter.

For example:

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

Parameters:

self - a CharSequence

delimiter - the delimiter

Returns:

a List of tokens

Since:

1.8.2

See Also:

StringTokenizer.StringTokenizer

@SuppressWarnings("unchecked") public static List<String> tokenize(CharSequence self, CharSequence delimiters)

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

Parameters:

self - a CharSequence

delimiters - the delimiters

Returns:

a List of tokens

Since:

1.8.2

See Also:

StringTokenizer.StringTokenizer

public static String tr(CharSequence self, 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:

self - the CharSequence that is to be translated

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

public static String uncapitalize(CharSequence self)

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(' ')
 

Parameters:

self - The CharSequence to uncapitalize

Returns:

A String containing the uncapitalized toString() of the CharSequence

Since:

2.4.8

public static String unexpand(CharSequence self)

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

Parameters:

self - A CharSequence to unexpand

Returns:

an unexpanded String

Since:

1.8.2

public static String unexpand(CharSequence self, int tabStop)

Replaces sequences of whitespaces with tabs.

Parameters:

self - A CharSequence to unexpand

tabStop - The number of spaces a tab represents

Returns:

an unexpanded String

Since:

1.8.2

public static String unexpandLine(CharSequence self, int tabStop)

Replaces sequences of whitespaces with tabs within a line.

Parameters:

self - A line to unexpand

tabStop - The number of spaces a tab represents

Returns:

an unexpanded String

Since:

1.8.2