Str (Java Tool 1.20.2 API)

java.lang.Object
- java.util.AbstractCollection<E>
- - java.util.AbstractList<T>
  - - org.osgl.util.ListBase<Character>
    - - org.osgl.util.StrBase<Str>
      - org.osgl.util.Str

All Implemented Interfaces:

Serializable, CharSequence, Comparable<Str>, Iterable<Character>, Collection<Character>, List<Character>, RandomAccess, C.Featured, C.List<Character>, C.ReversibleSequence<Character>, C.Sequence<Character>, C.Traversable<Character>
```
public class Str
extends StrBase<Str>
```
See Also:

Serialized Form

Nested Class Summary
- Nested classes/interfaces inherited from class org.osgl.util.StrBase
  StrBase.F
- Nested classes/interfaces inherited from interface org.osgl.util.C.List
  C.List.Cursor<T>
- Nested classes/interfaces inherited from interface org.osgl.util.C.Featured
  C.Featured.Factory

Field Summary

Fields
Modifier and Type Field and Description

static Str EMPTY_STR
- Fields inherited from class java.util.AbstractList
  modCount

Fields
Modifier and Type	Field and Description
`static Str`	`EMPTY_STR`

Constructor Summary

Constructors
Modifier Constructor and Description

protected Str()

Constructors
Modifier	Constructor and Description
`protected`	`Str()`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`protected Str`	`_empty()` Check if the str is empty
`protected Class<Str>`	`_impl()` Return the class of the implementation
`Str`	`afterFirst(char c)`
`Str`	`afterFirst(Str s)`
`Str`	`afterFirst(String s)`
`Str`	`afterLast(char c)`
`Str`	`afterLast(Str s)`
`Str`	`afterLast(String s)`
`Str`	`append(C.List<Character> list)` Return a str instance contains all characters of this str instance append with all characters in the list specified
`Str`	`append(char... array)` Return a str instance contains all characters of this str instance append with all characters in the array specified
`Str`	`append(Character character)` Returns a str instance contains all characters of this str instance appended with the character specified
`Str`	`append(Collection<? extends Character> collection)` Return a str instance contains all characters of this str append with all characters in the collection specified
`Str`	`append(Str s)` Returns a str instance contains all characters of this str instance appended with all characters in teh str specified
`Str`	`append(String s)` Returns a str instance contains all characters of this str instance appended with all characters in the `String` specified
`Str`	`beforeFirst(char c)`
`Str`	`beforeFirst(Str s)`
`Str`	`beforeFirst(String s)`
`Str`	`beforeLast(char c)`
`Str`	`beforeLast(Str s)`
`Str`	`beforeLast(String s)`
`Str`	`capFirst()`
`char[]`	`charArray()`
`char`	`charAt(int index)`
`int`	`compareTo(CharSequence x)` Compare the char sequence specified against this str
`int`	`compareTo(Str o)`
`int`	`compareToIgnoreCase(CharSequence x)` Compare the char sequence specified against this str in a case insensitive manner
`int`	`compareToIgnoreCase(Str x)` Compare the str specified against this str in a case insensitive manner
`boolean`	`contains(CharSequence s)`
`boolean`	`contentEquals(CharSequence x)` Check if this str content is equals to the char sequence specified
`boolean`	`contentEquals(Str x)` Check if this str content iks equals to the str specified
`int`	`count(Str search, boolean overlap)`
`int`	`count(String search, boolean overlap)`
`Str`	`decodeBASE64()`
`Str`	`dropWhile(Lang.Function<? super Character,Boolean> predicate)` Return a str that without the first N characters in the string.
`Str`	`encodeBASE64()`
`boolean`	`endsWith(CharSequence suffix, int offset)` Check if this str ends with a char sequence, with the search starts at the specified offset
`boolean`	`endsWith(Str suffix, int toffset)` Check this str instance ends with str, with the search starts at specified offset
`boolean`	`equalsIgnoreCase(CharSequence x)` Compare content of the str and the specified char sequence, case insensitive
`byte[]`	`getBytes()` Encodes this str into a sequence of bytes using the platform’s default charset, storing the result into a new byte array.
`byte[]`	`getBytes(Charset charset)` Encodes this str into a sequence of bytes using the given charset, storing the result into a new byte array.
`byte[]`	`getBytes(String charsetName)` Encodes this str into a sequence of bytes using the named charset, storing the result into a new byte array.
`byte[]`	`getBytesAscII()` Returns byte array of string composed of only ascii chars
`byte[]`	`getBytesUTF8()` Returns byte array of string composed of UTF-8 chars
`void`	`getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)` Copy part of the char sequence into another array
`int`	`hashCode()`
`int`	`indexOf(CharSequence str, int fromIndex)` Returns the index within this str of the first occurrence of the specified substring, starting at the specified index.
`int`	`indexOf(int ch, int fromIndex)` Returns the index within this str of the first occurrence of the specified character.
`int`	`indexOf(Str str, int fromIndex)` Locate another str inside this str, start at the specified index
`Str`	`insert(int index, char... ca)` Return a new str with character array inserted into the char sequence of this str
`Str`	`insert(int index, char character)` Return a new str with character inserted into the char sequence of this str
`Str`	`insert(int index, Character... ca)` Return a new str with character array inserted into the char sequence of this str
`Str`	`insert(int index, Character character)` Return a new str with character inserted into the char sequence of this str
`Str`	`insert(int index, StrBase<?> str)` Returns a new str with a string specified inserted into the char sequence of this str
`Str`	`insert(int index, String s)` Returns a new str with a string specified inserted into the char sequence of this str
`String`	`intern()`
`boolean`	`isBlank()` Check if this str is blank (empty or all space characters)
`boolean`	`isEmpty()` Is this traversal empty?
`int`	`lastIndexOf(CharSequence str, int fromIndex)` Returns the index within this str of the last occurrence of the specified substring, searching backward starting at the specified index.
`int`	`lastIndexOf(int ch, int fromIndex)` Returns the index within this str of the last occurrence of the specified character, searching backward starting at the specified index.
`int`	`lastIndexOf(Str str, int fromIndex)` Returns the index within this str of the last occurrence of the specified str, searching backward starting at the specified index.
`int`	`length()`
`Str`	`lpad(char c, int times)` Alias of `StrBase.padLeft(char, int)`
`Str`	`lpad(int times)` Alias of `StrBase.padLeft(int)`
`boolean`	`matches(String regex)` Tells whether or not this str matches the given regular expression.
`static Str`	`of(char... ca)`
`static Str`	`of(Character... chars)`
`static Str`	`of(Collection<Character> col)`
`static Str`	`of(Iterable<Character> itr)`
`static Str`	`of(Iterator<Character> itr)`
`static Str`	`of(String s)`
`static Str`	`of(StringBuilder sb)`
`Str`	`padLeft(char c, int times)` Returns a str instance with `times` of char `c` left pad to the current str
`Str`	`padLeft(int times)` Returns a str instance with `times` of char `' '` (space) left pad to the current str
`Str`	`padRight(char c, int times)` Returns a str instance with `times` of char `c` right pad to the current str
`Str`	`padRight(int times)` Returns a str instance with `times` of char `' '` (space) right pad to the current str
`Str`	`prepend(C.List<Character> list)` Return a str instance contains all characters of this str instance prepended with all characters in the list specified
`Str`	`prepend(char... chars)` Return a str instance contains all characters of this str instance prepended with all characters in the array specified
`Str`	`prepend(Character character)` Returns a str instance contains all characters of this str instance prepended with the character specified
`Str`	`prepend(Collection<? extends Character> collection)` Returns a str instance contains all characters of this str instance prepended with all characters in teh collection
`Str`	`prepend(Str s)` Returns a str instance contains all characters of this str instance prepended with all characters in the str specified
`Str`	`prepend(String s)` Returns a str instance contains all characters of this str instance prepended with all characters in the `String` specified
`boolean`	`regionMatches(boolean ignoreCase, int toffset, CharSequence other, int ooffset, int len)` Tests if two string regions are equal.
`boolean`	`regionMatches(boolean ignoreCase, int toffset, Str other, int ooffset, int len)` Tests if two string regions are equal.
`Str`	`remove(Lang.Function<? super Character,Boolean> predicate)` Returns a str that with all characters in this str instance except those matches the test of predicate function specified
`Str`	`replace(char oldChar, char newChar)` Returns a new str resulting from replacing all occurrences of `oldChar` in this string with `newChar`.
`Str`	`replace(CharSequence target, CharSequence replacement)` Replaces each substring of this str that matches the literal target sequence with the specified literal replacement sequence.
`Str`	`replaceAll(String regex, String replacement)` Replaces each substr of this str that matches the given regular expression with the given replacement.
`Str`	`replaceFirst(String regex, String replacement)` Replaces the first substring of this str that matches the given regular expression with the given replacement.
`Str`	`reverse()` Returns a str that contains all characters in this str instance but in a reversed order.
`Str`	`rpad(char c, int times)` Alias of `StrBase.padRight(char, int)`
`Str`	`rpad(int times)` Alias of `StrBase.padRight(int)`
`C.List<Str>`	`split(String regex, int limit)`
`boolean`	`startsWith(CharSequence prefix, int toffset)` Check if this str starts with a char sequence, with the search starts at the specified offset
`boolean`	`startsWith(Str prefix, int toffset)` Check this str instance starts with str, with the search starts at specified offset
`Str`	`strip(String prefix, String suffix)`
`Str`	`subList(int fromIndex, int toIndex)` Returns a sub str that is a part of this str
`Str`	`subSequence(int start, int end)` Return a part of this str specified by start inclusive and end exclusive position.
`String`	`substring(int beginIndex)` Return a sub string of type `String` of this str starts from `beginIndex` specified till the end of the char array of this str
`String`	`substring(int beginIndex, int endIndex)` Returns a new string that is a substring of this str.
`Str`	`takeWhile(Lang.Function<? super Character,Boolean> predicate)` Return a str that contains the first N characters in this string, the characters in the new str must matches the test specified by the predicate function.
`Str`	`times(int n)` Returns a str instance that repeat this str’s char sequence for `n` times
`FastStr`	`toFastStr()` Return a `FastStr` that contains all the char sequence in this str instance
`Str`	`toLowerCase(Locale locale)`
`String`	`toString()`
`Str`	`toUpperCase(Locale locale)`
`Str`	`trim()`
`Str`	`urlEncode()`

Methods inherited from class org.osgl.util.StrBase
accept, acceptLeft, acceptRight, add, after, after, before, before, concat, concat, contains, contentEquals, copy, copy, count, count, countWithOverlap, countWithOverlap, cutOff, drop, eager, empty, endsWith, endsWith, eq, eq, eq, equals, filter, flatMap, get, head, indexOf, indexOf, indexOf, indexOf, indexOf, indexOf, initFeatures, lastIndexOf, lastIndexOf, lastIndexOf, lastIndexOf, lastIndexOf, lastIndexOf, lazy, listIterator, lower, lower, map, maxLength, notEmpty, parallel, pos, pos, pos, pos, pos, pos, readOnly, regionMatches, regionMatches, remove, rpos, rpos, rpos, rpos, rpos, rpos, set, setFeature, size, snapshot, split, startsWith, startsWith, substr, substr, tail, tail, take, toCharArray, toLowerCase, toUpperCase, unsetFeature, upper, upper, val, value

Methods inherited from class org.osgl.util.ListBase
accept, acceptLeft, acceptRight, add, addAll, allMatch, anyMatch, append, append, append, append, append, appendList, appendReversibleSeq, asList, collect, count, each, each, features_, features, findFirst, findLast, findOne, first, forEach, forEach, forEachLeft, forEachLeft, forEachRight, forEachRight, head, insert, is, isImmutable, isLazy, isMutable, isReadOnly, iterator, last, locate, locateFirst, locateLast, noneMatch, prepend, prepend, prepend, prepend, prepend, prependList, prependReversibleSeq, reduce, reduce, reduceLeft, reduceLeft, reduceRight, reduceRight, reverseIterator, sequential, sorted, sorted, split, toMap, toMapByKey, toMapByVal, unique, unique, without, without, without, zip, zip, zip, zipAll, zipAll, zipAll, zipWithIndex

Methods inherited from class java.util.AbstractList
addAll, clear, listIterator, removeRange

Methods inherited from class java.util.AbstractCollection
addAll, contains, containsAll, remove, removeAll, retainAll, toArray, toArray

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

Methods inherited from interface java.lang.CharSequence
chars, codePoints

Methods inherited from interface java.util.List
addAll, addAll, clear, contains, containsAll, listIterator, remove, removeAll, replaceAll, retainAll, sort, spliterator, toArray, toArray

Methods inherited from interface java.util.Collection
parallelStream, removeIf, stream

Methods inherited from interface java.lang.Iterable
forEach

- Field Detail
  - EMPTY_STR
```
public static final Str EMPTY_STR
```
- Constructor Detail
  - Str
```
protected Str()
```
- Method Detail
  - _impl
```
protected Class<Str> _impl()
```
    Description copied from class: StrBase
    
    Return the class of the implementation
    
    Specified by:
    
    _impl in class StrBase<Str>
    
    Returns:
    
    the implementation class
  - _empty
```
protected Str _empty()
```
    Description copied from class: StrBase
    
    Check if the str is empty
    
    Specified by:
    
    _empty in class StrBase<Str>
    
    Returns:
    
    true if the str is empty
  - length
```
public int length()
```
  - isEmpty
```
public boolean isEmpty()
```
    Description copied from interface: C.Traversable
    
    Is this traversal empty?
    
    Specified by:
    
    isEmpty in interface Collection<Character>
    
    Specified by:
    
    isEmpty in interface List<Character>
    
    Specified by:
    
    isEmpty in interface C.Traversable<Character>
    
    Overrides:
    
    isEmpty in class AbstractCollection<Character>
    
    Returns:
    
    true if the traversal is empty or false otherwise
  - isBlank
```
public boolean isBlank()
```
    Description copied from class: StrBase
    
    Check if this str is blank (empty or all space characters)
    
    Specified by:
    
    isBlank in class StrBase<Str>
    
    Returns:
    
    true if this str is blank
  - subList
```
public Str subList(int fromIndex,
                   int toIndex)
```
    Description copied from class: StrBase
    
    Returns a sub str that is a part of this str
    
    Specified by:
    
    subList in interface List<Character>
    
    Specified by:
    
    subList in interface C.List<Character>
    
    Specified by:
    
    subList in class StrBase<Str>
    
    Parameters:
    
    fromIndex - the from (inclusive)
    
    toIndex - the to (exclusive)
    
    Returns:
    
    a sub str start at fromIndex and end at (@code toIndex)
    
    See Also:
    
    StrBase.subSequence(int, int), StrBase.substr(int, int)
  - takeWhile
```
public Str takeWhile(Lang.Function<? super Character,Boolean> predicate)
```
    Description copied from class: StrBase
    
    Return a str that contains the first N characters in this string, the characters in the new str must matches the test specified by the predicate function. The match operation stop at the first character that does not match the predicate
    
    Specified by:
    
    takeWhile in interface C.List<Character>
    
    Specified by:
    
    takeWhile in interface C.ReversibleSequence<Character>
    
    Specified by:
    
    takeWhile in interface C.Sequence<Character>
    
    Specified by:
    
    takeWhile in class StrBase<Str>
    
    Parameters:
    
    predicate - test if the character should be put into the new str or should stop matching
    
    Returns:
    
    the new str with first N characters matches the test by predicate
  - dropWhile
```
public Str dropWhile(Lang.Function<? super Character,Boolean> predicate)
```
    Description copied from class: StrBase
    
    Return a str that without the first N characters in the string. The characters been dropped must matches the test specified by teh predicate function. The match operation stop at the first character that matches the predicate
    
    Specified by:
    
    dropWhile in interface C.List<Character>
    
    Specified by:
    
    dropWhile in interface C.ReversibleSequence<Character>
    
    Specified by:
    
    dropWhile in interface C.Sequence<Character>
    
    Specified by:
    
    dropWhile in class StrBase<Str>
    
    Parameters:
    
    predicate - the function test if character should be dropped in the new str or stop match operation
    
    Returns:
    
    the new str as described
  - remove
```
public Str remove(Lang.Function<? super Character,Boolean> predicate)
```
    Description copied from class: StrBase
    
    Returns a str that with all characters in this str instance except those matches the test of predicate function specified
    
    Specified by:
    
    remove in interface C.List<Character>
    
    Specified by:
    
    remove in class StrBase<Str>
    
    Parameters:
    
    predicate - the function determine which character in this str will be removed
    
    Returns:
    
    a str with characters identified by predicate removed
  - insert
```
public Str insert(int index,
                  char character)
           throws StringIndexOutOfBoundsException
```
    Description copied from class: StrBase
    
    Return a new str with character inserted into the char sequence of this str
    
    Specified by:
    
    insert in class StrBase<Str>
    
    Parameters:
    
    index - the position to insert the character
    
    character - the char to be inserted
    
    Returns:
    
    an new str with char inserted into the position specified
    
    Throws:
    
    StringIndexOutOfBoundsException - if index is lesser than 0 or greater than or equals to StrBase.size() of the str
  - insert
```
public Str insert(int index,
                  Character character)
           throws IndexOutOfBoundsException
```
    Description copied from class: StrBase
    
    Return a new str with character inserted into the char sequence of this str
    
    Specified by:
    
    insert in interface C.List<Character>
    
    Specified by:
    
    insert in class StrBase<Str>
    
    Parameters:
    
    index - the position to insert the character
    
    character - the char to be inserted
    
    Returns:
    
    an new str with char inserted into the position specified
    
    Throws:
    
    IndexOutOfBoundsException - Math.abs(index) > size()
  - insert
```
public Str insert(int index,
                  Character... ca)
           throws StringIndexOutOfBoundsException
```
    Description copied from class: StrBase
    
    Return a new str with character array inserted into the char sequence of this str
    
    Specified by:
    
    insert in interface C.List<Character>
    
    Specified by:
    
    insert in class StrBase<Str>
    
    Parameters:
    
    index - the position to insert the character
    
    ca - the char array to be inserted
    
    Returns:
    
    an new str with char inserted into the position specified
    
    Throws:
    
    StringIndexOutOfBoundsException - if index is lesser than 0 or greater than or equals to StrBase.size() of the str
  - insert
```
public Str insert(int index,
                  char... ca)
           throws StringIndexOutOfBoundsException
```
    Description copied from class: StrBase
    
    Return a new str with character array inserted into the char sequence of this str
    
    Specified by:
    
    insert in class StrBase<Str>
    
    Parameters:
    
    index - the position to insert the character
    
    ca - the char array to be inserted
    
    Returns:
    
    an new str with char inserted into the position specified
    
    Throws:
    
    StringIndexOutOfBoundsException - if index is lesser than 0 or greater than or equals to StrBase.size() of the str
  - insert
```
public Str insert(int index,
                  StrBase<?> str)
           throws StringIndexOutOfBoundsException
```
    Description copied from class: StrBase
    
    Returns a new str with a string specified inserted into the char sequence of this str
    
    Specified by:
    
    insert in class StrBase<Str>
    
    Parameters:
    
    index - the position to insert the string
    
    str - the str to be inserted
    
    Returns:
    
    an new str with string inserted into the position specified
    
    Throws:
    
    StringIndexOutOfBoundsException - if index is lesser than 0 or greater than or equals to StrBase.size() of the str
  - insert
```
public Str insert(int index,
                  String s)
           throws StringIndexOutOfBoundsException
```
    Description copied from class: StrBase
    
    Returns a new str with a string specified inserted into the char sequence of this str
    
    Specified by:
    
    insert in class StrBase<Str>
    
    Parameters:
    
    index - the position to insert the string
    
    s - the string to be inserted
    
    Returns:
    
    an new str with string inserted into the position specified
    
    Throws:
    
    StringIndexOutOfBoundsException - if index is lesser than 0 or greater than or equals to StrBase.size() of the str
  - reverse
```
public Str reverse()
```
    Description copied from class: StrBase
    
    Returns a str that contains all characters in this str instance but in a reversed order.
    
    Specified by:
    
    reverse in interface C.List<Character>
    
    Specified by:
    
    reverse in interface C.ReversibleSequence<Character>
    
    Specified by:
    
    reverse in class StrBase<Str>
    
    Returns:
    
    a reversed str
    
    See Also:
    
    C.Feature.LIMITED, C.Featured.is(org.osgl.util.C.Feature)
  - append
```
public Str append(Collection<? extends Character> collection)
```
    Description copied from class: StrBase
    
    Return a str instance contains all characters of this str append with all characters in the collection specified
    
    Specified by:
    
    append in interface C.List<Character>
    
    Specified by:
    
    append in class StrBase<Str>
    
    Parameters:
    
    collection - the character collection to be appended
    
    Returns:
    
    the new str instance as described
  - append
```
public Str append(C.List<Character> list)
```
    Description copied from class: StrBase
    
    Return a str instance contains all characters of this str instance append with all characters in the list specified
    
    Specified by:
    
    append in interface C.List<Character>
    
    Specified by:
    
    append in class StrBase<Str>
    
    Parameters:
    
    list - the list of characters to be appended
    
    Returns:
    
    the new str instance as described
  - append
```
public Str append(char... array)
```
    Description copied from class: StrBase
    
    Return a str instance contains all characters of this str instance append with all characters in the array specified
    
    Specified by:
    
    append in class StrBase<Str>
    
    Parameters:
    
    array - the array of characters to be appended
    
    Returns:
    
    the new str instance as described
  - append
```
public Str append(Character character)
```
    Description copied from class: StrBase
    
    Returns a str instance contains all characters of this str instance appended with the character specified
    
    Specified by:
    
    append in interface C.List<Character>
    
    Specified by:
    
    append in interface C.ReversibleSequence<Character>
    
    Specified by:
    
    append in interface C.Sequence<Character>
    
    Specified by:
    
    append in class StrBase<Str>
    
    Parameters:
    
    character - the character to be appended
    
    Returns:
    
    the new str instance as described
  - append
```
public Str append(Str s)
```
    Description copied from class: StrBase
    
    Returns a str instance contains all characters of this str instance appended with all characters in teh str specified
    
    Specified by:
    
    append in class StrBase<Str>
    
    Parameters:
    
    s - the str in which characters to be appended
    
    Returns:
    
    the new str instance as described
  - append
```
public Str append(String s)
```
    Description copied from class: StrBase
    
    Returns a str instance contains all characters of this str instance appended with all characters in the String specified
    
    Specified by:
    
    append in class StrBase<Str>
    
    Parameters:
    
    s - the String in which characters to be appended
    
    Returns:
    
    the new str instance as described
  - prepend
```
public Str prepend(Collection<? extends Character> collection)
```
    Description copied from class: StrBase
    
    Returns a str instance contains all characters of this str instance prepended with all characters in teh collection
    
    Specified by:
    
    prepend in interface C.List<Character>
    
    Specified by:
    
    prepend in class StrBase<Str>
    
    Parameters:
    
    collection - the collection in which characters to be prepended
    
    Returns:
    
    the new str instance as described
  - prepend
```
public Str prepend(C.List<Character> list)
```
    Description copied from class: StrBase
    
    Return a str instance contains all characters of this str instance prepended with all characters in the list specified
    
    Specified by:
    
    prepend in interface C.List<Character>
    
    Specified by:
    
    prepend in class StrBase<Str>
    
    Parameters:
    
    list - the list of characters to be prepended
    
    Returns:
    
    the new str instance as described
  - prepend
```
public Str prepend(char... chars)
```
    Description copied from class: StrBase
    
    Return a str instance contains all characters of this str instance prepended with all characters in the array specified
    
    Specified by:
    
    prepend in class StrBase<Str>
    
    Parameters:
    
    chars - the array of characters to be prepended
    
    Returns:
    
    the new str instance as described
  - prepend
```
public Str prepend(Character character)
```
    Description copied from class: StrBase
    
    Returns a str instance contains all characters of this str instance prepended with the character specified
    
    Specified by:
    
    prepend in interface C.List<Character>
    
    Specified by:
    
    prepend in interface C.ReversibleSequence<Character>
    
    Specified by:
    
    prepend in interface C.Sequence<Character>
    
    Specified by:
    
    prepend in class StrBase<Str>
    
    Parameters:
    
    character - the character to be preppended
    
    Returns:
    
    the new str instance as described
  - prepend
```
public Str prepend(Str s)
```
    Description copied from class: StrBase
    
    Returns a str instance contains all characters of this str instance prepended with all characters in the str specified
    
    Specified by:
    
    prepend in class StrBase<Str>
    
    Parameters:
    
    s - the str in which characters to be prepended
    
    Returns:
    
    the new str instance as described
  - prepend
```
public Str prepend(String s)
```
    Description copied from class: StrBase
    
    Returns a str instance contains all characters of this str instance prepended with all characters in the String specified
    
    Specified by:
    
    prepend in class StrBase<Str>
    
    Parameters:
    
    s - the String in which characters to be prepended
    
    Returns:
    
    the new str instance as described
  - charAt
```
public char charAt(int index)
```
  - subSequence
```
public Str subSequence(int start,
                       int end)
```
    Description copied from class: StrBase
    
    Return a part of this str specified by start inclusive and end exclusive position.
    Note calling this method has the same effect with calling StrBase.subList(int, int) and calling StrBase.substr(int, int)
    
    Specified by:
    
    subSequence in interface CharSequence
    
    Specified by:
    
    subSequence in class StrBase<Str>
    
    Parameters:
    
    start - the start position
    
    end - the end position
    
    Returns:
    
    the part of this str as described
    
    See Also:
    
    StrBase.subList(int, int), StrBase.substr(int, int)
  - times
```
public Str times(int n)
```
    Description copied from class: StrBase
    
    Returns a str instance that repeat this str’s char sequence for n times
    
    Specified by:
    
    times in class StrBase<Str>
    
    Parameters:
    
    n - repeat times
    
    Returns:
    
    the new str as described
  - padLeft
```
public Str padLeft(char c,
                   int times)
```
    Description copied from class: StrBase
    
    Returns a str instance with times of char c left pad to the current str
    
    Specified by:
    
    padLeft in class StrBase<Str>
    
    Parameters:
    
    c - the char used to pad to this str
    
    times - the repeat times
    
    Returns:
    
    the str instance as described above
  - lpad
```
public Str lpad(char c,
                int times)
```
    Description copied from class: StrBase
    
    Alias of StrBase.padLeft(char, int)
    
    Specified by:
    
    lpad in class StrBase<Str>
    
    Parameters:
    
    c - the char used to pad to this str
    
    times - the repeat times
    
    Returns:
    
    the str instance as described above
  - padLeft
```
public Str padLeft(int times)
```
    Description copied from class: StrBase
    
    Returns a str instance with times of char ' ' (space) left pad to the current str
    
    Specified by:
    
    padLeft in class StrBase<Str>
    
    Parameters:
    
    times - the repeat times
    
    Returns:
    
    the str instance as described above
  - lpad
```
public Str lpad(int times)
```
    Description copied from class: StrBase
    
    Alias of StrBase.padLeft(int)
    
    Specified by:
    
    lpad in class StrBase<Str>
    
    Parameters:
    
    times - the repeat times
    
    Returns:
    
    the str instance as described above
  - padRight
```
public Str padRight(char c,
                    int times)
```
    Description copied from class: StrBase
    
    Returns a str instance with times of char c right pad to the current str
    
    Specified by:
    
    padRight in class StrBase<Str>
    
    Parameters:
    
    c - the char used to pad to this str
    
    times - the repeat times
    
    Returns:
    
    the str instance as described above
  - rpad
```
public Str rpad(char c,
                int times)
```
    Description copied from class: StrBase
    
    Alias of StrBase.padRight(char, int)
    
    Specified by:
    
    rpad in class StrBase<Str>
    
    Parameters:
    
    c - the char used to pad to this str
    
    times - the repeat times
    
    Returns:
    
    the str instance as described above
  - padRight
```
public Str padRight(int times)
```
    Description copied from class: StrBase
    
    Returns a str instance with times of char ' ' (space) right pad to the current str
    
    Specified by:
    
    padRight in class StrBase<Str>
    
    Parameters:
    
    times - the repeat times
    
    Returns:
    
    the str instance as described above
  - rpad
```
public Str rpad(int times)
```
    Description copied from class: StrBase
    
    Alias of StrBase.padRight(int)
    
    Specified by:
    
    rpad in class StrBase<Str>
    
    Parameters:
    
    times - the repeat times
    
    Returns:
    
    the str instance as described above
  - compareTo
```
public int compareTo(Str o)
```
  - toString
```
public String toString()
```
    Specified by:
    
    toString in interface CharSequence
    
    Overrides:
    
    toString in class AbstractCollection<Character>
  - toFastStr
```
public FastStr toFastStr()
```
    Description copied from class: StrBase
    
    Return a FastStr that contains all the char sequence in this str instance
    
    Specified by:
    
    toFastStr in class StrBase<Str>
    
    Returns:
    
    a FastStr as described
  - hashCode
```
public int hashCode()
```
    Specified by:
    
    hashCode in interface Collection<Character>
    
    Specified by:
    
    hashCode in interface List<Character>
    
    Overrides:
    
    hashCode in class ListBase<Character>
  - getChars
```
public void getChars(int srcBegin,
                     int srcEnd,
                     char[] dst,
                     int dstBegin)
```
    Description copied from class: StrBase
    
    Copy part of the char sequence into another array
    
    Specified by:
    
    getChars in class StrBase<Str>
    
    Parameters:
    
    srcBegin - the start of copy inclusive
    
    srcEnd - the end of copy exclusive
    
    dst - the destination array
    
    dstBegin - the start of past in destination array
  - getBytes
```
public byte[] getBytes()
```
    Description copied from class: StrBase
    
    Encodes this str into a sequence of bytes using the platform’s default charset, storing the result into a new byte array.
    
    Specified by:
    
    getBytes in class StrBase<Str>
    
    Returns:
    
    The resultant byte array
    
    See Also:
    
    String.getBytes()
  - getBytes
```
public byte[] getBytes(String charsetName)
```
    Description copied from class: StrBase
    
    Encodes this str into a sequence of bytes using the named charset, storing the result into a new byte array.
    
    Specified by:
    
    getBytes in class StrBase<Str>
    
    Parameters:
    
    charsetName - The name of a supported charset. If charsetName is null then this function shall return the result of StrBase.getBytes()
    
    Returns:
    
    The resultant byte array
    
    See Also:
    
    String.getBytes(String)
  - getBytes
```
public byte[] getBytes(Charset charset)
```
    Description copied from class: StrBase
    
    Encodes this str into a sequence of bytes using the given charset, storing the result into a new byte array.
    
    Specified by:
    
    getBytes in class StrBase<Str>
    
    Parameters:
    
    charset - The Charset to be used to encode the String. If charset is null then this function shall return the result of StrBase.getBytes()
    
    Returns:
    
    The resultant byte array
    
    See Also:
    
    String.getBytes(Charset)
  - getBytesAscII
```
public byte[] getBytesAscII()
```
    Description copied from class: StrBase
    
    Returns byte array of string composed of only ascii chars
    
    Specified by:
    
    getBytesAscII in class StrBase<Str>
    
    Returns:
    
    ASCII char array of this str
  - getBytesUTF8
```
public byte[] getBytesUTF8()
```
    Description copied from class: StrBase
    
    Returns byte array of string composed of UTF-8 chars
    
    Specified by:
    
    getBytesUTF8 in class StrBase<Str>
    
    Returns:
    
    UTF-8 char array of this str
  - contentEquals
```
public boolean contentEquals(CharSequence x)
```
    Description copied from class: StrBase
    
    Check if this str content is equals to the char sequence specified
    
    Specified by:
    
    contentEquals in class StrBase<Str>
    
    Parameters:
    
    x - the char sequence to be checked agains this str
    
    Returns:
    
    true if content of this str equals to that of the chars
  - contentEquals
```
public boolean contentEquals(Str x)
```
    Description copied from class: StrBase
    
    Check if this str content iks equals to the str specified
    
    Specified by:
    
    contentEquals in class StrBase<Str>
    
    Parameters:
    
    x - the str instance
    
    Returns:
    
    true if content of this str equals to that of the str
  - equalsIgnoreCase
```
public boolean equalsIgnoreCase(CharSequence x)
```
    Description copied from class: StrBase
    
    Compare content of the str and the specified char sequence, case insensitive
    
    Specified by:
    
    equalsIgnoreCase in class StrBase<Str>
    
    Parameters:
    
    x - the char sequence to be checked
    
    Returns:
    
    true if the argument is not null and it represents an equivalent String ignoring case; false otherwise
  - compareTo
```
public int compareTo(CharSequence x)
```
    Description copied from class: StrBase
    
    Compare the char sequence specified against this str
    
    Specified by:
    
    compareTo in class StrBase<Str>
    
    Parameters:
    
    x - the char sequence to be compared to this str
    
    Returns:
    
    the result of the comparison
    
    See Also:
    
    String.compareTo(String)
  - compareToIgnoreCase
```
public int compareToIgnoreCase(Str x)
```
    Description copied from class: StrBase
    
    Compare the str specified against this str in a case insensitive manner
    
    Specified by:
    
    compareToIgnoreCase in class StrBase<Str>
    
    Parameters:
    
    x - the str to be compared to this str
    
    Returns:
    
    the result of the comparison
    
    See Also:
    
    String.compareToIgnoreCase(String)
  - compareToIgnoreCase
```
public int compareToIgnoreCase(CharSequence x)
```
    Description copied from class: StrBase
    
    Compare the char sequence specified against this str in a case insensitive manner
    
    Specified by:
    
    compareToIgnoreCase in class StrBase<Str>
    
    Parameters:
    
    x - the char sequence to be compared to this str
    
    Returns:
    
    the result of the comparison
    
    See Also:
    
    String.compareToIgnoreCase(String)
  - regionMatches
```
public boolean regionMatches(boolean ignoreCase,
                             int toffset,
                             Str other,
                             int ooffset,
                             int len)
```
    Description copied from class: StrBase
    
    Tests if two string regions are equal.
    
    Specified by:
    
    regionMatches in class StrBase<Str>
    
    Parameters:
    
    ignoreCase - if true, ignore case when comparing characters.
    
    toffset - the starting offset of the subregion in this str.
    
    other - the str argument.
    
    ooffset - the starting offset of the subregion in the str argument.
    
    len - the number of characters to compare.
    
    Returns:
    
    true if the specified subregion of this string matches the specified subregion of the string argument; false otherwise. Whether the matching is exact or case insensitive depends on the ignoreCase argument.
    
    See Also:
    
    String.regionMatches(boolean, int, String, int, int)
  - regionMatches
```
public boolean regionMatches(boolean ignoreCase,
                             int toffset,
                             CharSequence other,
                             int ooffset,
                             int len)
```
    Description copied from class: StrBase
    
    Tests if two string regions are equal.
    
    Specified by:
    
    regionMatches in class StrBase<Str>
    
    Parameters:
    
    ignoreCase - if true, ignore case when comparing characters.
    
    toffset - the starting offset of the subregion in this str.
    
    other - the char sequence argument.
    
    ooffset - the starting offset of the subregion in the str argument.
    
    len - the number of characters to compare.
    
    Returns:
    
    true if the specified subregion of this string matches the specified subregion of the string argument; false otherwise. Whether the matching is exact or case insensitive depends on the ignoreCase argument.
    
    See Also:
    
    String.regionMatches(boolean, int, String, int, int)
  - startsWith
```
public boolean startsWith(Str prefix,
                          int toffset)
```
    Description copied from class: StrBase
    
    Check this str instance starts with str, with the search starts at specified offset
    
    Specified by:
    
    startsWith in class StrBase<Str>
    
    Parameters:
    
    prefix - the str arguments
    
    toffset - the offset where the search begins
    
    Returns:
    
    true if the search matches or false otherwise
  - startsWith
```
public boolean startsWith(CharSequence prefix,
                          int toffset)
```
    Description copied from class: StrBase
    
    Check if this str starts with a char sequence, with the search starts at the specified offset
    
    Specified by:
    
    startsWith in class StrBase<Str>
    
    Parameters:
    
    prefix - the char sequence argument
    
    toffset - the start offset where search begins
    
    Returns:
    
    true if search matches or false otherwise
  - endsWith
```
public boolean endsWith(CharSequence suffix,
                        int offset)
```
    Description copied from class: StrBase
    
    Check if this str ends with a char sequence, with the search starts at the specified offset
    
    Specified by:
    
    endsWith in class StrBase<Str>
    
    Parameters:
    
    suffix - the char sequence argument
    
    offset - the start offset where search begins backwards
    
    Returns:
    
    true if search matches or false otherwise
  - endsWith
```
public boolean endsWith(Str suffix,
                        int toffset)
```
    Description copied from class: StrBase
    
    Check this str instance ends with str, with the search starts at specified offset
    
    Specified by:
    
    endsWith in class StrBase<Str>
    
    Parameters:
    
    suffix - the str arguments
    
    toffset - the offset where the search begins (backwards)
    
    Returns:
    
    true if the search matches or false otherwise
  - indexOf
```
public int indexOf(int ch,
                   int fromIndex)
```
    Description copied from class: StrBase
    
    Returns the index within this str of the first occurrence of the specified character.
    
    Specified by:
    
    indexOf in class StrBase<Str>
    
    Parameters:
    
    ch - a character (Unicode code point).
    
    fromIndex - the from index
    
    Returns:
    
    the index of the first occurrence of the character in the character sequence represented by this object, or -1 if the character does not occur.
    
    See Also:
    
    String.indexOf(int, int)
  - lastIndexOf
```
public int lastIndexOf(int ch,
                       int fromIndex)
```
    Description copied from class: StrBase
    
    Returns the index within this str of the last occurrence of the specified character, searching backward starting at the specified index.
    
    Specified by:
    
    lastIndexOf in class StrBase<Str>
    
    Parameters:
    
    ch - a character (Unicode code point).
    
    fromIndex - the index to start the search from. There is no restriction on the value of fromIndex. If it is greater than or equal to the length of this str, it has the same effect as if it were equal to one less than the length of this str: this entire str may be searched. If it is negative, it has the same effect as if it were -1: -1 is returned.
    
    Returns:
    
    the index of the last occurrence of the character in the character sequence represented by this object that is less than or equal to fromIndex, or -1 if the character does not occur before that point.
    
    See Also:
    
    String.lastIndexOf(int, int)
  - indexOf
```
public int indexOf(CharSequence str,
                   int fromIndex)
```
    Description copied from class: StrBase
    
    Returns the index within this str of the first occurrence of the specified substring, starting at the specified index.
    
    Specified by:
    
    indexOf in class StrBase<Str>
    
    Parameters:
    
    str - the substring to search for.
    
    fromIndex - the index from which to start the search.
    
    Returns:
    
    the index of the first occurrence of the specified substring, starting at the specified index, or -1 if there is no such occurrence.
    
    See Also:
    
    String.indexOf(String, int)
  - indexOf
```
public int indexOf(Str str,
                   int fromIndex)
```
    Description copied from class: StrBase
    
    Locate another str inside this str, start at the specified index
    
    Specified by:
    
    indexOf in class StrBase<Str>
    
    Parameters:
    
    str - the search string
    
    fromIndex - from where the search should begin
    
    Returns:
    
    the location found or -1 if not found
  - lastIndexOf
```
public int lastIndexOf(CharSequence str,
                       int fromIndex)
```
    Description copied from class: StrBase
    Returns the index within this str of the last occurrence of the specified substring, searching backward starting at the specified index.
    
    The returned index is the largest value k for which:
    k <= fromIndex && this.startsWith(str, k)
    If no such value of k exists, then -1 is returned.
    Specified by:
    
    lastIndexOf in class StrBase<Str>
    
    Parameters:
    
    str - the string to search for.
    
    fromIndex - the index to start the search from.
    
    Returns:
    
    the index of the last occurrence of the specified substring, searching backward from the specified index, or -1 if there is no such occurrence.
    
    See Also:
    
    String.lastIndexOf(String)
  - lastIndexOf
```
public int lastIndexOf(Str str,
                       int fromIndex)
```
    Description copied from class: StrBase
    Returns the index within this str of the last occurrence of the specified str, searching backward starting at the specified index.
    
    The returned index is the largest value k for which:
    k <= fromIndex && this.startsWith(str, k)
    If no such value of k exists, then -1 is returned.
    Specified by:
    
    lastIndexOf in class StrBase<Str>
    
    Parameters:
    
    str - the str to search for.
    
    fromIndex - the index to start the search from.
    
    Returns:
    
    the index of the last occurrence of the specified str, searching backward from the specified index, or -1 if there is no such occurrence.
    
    See Also:
    
    String.lastIndexOf(String), StrBase.lastIndexOf(CharSequence, int)
  - substring
```
public String substring(int beginIndex)
```
    Description copied from class: StrBase
    
    Return a sub string of type String of this str starts from beginIndex specified till the end of the char array of this str
    
    Specified by:
    
    substring in class StrBase<Str>
    
    Parameters:
    
    beginIndex - the start index of the sub string
    
    Returns:
    
    the sub string as described
  - substring
```
public String substring(int beginIndex,
                        int endIndex)
```
    Description copied from class: StrBase
    
    Returns a new string that is a substring of this str. The substring begins at the specified beginIndex and extends to the character at index endIndex - 1. Thus the length of the substring is endIndex-beginIndex.
    
    Specified by:
    
    substring in class StrBase<Str>
    
    Parameters:
    
    beginIndex - the beginning index, inclusive.
    
    endIndex - the ending index, exclusive.
    
    Returns:
    
    the specified substring.
    
    See Also:
    
    String.substring(int, int)
  - replace
```
public Str replace(char oldChar,
                   char newChar)
```
    Description copied from class: StrBase
    
    Returns a new str resulting from replacing all occurrences of oldChar in this string with newChar.
    If the character oldChar does not occur in the character sequence represented by this str object, then a reference to this str object is returned. Otherwise, a new str object is created that represents a character sequence identical to the character sequence represented by this str object, except that every occurrence of oldChar is replaced by an occurrence of newChar.
    
    Specified by:
    
    replace in class StrBase<Str>
    
    Parameters:
    
    oldChar - the old character.
    
    newChar - the new character.
    
    Returns:
    
    a str derived from this str by replacing every occurrence of oldChar with newChar.
  - matches
```
public boolean matches(String regex)
```
    Description copied from class: StrBase
    
    Tells whether or not this str matches the given regular expression.
    
    Specified by:
    
    matches in class StrBase<Str>
    
    Parameters:
    
    regex - the regular expression to which this string is to be matched
    
    Returns:
    
    true if, and only if, this string matches the given regular expression
    
    See Also:
    
    Pattern, String.matches(String)
  - contains
```
public boolean contains(CharSequence s)
```
    Specified by:
    
    contains in class StrBase<Str>
  - replaceFirst
```
public Str replaceFirst(String regex,
                        String replacement)
```
    Description copied from class: StrBase
    
    Replaces the first substring of this str that matches the given regular expression with the given replacement.
    
    Specified by:
    
    replaceFirst in class StrBase<Str>
    
    Parameters:
    
    regex - the regular expression to which this str is to be matched
    
    replacement - the string to be substituted for the first match
    
    Returns:
    
    The resulting str
    
    See Also:
    
    Pattern, String.replaceFirst(String, String)
  - replaceAll
```
public Str replaceAll(String regex,
                      String replacement)
```
    Description copied from class: StrBase
    
    Replaces each substr of this str that matches the given regular expression with the given replacement.
    
    Specified by:
    
    replaceAll in class StrBase<Str>
    
    Parameters:
    
    regex - the regular expression to which this string is to be matched
    
    replacement - the string to be substituted for each match
    
    Returns:
    
    The resulting str
    
    See Also:
    
    Pattern, String.replaceAll(String, String)
  - replace
```
public Str replace(CharSequence target,
                   CharSequence replacement)
```
    Description copied from class: StrBase
    
    Replaces each substring of this str that matches the literal target sequence with the specified literal replacement sequence. The replacement proceeds from the beginning of the str to the end, for example, replacing “aa” with “b” in the str “aaa” will result in “ba” rather than “ab”.
    
    Specified by:
    
    replace in class StrBase<Str>
    
    Parameters:
    
    target - The sequence of char values to be replaced
    
    replacement - The replacement sequence of char values
    
    Returns:
    
    The resulting string
  - split
```
public C.List<Str> split(String regex,
                         int limit)
```
    Specified by:
    
    split in class StrBase<Str>
  - toLowerCase
```
public Str toLowerCase(Locale locale)
```
    Specified by:
    
    toLowerCase in class StrBase<Str>
  - toUpperCase
```
public Str toUpperCase(Locale locale)
```
    Specified by:
    
    toUpperCase in class StrBase<Str>
  - trim
```
public Str trim()
```
    Specified by:
    
    trim in class StrBase<Str>
  - charArray
```
public char[] charArray()
```
    Specified by:
    
    charArray in class StrBase<Str>
  - intern
```
public String intern()
```
    Specified by:
    
    intern in class StrBase<Str>
  - afterFirst
```
public Str afterFirst(Str s)
```
    Specified by:
    
    afterFirst in class StrBase<Str>
  - afterLast
```
public Str afterLast(Str s)
```
    Specified by:
    
    afterLast in class StrBase<Str>
  - beforeLast
```
public Str beforeLast(Str s)
```
    Specified by:
    
    beforeLast in class StrBase<Str>
  - afterFirst
```
public Str afterFirst(String s)
```
    Specified by:
    
    afterFirst in class StrBase<Str>
  - afterLast
```
public Str afterLast(String s)
```
    Specified by:
    
    afterLast in class StrBase<Str>
  - afterFirst
```
public Str afterFirst(char c)
```
    Specified by:
    
    afterFirst in class StrBase<Str>
  - afterLast
```
public Str afterLast(char c)
```
    Specified by:
    
    afterLast in class StrBase<Str>
  - beforeFirst
```
public Str beforeFirst(Str s)
```
    Specified by:
    
    beforeFirst in class StrBase<Str>
  - beforeFirst
```
public Str beforeFirst(String s)
```
    Specified by:
    
    beforeFirst in class StrBase<Str>
  - beforeLast
```
public Str beforeLast(String s)
```
    Specified by:
    
    beforeLast in class StrBase<Str>
  - strip
```
public Str strip(String prefix,
                 String suffix)
```
    Specified by:
    
    strip in class StrBase<Str>
  - beforeFirst
```
public Str beforeFirst(char c)
```
    Specified by:
    
    beforeFirst in class StrBase<Str>
  - beforeLast
```
public Str beforeLast(char c)
```
    Specified by:
    
    beforeLast in class StrBase<Str>
  - urlEncode
```
public Str urlEncode()
```
    Specified by:
    
    urlEncode in class StrBase<Str>
  - decodeBASE64
```
public Str decodeBASE64()
```
    Specified by:
    
    decodeBASE64 in class StrBase<Str>
  - encodeBASE64
```
public Str encodeBASE64()
```
    Specified by:
    
    encodeBASE64 in class StrBase<Str>
  - capFirst
```
public Str capFirst()
```
    Specified by:
    
    capFirst in class StrBase<Str>
  - count
```
public int count(String search,
                 boolean overlap)
```
    Specified by:
    
    count in class StrBase<Str>
  - count
```
public int count(Str search,
                 boolean overlap)
```
    Specified by:
    
    count in class StrBase<Str>
  - of
```
public static Str of(String s)
```
  - of
```
public static Str of(Character... chars)
```
  - of
```
public static Str of(char... ca)
```
  - of
```
public static Str of(StringBuilder sb)
```
  - of
```
public static Str of(Iterable<Character> itr)
```
  - of
```
public static Str of(Collection<Character> col)
```
  - of
```
public static Str of(Iterator<Character> itr)
```

Class Str

Nested Class Summary

Nested classes/interfaces inherited from class org.osgl.util.StrBase

Nested classes/interfaces inherited from interface org.osgl.util.C.List

Nested classes/interfaces inherited from interface org.osgl.util.C.Featured

Field Summary

Fields inherited from class java.util.AbstractList

Constructor Summary

Method Summary

Methods inherited from class org.osgl.util.StrBase

Methods inherited from class org.osgl.util.ListBase

Methods inherited from class java.util.AbstractList

Methods inherited from class java.util.AbstractCollection

Methods inherited from class java.lang.Object

Methods inherited from interface java.lang.CharSequence

Methods inherited from interface java.util.List

Methods inherited from interface java.util.Collection

Methods inherited from interface java.lang.Iterable

Field Detail

EMPTY_STR

Constructor Detail

Str

Method Detail

_impl

_empty

length

isEmpty

isBlank

subList

takeWhile

dropWhile

remove

insert

insert

insert

insert

insert

insert

reverse

append

append

append

append

append

append

prepend

prepend

prepend

prepend

prepend

prepend

charAt

subSequence

times

padLeft

lpad

padLeft

lpad

padRight

rpad

padRight

rpad

compareTo

toString

toFastStr

hashCode

getChars

getBytes

getBytes

getBytes

getBytesAscII

getBytesUTF8

contentEquals

contentEquals

equalsIgnoreCase

compareTo

compareToIgnoreCase

compareToIgnoreCase

regionMatches

regionMatches