RubyString

java.lang.Object
- net.sf.rubycollect4j.RubyEnumerable<java.lang.String>
- - net.sf.rubycollect4j.RubyString

All Implemented Interfaces:

java.io.Serializable, java.lang.CharSequence, java.lang.Comparable<java.lang.CharSequence>, java.lang.Iterable<java.lang.String>, Ruby.Enumerable<java.lang.String>, RubyContract.Enumerable<java.lang.String,Ruby.Enumerator<?>,RubyArray<?>>
```
public final class RubyString
extends RubyEnumerable<java.lang.String>
implements java.lang.CharSequence, java.lang.Comparable<java.lang.CharSequence>, java.io.Serializable
```
RubyString implements all methods refer to the String class of Ruby language.
RubyString is also a Java CharSequence and a Ruby.Enumerable.
To avoid the conflict of Java 8 String#chars(), RubyString doesn't implement the chars() method, but instead it directly extends the RubyEnumerable which also implies it allows to be manipulated as RubyEnumerable<String> and each String represents a character in this RubyString.

See Also:
Serialized Form

Constructor Summary

Constructors
Constructor and Description
`RubyString()` Returns a `RubyString` with an empty String as default value.
`RubyString(java.lang.Object o)` Returns a `RubyString` with calling `Object.toString()` on given Object as default value.

Method Summary

Methods
Modifier and Type	Method and Description
`boolean`	`asciiOnlyʔ()` Checks if `RubyString` only contains ascii.
`RubyString`	`b()` Returns a copied string whose encoding is ASCII-8BIT.
`RubyArray<java.lang.Byte>`	`bytes()` Returns an `RubyArray` of Byte in `RubyString`.
`int`	`bytesize()` Returns the length of `RubyString` in bytes.
`RubyString`	`byteslice(int index)` Returns a substring of one byte at given index.
`RubyString`	`byteslice(int offset, int length)` Returns a substring starting at the offset given by the first, and a length given by the second.
`RubyString`	`capitalize()` Returns a copy of `RubyString` with the first character converted to uppercase and the remainder to lowercase.
`RubyString`	`capitalizeǃ()` Modifies `RubyString` by converting the first character to uppercase and the remainder to lowercase.
`int`	`casecmp(java.lang.CharSequence charSeq)` Case-insensitive version of `compareTo(CharSequence)`.
`RubyString`	`center(int width)` Returns a new `RubyString` of length width with str centered and padded with spaces.
`RubyString`	`center(int width, java.lang.String padstr)` Returns a new `RubyString` of length width with str centered and padded with padstr.
`char`	`charAt(int index)`
`RubyString`	`chomp()` Returns a new `RubyString` with the line separator removed from the end of str.
`RubyString`	`chomp(java.lang.String separator)` Returns a new `RubyString` with the given line separator removed from the end of str.
`RubyString`	`chompǃ()` Modifies str in place as described for `chomp()`, returning str, or null if no modifications were made.
`RubyString`	`chompǃ(java.lang.String separator)` Modifies str in place as described for `chomp()`, returning str, or null if no modifications were made.
`RubyString`	`chop()` Returns a new `RubyString` with the last character removed.
`RubyString`	`chopǃ()` Processes str as for `chop()`, returning str, or null if str is the empty string.
`RubyString`	`chr()` Returns a one-character string at the beginning of the string.
`RubyString`	`clear()` Makes string empty.
`RubyArray<java.lang.Integer>`	`codepoints()` Returns a `RubyArray` of the Integer ordinals of the characters in str.
`int`	`compareTo(java.lang.CharSequence o)`
`RubyString`	`concat(int codepoint)` Appends the given codepoint as a character to str.
`RubyString`	`concat(java.lang.Object o)` Appends the given object to str.
`int`	`count(java.lang.String charSet, java.lang.String... charSets)` Each charSet parameter defines a set of characters to count.
`RubyString`	`crypt(java.lang.String salt)` Applies a one-way cryptographic hash to str by invoking the MessageDigest(MD5) with the given salt string.
`RubyString`	`delete(java.lang.String charSet)` Returns a copy of str with all characters in the intersection of its arguments deleted.
`RubyString`	`deleteǃ(java.lang.String charSet)` Performs a delete operation in place, returning str, or null if str was not modified.
`RubyString`	`downcase()` Returns a copy of str with all uppercase letters replaced with their lowercase.
`RubyString`	`downcaseǃ()` Downcases the contents of str, returning null if no changes were made.
`RubyString`	`dump()` Produces a version of str with all non-printing or non-ASCII 8bit characters replaced by \\nnn or \\unnnn notation and all special characters escaped.
`RubyEnumerator<java.lang.Byte>`	`eachByte()` Returns a `RubyEnumerator` of each byte in str.
`RubyString`	`eachByte(Block<java.lang.Byte> block)` Passes each byte in str to the given block.
`RubyEnumerator<java.lang.String>`	`eachChar()` Returns a `RubyEnumerator` of each character in str.
`RubyString`	`eachChar(Block<java.lang.String> block)` Passes each character in str to the given block.
`RubyEnumerator<java.lang.Integer>`	`eachCodepoint()` Returns a `RubyEnumerator` of each codepoint in str.
`RubyString`	`eachCodepoint(Block<java.lang.Integer> block)` Passes each codepoint in str to the given block.
`RubyEnumerator<java.lang.String>`	`eachLine()` Returns a `RubyEnumerator` of each line in str.
`RubyString`	`eachLine(Block<java.lang.String> block)` Passes each line in str to the given block.
`RubyEnumerator<java.lang.String>`	`eachLine(java.lang.String separator)` Returns a `RubyEnumerator` of each line by given separator in str.
`RubyString`	`eachLine(java.lang.String separator, Block<java.lang.String> block)` Passes each line by given separator in str to the given block.
`boolean`	`emptyʔ()` Returns true if str has a length of zero.
`RubyString`	`encode(java.lang.String encoding)` Returns a copy of str transcoded to encoding encoding.
`RubyString`	`encode(java.lang.String dstEncoding, java.lang.String srcEncoding)` Returns a copy of str transcoded from srcEncoding to dstEncoding.
`RubyString`	`encodeǃ(java.lang.String encoding)` Returns the str transcoded to encoding encoding.
`RubyString`	`encodeǃ(java.lang.String dstEncoding, java.lang.String srcEncoding)` Returns the str transcoded from srcEncoding to dstEncoding.
`java.nio.charset.Charset`	`encoding()` Returns UTF-8 Charset.
`boolean`	`endWithʔ(java.lang.String suffix, java.lang.String... otherSuffix)` Returns true if str ends with one of the suffixes given.
`boolean`	`eqlʔ(java.lang.Object o)` Two RubyString are equal if they have the same length and content.
`boolean`	`equals(java.lang.Object o)`
`RubyString`	`forceEncoding(java.lang.String encoding)` Changes the encoding to encoding and returns self.
`java.lang.Byte`	`getbyte(int index)` Returns the indexth byte, or null if index was out of range.
`protected java.lang.Iterable<java.lang.String>`	`getIterable()` Returns an Iterable of elements.
`RubyEnumerator<java.lang.String>`	`gsub(java.lang.String regex)` Returns a `RubyEnumerator` of all matched str.
`RubyString`	`gsub(java.lang.String regex, java.util.Map<java.lang.String,?> map)` Returns a copy of str with the all occurrences of pattern substituted for the second argument.
`RubyString`	`gsub(java.lang.String regex, java.lang.String replacement)` Returns a copy of str with the all occurrences of pattern substituted for the second argument.
`RubyString`	`gsub(java.lang.String regex, TransformBlock<java.lang.String,java.lang.String> block)` Returns a copy of str with the all occurrences of pattern substituted for the second argument.
`RubyEnumerator<java.lang.String>`	`gsubǃ(java.lang.String regex)` Returns a `RubyEnumerator` of all matched str.
`RubyString`	`gsubǃ(java.lang.String regex, java.lang.String replacement)` Performs the substitutions of `gsub(String, String)` in place, returning this `RubyString`, or null if no substitutions were performed.
`RubyString`	`gsubǃ(java.lang.String regex, TransformBlock<java.lang.String,java.lang.String> block)` Performs the substitutions of `gsub(String, TransformBlock)` in place, returning this `RubyString`, or null if no substitutions were performed.
`int`	`hash()` Return a hash based on the string’s length and content.
`int`	`hashCode()`
`long`	`hex()` Treats leading characters from str as a string of hexadecimal digits (with an optional sign and an optional 0x) and returns the corresponding number.
`boolean`	`includeʔ(java.lang.String otherStr)` Returns true if str contains the given string.
`java.lang.Integer`	`index(java.util.regex.Pattern regex)` Returns the index of the first occurrence of the given Pattern in str.
`java.lang.Integer`	`index(java.util.regex.Pattern regex, int offset)` Returns the index of the first occurrence of the given Pattern in str by an offset.
`java.lang.Integer`	`index(java.lang.String substring)` Returns the index of the first occurrence of the given substring in str.
`java.lang.Integer`	`index(java.lang.String substring, int offset)` Returns the index of the first occurrence of the given substring in str.
`RubyString`	`insert(int index, java.lang.String otherStr)` Inserts otherStr before the character at the given index, modifying str.
`RubyString`	`inspect()` Returns a printable version of str, surrounded by quote marks, with special characters escaped.
`int`	`length()`
`RubyArray<java.lang.String>`	`lines()` Returns a `RubyArray` of lines in str split using the supplied record separator (System.getProperty("line.separator") by default).
`RubyArray<java.lang.String>`	`lines(java.lang.String separator)` Returns a `RubyArray` of lines in str split using given record separator.
`RubyString`	`ljust(int width)` If integer is greater than the length of str, returns a new `RubyString` of length integer with str left justified and padded with whitesapce; otherwise, returns str.
`RubyString`	`ljust(int width, java.lang.String padstr)` If integer is greater than the length of str, returns a new `RubyString` of length integer with str left justified and padded with padstr; otherwise, returns str.
`RubyString`	`lstrip()` Returns a copy of str with leading whitespace removed.
`RubyString`	`lstripǃ()` Removes leading whitespace from str, returning null if no change was made.
`java.util.regex.Matcher`	`match(java.lang.String regex)` Converts regex to a Pattern, then invokes its match method on str.
`java.util.regex.Matcher`	`match(java.lang.String regex, int pos)` Converts regex to a Pattern, then invokes its match method on str.
`RubyString`	`next()` Returns the successor to str.
`RubyString`	`nextǃ()` Equivalent to `next()`, but modifies the receiver in place.
`int`	`oct()` Treats leading characters of str as a string of octal digits (with an optional sign) and returns the corresponding number.
`int`	`ord()` Return the Integer ordinal of a one-character string.
`RubyArray<java.lang.String>`	`partition(java.util.regex.Pattern pattern)` Searches pattern in the string and returns the part before it, the match, and the part after it.
`RubyArray<java.lang.String>`	`partition(java.lang.String sep)` Searches sep in the string and returns the part before it, the match, and the part after it.
`RubyString`	`prepend(java.lang.String otherStr)` Prepends the given string to str.
`RubyString`	`replace(java.lang.String otherStr)` Replaces the contents and taintedness of str with the corresponding values in otherStr.
`RubyString`	`reverse()` Returns a new string with the characters from str in reverse order.
`RubyString`	`reverseǃ()` Reverses str in place.
`java.lang.Integer`	`rindex(java.util.regex.Pattern pattern)` Returns the index of the last occurrence of the given Pattern in str.
`java.lang.Integer`	`rindex(java.util.regex.Pattern pattern, int stopAt)` Returns the index of the last occurrence of the given Pattern in str.
`java.lang.Integer`	`rindex(java.lang.String substring)` Returns the index of the last occurrence of the given substring in str.
`java.lang.Integer`	`rindex(java.lang.String substring, int stopAt)` Returns the index of the last occurrence of the given Pattern in str.
`RubyString`	`rjust(int width)` If width is greater than the length of str, returns a new String of length integer with str right justified and padded with whitespace; otherwise, returns str.
`RubyString`	`rjust(int width, java.lang.String padstr)` If width is greater than the length of str, returns a new String of length integer with str right justified and padded with padstr; otherwise, returns str.
`RubyArray<java.lang.String>`	`rpartition(java.util.regex.Pattern pattern)` Searches Pattern in the string from the end of the string, and returns the part before it, the match, and the part after it.
`RubyArray<java.lang.String>`	`rpartition(java.lang.String sep)` Searches sep in the string from the end of the string, and returns the part before it, the match, and the part after it.
`RubyString`	`rstrip()` Returns a copy of str with trailing whitespace removed.
`RubyString`	`rstripǃ()` Removes trailing whitespace from str, returning nil if no change was made.
`RubyArray<java.lang.String>`	`scan(java.lang.String regex)` Both forms iterate through str, matching the regexp.
`RubyString`	`scan(java.lang.String regex, Block<java.lang.String> block)` Both forms iterate through str, matching the regexp.
`RubyArray<RubyArray<java.lang.String>>`	`scanGroups(java.lang.String regex)` Both forms iterate through str, matching the regexp.
`RubyString`	`scanGroups(java.lang.String regex, Block<RubyArray<java.lang.String>> block)` Both forms iterate through str, matching the regexp.
`RubyString`	`scrub()` If the string is invalid byte sequence then replace invalid bytes with �.
`RubyString`	`scrub(java.lang.String repl)` If the string is invalid byte sequence then replace invalid bytes with given replacement character.
`RubyString`	`scrub(TransformBlock<RubyArray<java.lang.Byte>,java.lang.String> block)` If the string is invalid byte sequence then replace invalid bytes with returned value of the block.
`RubyString`	`scrubǃ()` If the string is invalid byte sequence then replace invalid bytes with �.
`RubyString`	`scrubǃ(java.lang.String repl)` If the string is invalid byte sequence then replace invalid bytes with given replacement character.
`RubyString`	`scrubǃ(TransformBlock<RubyArray<java.lang.Byte>,java.lang.String> block)` If the string is invalid byte sequence then replace invalid bytes with returned value of the block.
`byte`	`setbyte(int index, byte b)` Modifies the indexth byte.
`int`	`size()` Returns the character length of str.
`RubyString`	`slice(int index)` Returns a substring of one character at that index.
`RubyString`	`slice(int index, int length)` Returns a substring containing length characters starting at the index.
`RubyString`	`slice(java.util.regex.Pattern pattern)` Returns the matching portion of the string.
`RubyString`	`slice(java.util.regex.Pattern pattern, int group)` Returns the target group of matching portion of the string.
`RubyString`	`slice(java.lang.String matchStr)` Returns if matchStr occurs in the string.
`RubyString`	`sliceǃ(int index)` Deletes the specified portion from str, and returns the portion deleted.
`RubyString`	`sliceǃ(int index, int length)` Deletes the specified portion from str, and returns the portion deleted.
`RubyString`	`sliceǃ(java.util.regex.Pattern pattern)` Deletes the specified portion from str, and returns the portion deleted.
`RubyString`	`sliceǃ(java.util.regex.Pattern pattern, int group)` Deletes the specified portion from str, and returns the portion deleted.
`RubyString`	`sliceǃ(java.lang.String matchStr)` Deletes the specified portion from str, and returns the portion deleted.
`RubyArray<java.lang.String>`	`split()` Divides str into substrings based on a whitespaces, returning a `RubyArray` of these substrings.
`RubyArray<java.lang.String>`	`split(java.util.regex.Pattern pattern)` Divides str into substrings based on a Pattern, returning a `RubyArray` of these substrings.
`RubyArray<java.lang.String>`	`split(java.util.regex.Pattern pattern, int limit)` Divides str into substrings based on a Pattern, returning a `RubyArray` of these substrings, at most that limit number of fields will be returned.
`RubyArray<java.lang.String>`	`split(java.lang.String delimiter)` Divides str into substrings based on a delimiter, returning a `RubyArray` of these substrings.
`RubyArray<java.lang.String>`	`split(java.lang.String delimiter, int limit)` Divides str into substrings based on a delimiter, returning a `RubyArray` of these substrings, at most that limit number of fields will be returned.
`RubyString`	`squeeze()` Builds a set of characters using the procedure described for `RubyEnumerable.count()`.
`RubyString`	`squeeze(java.lang.String charSet)` Builds a set of characters from the charSet using the procedure described for `RubyEnumerable.count()`.
`RubyString`	`squeezeǃ()` Squeezes str in place, returning either str, or nil if no changes were made.
`RubyString`	`squeezeǃ(java.lang.String charSet)` Squeezes str in place, returning either str, or nil if no changes were made.
`boolean`	`startWithʔ(java.lang.String prefix, java.lang.String... otherPrefix)` Returns true if str starts with one of the prefixes given.
`RubyString`	`strip()` Returns a copy of str with leading and trailing whitespace removed.
`RubyString`	`stripǃ()` Removes leading and trailing whitespace from str.
`RubyString`	`sub(java.lang.String regex, java.util.Map<java.lang.String,?> map)` Returns a copy of str with the first occurrence of pattern replaced by the second argument.
`RubyString`	`sub(java.lang.String regex, java.lang.String replacement)` Returns a copy of str with the first occurrence of pattern replaced by the second argument.
`RubyString`	`sub(java.lang.String regex, TransformBlock<java.lang.String,java.lang.String> block)` Returns a copy of str with the first occurrence of pattern replaced by the value returned by the block will be substituted for the match on each call.
`java.lang.CharSequence`	`subSequence(int start, int end)`
`RubyString`	`subǃ(java.lang.String regex, java.lang.String replacement)` Performs the same substitution as `sub(String, String)` in-place.
`RubyString`	`subǃ(java.lang.String regex, TransformBlock<java.lang.String,java.lang.String> block)` Performs the same substitution as `sub(String, TransformBlock)` in-place.
`RubyString`	`succ()` Returns the successor to str.
`RubyString`	`succǃ()` Equivalent to `succ()`, but modifies the receiver in place.
`int`	`sum()` Returns a basic n-bit checksum of the characters in str, where n is 16.
`int`	`sum(int n)` Returns a basic n-bit checksum of the characters in str, where n is the optional Fixnum parameter.
`RubyString`	`swapcase()` Returns a copy of str with uppercase alphabetic characters converted to lowercase and lowercase characters converted to uppercase.
`RubyString`	`swapcaseǃ()` Equivalent to `swapcase()`, but modifies the receiver in place, returning str, or null if no changes were made.
`double`	`toF()` Returns the result of interpreting leading characters in str as a floating point number.
`int`	`toI()` Returns the result of interpreting leading characters in str as a integer number.
`int`	`toI(int radix)` Returns the result of interpreting leading characters in str as a integer number.
`java.lang.String`	`toS()` Returns the receiver.
`java.lang.String`	`toStr()` Returns the receiver.
`java.lang.String`	`toString()`
`RubyString`	`tr(java.lang.String fromStr, java.lang.String toStr)` Returns a copy of str with the characters in fromStr replaced by the corresponding characters in toStr.
`RubyString`	`trS(java.lang.String fromStr, java.lang.String toStr)` Processes a copy of str as described under `tr(String, String)`, then removes duplicate characters in regions that were affected by the translation.
`RubyString`	`trSǃ(java.lang.String fromStr, java.lang.String toStr)` Performs `trS(String, String)` processing on str in place, returning str, or null if no changes were made.
`RubyString`	`trǃ(java.lang.String fromStr, java.lang.String toStr)` Translates str in place, using the same rules as `tr(String, String)`.
`RubyArray<java.lang.Object>`	`unpack(java.lang.String format)` Decodes str (which may contain binary data) according to the format string, returning an array of each value extracted.
`RubyString`	`upcase()` Returns a copy of str with all lowercase letters replaced with their uppercase counterparts.
`RubyString`	`upcaseǃ()` Upcases the contents of str, returning nil if no changes were made.
`RubyEnumerator<java.lang.String>`	`upto(java.lang.String otherStr)` Iterates through successive values, starting at str and ending at otherStr inclusive, passing each value in turn to the block.
`RubyString`	`upto(java.lang.String otherStr, Block<java.lang.String> block)` Iterates through successive values, starting at str and ending at otherStr inclusive, passing each value in turn to the block.
`RubyEnumerator<java.lang.String>`	`upto(java.lang.String otherStr, boolean exclusive)` Iterates through successive values, starting at str and ending at otherStr inclusive, passing each value in turn to the block.
`RubyString`	`upto(java.lang.String otherStr, boolean exclusive, Block<java.lang.String> block)` Iterates through successive values, starting at str and ending at otherStr, passing each value in turn to the block.
`boolean`	`validEncodingʔ(java.lang.String encoding)` Returns true for a string which encoded correctly.

Methods inherited from class net.sf.rubycollect4j.RubyEnumerable
allʔ, allʔ, anyʔ, anyʔ, chunk, chunk, collect, collect, collect, collectConcat, collectConcat, count, count, cycle, cycle, cycle, cycle, detect, detect, drop, dropWhile, dropWhile, each, each, eachCons, eachCons, eachEntry, eachEntry, eachSlice, eachSlice, eachWithIndex, eachWithIndex, eachWithObject, eachWithObject, entries, find, find, findAll, findAll, findIndex, findIndex, findIndex, first, first, flatMap, flatMap, grep, grep, grep, groupBy, groupBy, groupBy, inject, inject, inject, inject, iterator, lazy, map, map, map, max, max, maxBy, maxBy, maxBy, maxBy, memberʔ, min, min, minBy, minBy, minBy, minBy, minmax, minmax, minmaxBy, minmaxBy, minmaxBy, minmaxBy, noneʔ, noneʔ, oneʔ, oneʔ, partition, partition, reduce, reduce, reduce, reduce, reject, reject, reverseEach, reverseEach, select, select, sliceBefore, sliceBefore, sort, sortBy, sortBy, sortBy, sortBy, sortBy, take, takeWhile, takeWhile, toA, zip, zip, zip

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

- Constructor Detail
  - RubyString
```
public RubyString()
```
    Returns a RubyString with an empty String as default value.
  - RubyString
```
public RubyString(java.lang.Object o)
```
    Returns a RubyString with calling Object.toString() on given Object as default value.
    
    Parameters:
    o - any Object
    
    Throws:
    
    javax.xml.bind.TypeConstraintException - if o is null
- Method Detail
  - getIterable
```
protected java.lang.Iterable<java.lang.String> getIterable()
```
    Description copied from class: RubyEnumerable
    
    Returns an Iterable of elements.
    
    Specified by:
    
    getIterable in class RubyEnumerable<java.lang.String>
    
    Returns:
    Iterable
  - asciiOnlyʔ
```
public boolean asciiOnlyʔ()
```
    Checks if RubyString only contains ascii.
    
    Returns:
    true if this RubyString only contains ascii, false otherwise
  - b
```
public RubyString b()
```
    Returns a copied string whose encoding is ASCII-8BIT.
    
    Returns:
    new RubyString
  - bytes
```
public RubyArray<java.lang.Byte> bytes()
```
    Returns an RubyArray of Byte in RubyString.
    
    Returns:
    RubyArray of Byte
  - bytesize
```
public int bytesize()
```
    Returns the length of RubyString in bytes.
    
    Returns:
    the length of bytes
  - byteslice
```
public RubyString byteslice(int index)
```
    Returns a substring of one byte at given index.
    
    Parameters:
    index - of target byte
    
    Returns:
    s RubyString of sliced byte
  - byteslice
```
public RubyString byteslice(int offset,
                   int length)
```
    Returns a substring starting at the offset given by the first, and a length given by the second.
    
    Parameters:
    offset - begin index
    length - of the bytes
    
    Returns:
    new RubyString
  - capitalize
```
public RubyString capitalize()
```
    Returns a copy of RubyString with the first character converted to uppercase and the remainder to lowercase.
    
    Returns:
    new RubyString
  - capitalizeǃ
```
public RubyString capitalizeǃ()
```
    Modifies RubyString by converting the first character to uppercase and the remainder to lowercase.
    
    Returns:
    this RubyString if capitalized, null otherwise
  - casecmp
```
public int casecmp(java.lang.CharSequence charSeq)
```
    Case-insensitive version of compareTo(CharSequence).
    
    Parameters:
    charSeq - any CharSequence
    
    Returns:
    negative integer, zero, or a positive integer as the specified CharSequence is greater than, equal to, or less than this String, ignoring case considerations.
  - center
```
public RubyString center(int width)
```
    Returns a new RubyString of length width with str centered and padded with spaces.
    
    Parameters:
    width - of result
    
    Returns:
    new RubyString
  - center
```
public RubyString center(int width,
                java.lang.String padstr)
```
    Returns a new RubyString of length width with str centered and padded with padstr.
    
    Parameters:
    width - of result
    padstr - used to pad in front and after the str
    
    Returns:
    new RubyString
  - chomp
```
public RubyString chomp()
```
    Returns a new RubyString with the line separator removed from the end of str.
    
    Returns:
    new RubyString
  - chompǃ
```
public RubyString chompǃ()
```
    Modifies str in place as described for chomp(), returning str, or null if no modifications were made.
    
    Returns:
    this RubyString or null
  - chomp
```
public RubyString chomp(java.lang.String separator)
```
    Returns a new RubyString with the given line separator removed from the end of str.
    
    Parameters:
    separator - a line separator
    
    Returns:
    new RubyString
  - chompǃ
```
public RubyString chompǃ(java.lang.String separator)
```
    Modifies str in place as described for chomp(), returning str, or null if no modifications were made.
    
    Returns:
    this RubyString or null
  - chop
```
public RubyString chop()
```
    Returns a new RubyString with the last character removed. If the string ends with \r\n, both characters are removed.
    
    Returns:
    new RubyString
  - chopǃ
```
public RubyString chopǃ()
```
    Processes str as for chop(), returning str, or null if str is the empty string.
    
    Returns:
    new RubyString or null
  - chr
```
public RubyString chr()
```
    Returns a one-character string at the beginning of the string.
    
    Returns:
    new RubyString
  - clear
```
public RubyString clear()
```
    Makes string empty.
    
    Returns:
    this RubyString
  - codepoints
```
public RubyArray<java.lang.Integer> codepoints()
```
    Returns a RubyArray of the Integer ordinals of the characters in str.
    
    Returns:
    RubyArray
  - concat
```
public RubyString concat(int codepoint)
```
    Appends the given codepoint as a character to str.
    
    Parameters:
    codepoint - of a character
    
    Returns:
    this RubyString
  - concat
```
public RubyString concat(java.lang.Object o)
```
    Appends the given object to str.
    
    Parameters:
    o - any Object
    
    Returns:
    this RubyString
  - count
```
public int count(java.lang.String charSet,
        java.lang.String... charSets)
```
    Each charSet parameter defines a set of characters to count. The intersection of these sets defines the characters to count in str. Any charSet that starts with a caret ^ is negated. The sequence c1-c2 means all characters between c1 and c2. The backslash character can be used to escape ^ or -.
    
    Parameters:
    charSet - a set of characters
    charSets - sets of characters
    
    Returns:
    the total count
  - crypt
```
public RubyString crypt(java.lang.String salt)
```
    Applies a one-way cryptographic hash to str by invoking the MessageDigest(MD5) with the given salt string.
    
    Parameters:
    salt - a secret string
    
    Returns:
    new RubyString
  - delete
```
public RubyString delete(java.lang.String charSet)
```
    Returns a copy of str with all characters in the intersection of its arguments deleted. Uses the same rules for building the set of characters as RubyEnumerable.count().
    
    Parameters:
    charSet - a set of characters
    
    Returns:
    new RubyString
  - deleteǃ
```
public RubyString deleteǃ(java.lang.String charSet)
```
    Performs a delete operation in place, returning str, or null if str was not modified.
    
    Parameters:
    charSet - a set of characters
    
    Returns:
    new RubyString or null
  - downcase
```
public RubyString downcase()
```
    Returns a copy of str with all uppercase letters replaced with their lowercase.
    
    Returns:
    new RubyString
  - downcaseǃ
```
public RubyString downcaseǃ()
```
    Downcases the contents of str, returning null if no changes were made.
    
    Returns:
    this RubyString or null
  - dump
```
public RubyString dump()
```
    Produces a version of str with all non-printing or non-ASCII 8bit characters replaced by \\nnn or \\unnnn notation and all special characters escaped.
    
    Returns:
    new RubyString
  - eachByte
```
public RubyEnumerator<java.lang.Byte> eachByte()
```
    Returns a RubyEnumerator of each byte in str.
    
    Returns:
    RubyEnumerator
  - eachByte
```
public RubyString eachByte(Block<java.lang.Byte> block)
```
    Passes each byte in str to the given block.
    
    Parameters:
    block - to yield byte
    
    Returns:
    this RubyString
  - eachChar
```
public RubyEnumerator<java.lang.String> eachChar()
```
    Returns a RubyEnumerator of each character in str.
    
    Returns:
    RubyEnumerator
  - eachChar
```
public RubyString eachChar(Block<java.lang.String> block)
```
    Passes each character in str to the given block.
    
    Parameters:
    block - to yield character
    
    Returns:
    this RubyString
  - eachCodepoint
```
public RubyEnumerator<java.lang.Integer> eachCodepoint()
```
    Returns a RubyEnumerator of each codepoint in str.
    
    Returns:
    RubyEnumerator
  - eachCodepoint
```
public RubyString eachCodepoint(Block<java.lang.Integer> block)
```
    Passes each codepoint in str to the given block.
    
    Parameters:
    block - to yield character
    
    Returns:
    this RubyString
  - eachLine
```
public RubyEnumerator<java.lang.String> eachLine()
```
    Returns a RubyEnumerator of each line in str.
    
    Returns:
    RubyEnumerator
  - eachLine
```
public RubyString eachLine(Block<java.lang.String> block)
```
    Passes each line in str to the given block.
    
    Parameters:
    block - to yield line
    
    Returns:
    this RubyString
  - eachLine
```
public RubyEnumerator<java.lang.String> eachLine(java.lang.String separator)
```
    Returns a RubyEnumerator of each line by given separator in str.
    
    Returns:
    RubyEnumerator
  - eachLine
```
public RubyString eachLine(java.lang.String separator,
                  Block<java.lang.String> block)
```
    Passes each line by given separator in str to the given block.
    
    Parameters:
    block - to yield line
    
    Returns:
    this RubyString
  - emptyʔ
```
public boolean emptyʔ()
```
    Returns true if str has a length of zero.
    
    Returns:
    true if str has a length of zero, false otherwise
  - encode
```
public RubyString encode(java.lang.String encoding)
```
    Returns a copy of str transcoded to encoding encoding.
    
    Parameters:
    encoding - name of encoding
    
    Returns:
    new RubyString
  - encode
```
public RubyString encode(java.lang.String dstEncoding,
                java.lang.String srcEncoding)
```
    Returns a copy of str transcoded from srcEncoding to dstEncoding.
    
    Parameters:
    dstEncoding - name of destination encoding
    srcEncoding - name of source encoding
    
    Returns:
    new RubyString
  - encodeǃ
```
public RubyString encodeǃ(java.lang.String encoding)
```
    Returns the str transcoded to encoding encoding.
    
    Parameters:
    encoding - name of encoding
    
    Returns:
    this RubyString
  - encodeǃ
```
public RubyString encodeǃ(java.lang.String dstEncoding,
                 java.lang.String srcEncoding)
```
    Returns the str transcoded from srcEncoding to dstEncoding.
    
    Parameters:
    dstEncoding - name of destination encoding
    srcEncoding - name of source encoding
    
    Returns:
    this RubyString
  - encoding
```
public java.nio.charset.Charset encoding()
```
    Returns UTF-8 Charset.
    
    Returns:
    Charset
  - endWithʔ
```
public boolean endWithʔ(java.lang.String suffix,
               java.lang.String... otherSuffix)
```
    Returns true if str ends with one of the suffixes given.
    
    Parameters:
    suffix -
    otherSuffix -
    
    Returns:
    true if str ends with one of the suffixes given, false otherwise
  - eqlʔ
```
public boolean eqlʔ(java.lang.Object o)
```
    Two RubyString are equal if they have the same length and content.
    
    Parameters:
    o - any Object
    
    Returns:
    true if two objects are equal, false otherwise
  - forceEncoding
```
public RubyString forceEncoding(java.lang.String encoding)
```
    Changes the encoding to encoding and returns self.
    
    Parameters:
    encoding - name of encoding
    
    Returns:
    this RubyString
  - getbyte
```
public java.lang.Byte getbyte(int index)
```
    Returns the indexth byte, or null if index was out of range.
    
    Parameters:
    index - of a byte
    
    Returns:
    Byte or null
  - gsub
```
public RubyString gsub(java.lang.String regex,
              java.lang.String replacement)
```
    Returns a copy of str with the all occurrences of pattern substituted for the second argument.
    
    Parameters:
    regex - regular expression
    replacement - any String
    
    Returns:
    new RubyString
  - gsub
```
public RubyString gsub(java.lang.String regex,
              java.util.Map<java.lang.String,?> map)
```
    Returns a copy of str with the all occurrences of pattern substituted for the second argument. The second argument is a Map, and the matched text is one of its keys, the corresponding value is the replacement string.
    
    Parameters:
    regex - regular expression
    map - any Map
    
    Returns:
    new RubyString
  - gsub
```
public RubyString gsub(java.lang.String regex,
              TransformBlock<java.lang.String,java.lang.String> block)
```
    Returns a copy of str with the all occurrences of pattern substituted for the second argument. The second argument is a TransformBlock, and the value returned by the block will be substituted for the match on each call.
    
    Parameters:
    regex - regular expression
    block - to do the replacement
    
    Returns:
    new RubyString
  - gsub
```
public RubyEnumerator<java.lang.String> gsub(java.lang.String regex)
```
    Returns a RubyEnumerator of all matched str.
    
    Parameters:
    regex - regular expression
    
    Returns:
    RubyEnumerator
  - gsubǃ
```
public RubyString gsubǃ(java.lang.String regex,
               java.lang.String replacement)
```
    Performs the substitutions of gsub(String, String) in place, returning this RubyString, or null if no substitutions were performed.
    
    Parameters:
    regex - regular expression
    replacement - any String
    
    Returns:
    this RubyString or null
  - gsubǃ
```
public RubyString gsubǃ(java.lang.String regex,
               TransformBlock<java.lang.String,java.lang.String> block)
```
    Performs the substitutions of gsub(String, TransformBlock) in place, returning this RubyString, or null if no substitutions were performed.
    
    Parameters:
    regex - regular expression
    block - to do the replacement
    
    Returns:
    this RubyString or null
  - gsubǃ
```
public RubyEnumerator<java.lang.String> gsubǃ(java.lang.String regex)
```
    Returns a RubyEnumerator of all matched str.
    
    Parameters:
    regex - regular expression
    
    Returns:
    RubyEnumerator
  - hash
```
public int hash()
```
    Return a hash based on the string’s length and content.
    
    Returns:
    hashcode
  - hex
```
public long hex()
```
    Treats leading characters from str as a string of hexadecimal digits (with an optional sign and an optional 0x) and returns the corresponding number. Zero is returned on error.
    
    Returns:
    long
  - includeʔ
```
public boolean includeʔ(java.lang.String otherStr)
```
    Returns true if str contains the given string.
    
    Specified by:
    
    includeʔ in interface RubyContract.Enumerable<java.lang.String,Ruby.Enumerator<?>,RubyArray<?>>
    
    Overrides:
    
    includeʔ in class RubyEnumerable<java.lang.String>
    
    Parameters:
    otherStr - to be searched
    
    Returns:
    true if str contains the given string, false otherwise
  - index
```
public java.lang.Integer index(java.lang.String substring)
```
    Returns the index of the first occurrence of the given substring in str. Returns null if not found
    
    Parameters:
    substring - any String
    
    Returns:
    Integer or null
  - index
```
public java.lang.Integer index(java.lang.String substring,
                      int offset)
```
    Returns the index of the first occurrence of the given substring in str. Returns null if not found. The second parameter specifies the position in the string to begin the search.
    
    Parameters:
    substring - any String
    offset - position to begin the search
    
    Returns:
    Integer or null
  - index
```
public java.lang.Integer index(java.util.regex.Pattern regex)
```
    Returns the index of the first occurrence of the given Pattern in str. Returns null if not found.
    
    Parameters:
    regex - a Pattern
    
    Returns:
    Integer or null
  - index
```
public java.lang.Integer index(java.util.regex.Pattern regex,
                      int offset)
```
    Returns the index of the first occurrence of the given Pattern in str by an offset. Returns null if not found.
    
    Parameters:
    regex - a Pattern
    offset - place to start
    
    Returns:
    Integer or null
  - insert
```
public RubyString insert(int index,
                java.lang.String otherStr)
```
    Inserts otherStr before the character at the given index, modifying str. Negative indices count from the end of the string, and insert after the given character. The intent is insert aString so that it starts at the given index.
    
    Parameters:
    index - position to begin insertion
    otherStr - any String
    
    Returns:
    this RubyString
  - inspect
```
public RubyString inspect()
```
    Returns a printable version of str, surrounded by quote marks, with special characters escaped.
    
    Returns:
    new RubyString
  - lines
```
public RubyArray<java.lang.String> lines()
```
    Returns a RubyArray of lines in str split using the supplied record separator (System.getProperty("line.separator") by default).
    
    Returns:
    RubyArray
  - lines
```
public RubyArray<java.lang.String> lines(java.lang.String separator)
```
    Returns a RubyArray of lines in str split using given record separator.
    
    Returns:
    RubyArray
  - ljust
```
public RubyString ljust(int width)
```
    If integer is greater than the length of str, returns a new RubyString of length integer with str left justified and padded with whitesapce; otherwise, returns str.
    
    Parameters:
    width - of new RubyString
    
    Returns:
    new RubyString
  - ljust
```
public RubyString ljust(int width,
               java.lang.String padstr)
```
    If integer is greater than the length of str, returns a new RubyString of length integer with str left justified and padded with padstr; otherwise, returns str.
    
    Parameters:
    width - of new RubyString
    padstr - used to pad on the right of new RubyString
    
    Returns:
    new RubyString
  - lstrip
```
public RubyString lstrip()
```
    Returns a copy of str with leading whitespace removed.
    
    Returns:
    new RubyString
  - lstripǃ
```
public RubyString lstripǃ()
```
    Removes leading whitespace from str, returning null if no change was made.
    
    Returns:
    this RubyString or null
  - match
```
public java.util.regex.Matcher match(java.lang.String regex)
```
    Converts regex to a Pattern, then invokes its match method on str. Returns null if no match found.
    
    Parameters:
    regex - regular expression
    
    Returns:
    Matcher or null
  - match
```
public java.util.regex.Matcher match(java.lang.String regex,
                            int pos)
```
    Converts regex to a Pattern, then invokes its match method on str. The second parameter specifies the position in the string to begin the search. Returns null if no match found.
    
    Parameters:
    regex - regular expression
    pos - position begin to search
    
    Returns:
    Matcher or null
  - next
```
public RubyString next()
```
    Returns the successor to str.
    
    Returns:
    new RubyString
  - nextǃ
```
public RubyString nextǃ()
```
    Equivalent to next(), but modifies the receiver in place.
    
    Returns:
    new RubyString
  - oct
```
public int oct()
```
    Treats leading characters of str as a string of octal digits (with an optional sign) and returns the corresponding number. Returns 0 if the conversion fails.
    
    Returns:
    int
  - ord
```
public int ord()
```
    Return the Integer ordinal of a one-character string.
    
    Returns:
    int
  - partition
```
public RubyArray<java.lang.String> partition(java.lang.String sep)
```
    Searches sep in the string and returns the part before it, the match, and the part after it. If it is not found, returns two empty strings and str.
    
    Parameters:
    sep -
    
    Returns:
    RubyArray
  - partition
```
public RubyArray<java.lang.String> partition(java.util.regex.Pattern pattern)
```
    Searches pattern in the string and returns the part before it, the match, and the part after it. If it is not found, returns two empty strings and str.
    
    Parameters:
    pattern - a Pattern
    
    Returns:
    RubyArray
  - prepend
```
public RubyString prepend(java.lang.String otherStr)
```
    Prepends the given string to str.
    
    Parameters:
    otherStr - any String
    
    Returns:
    new RubyString
  - replace
```
public RubyString replace(java.lang.String otherStr)
```
    Replaces the contents and taintedness of str with the corresponding values in otherStr.
    
    Parameters:
    otherStr -
    
    Returns:
    this RubyString
  - reverse
```
public RubyString reverse()
```
    Returns a new string with the characters from str in reverse order.
    
    Returns:
    new RubyString
  - reverseǃ
```
public RubyString reverseǃ()
```
    Reverses str in place.
    
    Returns:
    this RubyString
  - rindex
```
public java.lang.Integer rindex(java.lang.String substring)
```
    Returns the index of the last occurrence of the given substring in str. Returns null if not found.
    
    Parameters:
    substring - any String
    
    Returns:
    Ineger or null
  - rindex
```
public java.lang.Integer rindex(java.lang.String substring,
                       int stopAt)
```
    Returns the index of the last occurrence of the given Pattern in str. Returns null if not found. The second parameter specifies the position in the string to end the search—characters beyond this point will not be considered.
    
    Parameters:
    substring - any String
    stopAt - position to stop search
    
    Returns:
    Ineger or null
  - rindex
```
public java.lang.Integer rindex(java.util.regex.Pattern pattern)
```
    Returns the index of the last occurrence of the given Pattern in str. Returns null if not found.
    
    Parameters:
    pattern - a Pattern
    
    Returns:
    Integer or null
  - rindex
```
public java.lang.Integer rindex(java.util.regex.Pattern pattern,
                       int stopAt)
```
    Returns the index of the last occurrence of the given Pattern in str. Returns null if not found. The second parameter specifies the position in the string to end the search—characters beyond this point will not be considered.
    
    Parameters:
    pattern - a Pattern
    stopAt - position to stop search
    
    Returns:
    Integer or null
  - rjust
```
public RubyString rjust(int width)
```
    If width is greater than the length of str, returns a new String of length integer with str right justified and padded with whitespace; otherwise, returns str.
    
    Parameters:
    width - of new RubyString
    
    Returns:
    new RubyString
  - rjust
```
public RubyString rjust(int width,
               java.lang.String padstr)
```
    If width is greater than the length of str, returns a new String of length integer with str right justified and padded with padstr; otherwise, returns str.
    
    Parameters:
    width - of new RubyString
    padstr - used to pad on the left of new RubyString
    
    Returns:
    new RubyString
  - rpartition
```
public RubyArray<java.lang.String> rpartition(java.lang.String sep)
```
    Searches sep in the string from the end of the string, and returns the part before it, the match, and the part after it. If it is not found, returns two empty strings and str.
    
    Parameters:
    sep - separator
    
    Returns:
    RubyArray
  - rpartition
```
public RubyArray<java.lang.String> rpartition(java.util.regex.Pattern pattern)
```
    Searches Pattern in the string from the end of the string, and returns the part before it, the match, and the part after it. If it is not found, returns two empty strings and str.
    
    Parameters:
    pattern - a Pattern
    
    Returns:
    RubyArray
  - rstrip
```
public RubyString rstrip()
```
    Returns a copy of str with trailing whitespace removed.
    
    Returns:
    new RubyString
    See Also:
    lstrip(), strip()
  - rstripǃ
```
public RubyString rstripǃ()
```
    Removes trailing whitespace from str, returning nil if no change was made.
    
    Returns:
    this RubyString
    See Also:
    lstripǃ(), stripǃ()
  - scan
```
public RubyArray<java.lang.String> scan(java.lang.String regex)
```
    Both forms iterate through str, matching the regexp. For each match, a result is generated and added to the result RubyArray.
    
    Parameters:
    regex - regular expression
    
    Returns:
    RubyArray
  - scan
```
public RubyString scan(java.lang.String regex,
              Block<java.lang.String> block)
```
    Both forms iterate through str, matching the regexp. For each match, a result is generated and passed to the block.
    
    Parameters:
    regex - regular expression
    block - to do the replacement
    
    Returns:
    this RubyString
  - scanGroups
```
public RubyArray<RubyArray<java.lang.String>> scanGroups(java.lang.String regex)
```
    Both forms iterate through str, matching the regexp. For each match, a result is generated and added to the result array. If the pattern contains no groups, each individual result consists of the matched string. If the pattern contains groups, each individual result is itself an array containing one entry per group.
    
    Parameters:
    regex - regular expression
    
    Returns:
    RubyArray
  - scanGroups
```
public RubyString scanGroups(java.lang.String regex,
                    Block<RubyArray<java.lang.String>> block)
```
    Both forms iterate through str, matching the regexp. For each match, a result is generated and passed to the block. If the pattern contains no groups, each individual result consists of the matched string. If the pattern contains groups, each individual result is itself an array containing one entry per group.
    
    Parameters:
    regex - regular expression
    block - to yield matched groups
    
    Returns:
    this RubyString
  - scrub
```
public RubyString scrub()
```
    If the string is invalid byte sequence then replace invalid bytes with �.
    
    Returns:
    new RubyString
  - scrub
```
public RubyString scrub(java.lang.String repl)
```
    If the string is invalid byte sequence then replace invalid bytes with given replacement character.
    
    Returns:
    new RubyString
  - scrub
```
public RubyString scrub(TransformBlock<RubyArray<java.lang.Byte>,java.lang.String> block)
```
    If the string is invalid byte sequence then replace invalid bytes with returned value of the block.
    
    Returns:
    new RubyString
  - scrubǃ
```
public RubyString scrubǃ()
```
    If the string is invalid byte sequence then replace invalid bytes with �.
    
    Returns:
    this RubyString
  - scrubǃ
```
public RubyString scrubǃ(java.lang.String repl)
```
    If the string is invalid byte sequence then replace invalid bytes with given replacement character.
    
    Returns:
    this RubyString
  - scrubǃ
```
public RubyString scrubǃ(TransformBlock<RubyArray<java.lang.Byte>,java.lang.String> block)
```
    If the string is invalid byte sequence then replace invalid bytes with returned value of the block.
    
    Returns:
    this RubyString
  - setbyte
```
public byte setbyte(int index,
           byte b)
```
    Modifies the indexth byte.
    
    Parameters:
    index - position to modify
    b - a byte
    
    Returns:
    byte
  - size
```
public int size()
```
    Returns the character length of str.
    
    Returns:
    int
  - slice
```
public RubyString slice(int index)
```
    Returns a substring of one character at that index.
    
    Parameters:
    index - of the character
    
    Returns:
    new RubyString or null
  - slice
```
public RubyString slice(int index,
               int length)
```
    Returns a substring containing length characters starting at the index.
    
    Parameters:
    index - position to begin slice
    length - of new RubyString
    
    Returns:
    new RubyString or null
  - slice
```
public RubyString slice(java.util.regex.Pattern pattern)
```
    Returns the matching portion of the string.
    
    Parameters:
    pattern - a Pattern
    
    Returns:
    new RubyString or null
  - slice
```
public RubyString slice(java.util.regex.Pattern pattern,
               int group)
```
    Returns the target group of matching portion of the string.
    
    Parameters:
    pattern - a Pattern
    group - number pf matched group
    
    Returns:
    new RubyString or null
  - slice
```
public RubyString slice(java.lang.String matchStr)
```
    Returns if matchStr occurs in the string.
    
    Parameters:
    matchStr - matched string
    
    Returns:
    new RubyString or null
  - sliceǃ
```
public RubyString sliceǃ(int index)
```
    Deletes the specified portion from str, and returns the portion deleted.
    
    Parameters:
    index - of the character
    
    Returns:
    new RubyString or null
  - sliceǃ
```
public RubyString sliceǃ(int index,
                int length)
```
    Deletes the specified portion from str, and returns the portion deleted.
    
    Parameters:
    index - position to begin slice
    length - of new RubyString
    
    Returns:
    new RubyString or null
  - sliceǃ
```
public RubyString sliceǃ(java.util.regex.Pattern pattern)
```
    Deletes the specified portion from str, and returns the portion deleted.
    
    Parameters:
    pattern - a Pattern
    
    Returns:
    new RubyString or null
  - sliceǃ
```
public RubyString sliceǃ(java.util.regex.Pattern pattern,
                int group)
```
    Deletes the specified portion from str, and returns the portion deleted.
    
    Parameters:
    pattern - a Pattern
    group - number pf matched group
    
    Returns:
    new RubyString or null
  - sliceǃ
```
public RubyString sliceǃ(java.lang.String matchStr)
```
    Deletes the specified portion from str, and returns the portion deleted.
    
    Parameters:
    matchStr - matched string
    
    Returns:
    new RubyString or null
  - split
```
public RubyArray<java.lang.String> split()
```
    Divides str into substrings based on a whitespaces, returning a RubyArray of these substrings.
    
    Returns:
    RubyArray
  - split
```
public RubyArray<java.lang.String> split(java.lang.String delimiter)
```
    Divides str into substrings based on a delimiter, returning a RubyArray of these substrings.
    
    Parameters:
    delimiter - used to split str
    
    Returns:
    RubyArray
  - split
```
public RubyArray<java.lang.String> split(java.lang.String delimiter,
                                int limit)
```
    Divides str into substrings based on a delimiter, returning a RubyArray of these substrings, at most that limit number of fields will be returned.
    
    Parameters:
    delimiter - used to split str
    limit - max number of fields
    
    Returns:
    RubyArray
  - split
```
public RubyArray<java.lang.String> split(java.util.regex.Pattern pattern)
```
    Divides str into substrings based on a Pattern, returning a RubyArray of these substrings.
    
    Parameters:
    pattern - a Pattern
    
    Returns:
    RubyArray
  - split
```
public RubyArray<java.lang.String> split(java.util.regex.Pattern pattern,
                                int limit)
```
    Divides str into substrings based on a Pattern, returning a RubyArray of these substrings, at most that limit number of fields will be returned.
    
    Parameters:
    pattern - a Pattern
    limit - max number of fields
    
    Returns:
    RubyArray
  - squeeze
```
public RubyString squeeze()
```
    Builds a set of characters using the procedure described for RubyEnumerable.count().
    
    Returns:
    new RubyString
  - squeeze
```
public RubyString squeeze(java.lang.String charSet)
```
    Builds a set of characters from the charSet using the procedure described for RubyEnumerable.count().
    
    Parameters:
    charSet - a set of characters
    
    Returns:
    new RubyString
  - squeezeǃ
```
public RubyString squeezeǃ()
```
    Squeezes str in place, returning either str, or nil if no changes were made.
    
    Returns:
    this RubyString or null
  - squeezeǃ
```
public RubyString squeezeǃ(java.lang.String charSet)
```
    Squeezes str in place, returning either str, or nil if no changes were made.
    
    Parameters:
    charSet - a set of characters
    
    Returns:
    this RubyString or null
  - startWithʔ
```
public boolean startWithʔ(java.lang.String prefix,
                 java.lang.String... otherPrefix)
```
    Returns true if str starts with one of the prefixes given.
    
    Parameters:
    prefix - first prefix
    otherPrefix - otner prefixes
    
    Returns:
    true if str starts with one of the prefixes given, flase otherwise
  - strip
```
public RubyString strip()
```
    Returns a copy of str with leading and trailing whitespace removed.
    
    Returns:
    new RubyString
  - stripǃ
```
public RubyString stripǃ()
```
    Removes leading and trailing whitespace from str. Returns nil if str was not altered.
    
    Returns:
    this RubyString
  - sub
```
public RubyString sub(java.lang.String regex,
             java.lang.String replacement)
```
    Returns a copy of str with the first occurrence of pattern replaced by the second argument.
    
    Parameters:
    regex - regular expression
    replacement - used to replace matched string
    
    Returns:
    new RubyString
  - sub
```
public RubyString sub(java.lang.String regex,
             java.util.Map<java.lang.String,?> map)
```
    Returns a copy of str with the first occurrence of pattern replaced by the second argument. The second argument is a Map, and the matched text is one of its keys, the corresponding value is the replacement string.
    
    Parameters:
    regex - regular expression
    map - any Map
    
    Returns:
    new RubyString
  - sub
```
public RubyString sub(java.lang.String regex,
             TransformBlock<java.lang.String,java.lang.String> block)
```
    Returns a copy of str with the first occurrence of pattern replaced by the value returned by the block will be substituted for the match on each call.
    
    Parameters:
    regex - regular expression
    block - to do the replacement
    
    Returns:
    new RubyString
  - subǃ
```
public RubyString subǃ(java.lang.String regex,
              java.lang.String replacement)
```
    Performs the same substitution as sub(String, String) in-place. Returns str if a substitution was performed or nil if no substitution was performed.
    
    Parameters:
    regex - regular expression
    replacement - used to replace matched string
    
    Returns:
    this RubyString or null
  - subǃ
```
public RubyString subǃ(java.lang.String regex,
              TransformBlock<java.lang.String,java.lang.String> block)
```
    Performs the same substitution as sub(String, TransformBlock) in-place. Returns str if a substitution was performed or nil if no substitution was performed.
    
    Parameters:
    regex - regular expression
    block - to do the replacement
    
    Returns:
    this RubyString or null
  - succ
```
public RubyString succ()
```
    Returns the successor to str. The successor is calculated by incrementing characters starting from the rightmost alphanumeric (or the rightmost character if there are no alphanumerics) in the string. Incrementing a digit always results in another digit, and incrementing a letter results in another letter of the same case. Incrementing nonalphanumerics uses the underlying character set’s collating sequence.
    
    Returns:
    new RubyString
  - succǃ
```
public RubyString succǃ()
```
    Equivalent to succ(), but modifies the receiver in place.
    
    Returns:
    this RubyString
  - sum
```
public int sum()
```
    Returns a basic n-bit checksum of the characters in str, where n is 16. The result is simply the sum of the binary value of each character in str modulo 2**n - 1. This is not a particularly good checksum.
    
    Returns:
    int
  - sum
```
public int sum(int n)
```
    Returns a basic n-bit checksum of the characters in str, where n is the optional Fixnum parameter. The result is simply the sum of the binary value of each character in str modulo 2**n - 1. This is not a particularly good checksum.
    
    Parameters:
    n - any int
    
    Returns:
    int
  - swapcase
```
public RubyString swapcase()
```
    Returns a copy of str with uppercase alphabetic characters converted to lowercase and lowercase characters converted to uppercase. Note: case conversion is effective only in ASCII region.
    
    Returns:
    new RubyString
  - swapcaseǃ
```
public RubyString swapcaseǃ()
```
    Equivalent to swapcase(), but modifies the receiver in place, returning str, or null if no changes were made. Note: case conversion is effective only in ASCII region.
    
    Returns:
    this RubyString or null
  - toF
```
public double toF()
```
    Returns the result of interpreting leading characters in str as a floating point number. Extraneous characters past the end of a valid number are ignored. If there is not a valid number at the start of str, 0.0 is returned. This method never raises an exception.
    
    Returns:
    double
  - toI
```
public int toI()
```
    Returns the result of interpreting leading characters in str as a integer number. Extraneous characters past the end of a valid number are ignored. If there is not a valid number at the start of str, 0 is returned. This method never raises an exception.
    
    Returns:
    int
  - toI
```
public int toI(int radix)
```
    Returns the result of interpreting leading characters in str as a integer number. Extraneous characters past the end of a valid number are ignored. If there is not a valid number at the start of str, 0 is returned. This method never raises an exception.
    
    Parameters:
    radix - the number of unique digits
    
    Returns:
    int
  - toS
```
public java.lang.String toS()
```
    Returns the receiver.
    
    Returns:
    String
  - toStr
```
public java.lang.String toStr()
```
    Returns the receiver.
    
    Returns:
    String
  - tr
```
public RubyString tr(java.lang.String fromStr,
            java.lang.String toStr)
```
    Returns a copy of str with the characters in fromStr replaced by the corresponding characters in toStr. If toStr is shorter than fromStr, it is padded with its last character in order to maintain the correspondence.
    
    Parameters:
    fromStr - a list of characters
    toStr - a list of characters
    
    Returns:
    new RubyString
  - trǃ
```
public RubyString trǃ(java.lang.String fromStr,
             java.lang.String toStr)
```
    Translates str in place, using the same rules as tr(String, String). Returns str, or nil if no changes were made.
    
    Parameters:
    fromStr - a list of characters
    toStr - a list of characters
    
    Returns:
    this RubyString or null
  - trS
```
public RubyString trS(java.lang.String fromStr,
             java.lang.String toStr)
```
    Processes a copy of str as described under tr(String, String), then removes duplicate characters in regions that were affected by the translation.
    
    Parameters:
    fromStr - a list of characters
    toStr - a list of characters
    
    Returns:
    new RubyString
  - trSǃ
```
public RubyString trSǃ(java.lang.String fromStr,
              java.lang.String toStr)
```
    Performs trS(String, String) processing on str in place, returning str, or null if no changes were made.
    
    Parameters:
    fromStr - a list of characters
    toStr - a list of characters
    
    Returns:
    this RubyString or null
  - unpack
```
public RubyArray<java.lang.Object> unpack(java.lang.String format)
```
    Decodes str (which may contain binary data) according to the format string, returning an array of each value extracted. The format string consists of a sequence of single-character directives, summarized in the table at the end of this entry. Each directive may be followed by a number, indicating the number of times to repeat with this directive. An asterisk (“*”) will use up all remaining elements.
    
    Parameters:
    format - format string
    
    Returns:
    RubyArray
    See Also:
    RubyArray.pack(String)
  - upcase
```
public RubyString upcase()
```
    Returns a copy of str with all lowercase letters replaced with their uppercase counterparts. The operation is locale insensitive—only characters “a” to “z” are affected.
    
    Returns:
    new RubyString
  - upcaseǃ
```
public RubyString upcaseǃ()
```
    Upcases the contents of str, returning nil if no changes were made.
    
    Returns:
    new RubyString
  - upto
```
public RubyEnumerator<java.lang.String> upto(java.lang.String otherStr)
```
    Iterates through successive values, starting at str and ending at otherStr inclusive, passing each value in turn to the block. The succ() method is used to generate each value.
    
    Parameters:
    otherStr - any String
    
    Returns:
    RubyEnumerator
  - upto
```
public RubyEnumerator<java.lang.String> upto(java.lang.String otherStr,
                                    boolean exclusive)
```
    Iterates through successive values, starting at str and ending at otherStr inclusive, passing each value in turn to the block. The succ() method is used to generate each value. The second argument exclusive is omitted or is false, the last value will be included; otherwise it will be excluded.
    
    Parameters:
    otherStr - any String
    exclusive - true if the last value is ommitted, false otherwise
    
    Returns:
    RubyEnumerator
  - upto
```
public RubyString upto(java.lang.String otherStr,
              Block<java.lang.String> block)
```
    Iterates through successive values, starting at str and ending at otherStr inclusive, passing each value in turn to the block.
    
    Parameters:
    otherStr - any String
    block - to yield successive value
    
    Returns:
    this RubyString
  - upto
```
public RubyString upto(java.lang.String otherStr,
              boolean exclusive,
              Block<java.lang.String> block)
```
    Iterates through successive values, starting at str and ending at otherStr, passing each value in turn to the block. The second argument exclusive is omitted or is false, the last value will be included.
    
    Parameters:
    otherStr - any String
    exclusive - true if the last value is ommitted, false otherwise
    block - to yield successive value
    
    Returns:
    this RubyString
  - validEncodingʔ
```
public boolean validEncodingʔ(java.lang.String encoding)
```
    Returns true for a string which encoded correctly.
    
    Parameters:
    encoding - name of encoding
    
    Returns:
    true if a string encoded correctly, flase otherwise
  - equals
```
public boolean equals(java.lang.Object o)
```
    Overrides:
    
    equals in class java.lang.Object
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class java.lang.Object
  - toString
```
public java.lang.String toString()
```
    Specified by:
    
    toString in interface java.lang.CharSequence
    
    Overrides:
    
    toString in class RubyEnumerable<java.lang.String>
  - length
```
public int length()
```
    Specified by:
    
    length in interface java.lang.CharSequence
  - charAt
```
public char charAt(int index)
```
    Specified by:
    
    charAt in interface java.lang.CharSequence
  - subSequence
```
public java.lang.CharSequence subSequence(int start,
                                 int end)
```
    Specified by:
    
    subSequence in interface java.lang.CharSequence
  - compareTo
```
public int compareTo(java.lang.CharSequence o)
```
    Specified by:
    
    compareTo in interface java.lang.Comparable<java.lang.CharSequence>

Class RubyString

Constructor Summary

Method Summary

Methods inherited from class net.sf.rubycollect4j.RubyEnumerable

Methods inherited from class java.lang.Object

Constructor Detail

RubyString

RubyString

Method Detail

getIterable

asciiOnlyʔ

b

bytes

bytesize

byteslice

byteslice

capitalize

capitalizeǃ

casecmp

center

center

chomp

chompǃ

chomp

chompǃ

chop

chopǃ

chr

clear

codepoints

concat

concat

count

crypt

delete

deleteǃ

downcase

downcaseǃ

dump

eachByte

eachByte

eachChar

eachChar

eachCodepoint

eachCodepoint

eachLine

eachLine

eachLine

eachLine

emptyʔ

encode

encode

encodeǃ

encodeǃ

encoding

endWithʔ

eqlʔ

forceEncoding

getbyte

gsub

gsub

gsub

gsub

gsubǃ

gsubǃ

gsubǃ

hash

hex

includeʔ

index

index

index

index

insert

inspect

lines

lines

ljust

ljust

lstrip