StrBase (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<T>

Type Parameters:

T - the implementation class type

All Implemented Interfaces:

Serializable, CharSequence, Comparable<T>, Iterable<Character>, Collection<Character>, List<Character>, RandomAccess, C.Featured, C.List<Character>, C.ReversibleSequence<Character>, C.Sequence<Character>, C.Traversable<Character>

Direct Known Subclasses:

FastStr, Str
```
public abstract class StrBase<T extends StrBase<T>>
extends ListBase<Character>
implements RandomAccess, CharSequence, Serializable, Comparable<T>
```
The abstract base class for Str and FastStr. This class aggregates methods from both CharSequence and C.List to provide easy manipulation and also functional programming facilities to char sequence

See Also:

Serialized Form

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class 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

Nested Classes
Modifier and Type	Class and Description
`static class`	`StrBase.F`

Field Summary
- Fields inherited from class java.util.AbstractList
  modCount

Constructor Summary

Constructors
Modifier Constructor and Description

protected StrBase()

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

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`protected abstract T`	`_empty()` Check if the str is empty
`protected abstract Class<T>`	`_impl()` Return the class of the implementation
`T`	`accept(Lang.Visitor<? super Character> visitor)` Iterate this `Traversable` with a visitor function.
`T`	`acceptLeft(Lang.Visitor<? super Character> visitor)` Iterate through this sequence from head to tail with the visitor function specified
`T`	`acceptRight(Lang.Visitor<? super Character> visitor)` Iterate through this sequence from tail to head with the visitor function specified
`void`	`add(int index, Character element)`
`T`	`after(String s)`
`T`	`after(T s)`
`abstract T`	`afterFirst(char c)`
`abstract T`	`afterFirst(String s)`
`abstract T`	`afterFirst(T s)`
`abstract T`	`afterLast(char c)`
`abstract T`	`afterLast(String s)`
`abstract T`	`afterLast(T characters)`
`abstract T`	`append(C.List<Character> list)` Return a str instance contains all characters of this str instance append with all characters in the list specified
`abstract T`	`append(char... array)` Return a str instance contains all characters of this str instance append with all characters in the array specified
`abstract T`	`append(Character character)` Returns a str instance contains all characters of this str instance appended with the character specified
`abstract T`	`append(Collection<? extends Character> collection)` Return a str instance contains all characters of this str append with all characters in the collection specified
`abstract T`	`append(String s)` Returns a str instance contains all characters of this str instance appended with all characters in the `String` specified
`abstract T`	`append(T s)` Returns a str instance contains all characters of this str instance appended with all characters in teh str specified
`T`	`before(String s)`
`T`	`before(T s)`
`abstract T`	`beforeFirst(char c)`
`abstract T`	`beforeFirst(String s)`
`abstract T`	`beforeFirst(T s)`
`abstract T`	`beforeLast(char c)`
`abstract T`	`beforeLast(String s)`
`abstract T`	`beforeLast(T s)`
`abstract T`	`capFirst()`
`abstract char[]`	`charArray()`
`abstract int`	`compareTo(CharSequence x)` Compare the char sequence specified against this str
`abstract int`	`compareToIgnoreCase(CharSequence x)` Compare the char sequence specified against this str in a case insensitive manner
`abstract int`	`compareToIgnoreCase(T x)` Compare the str specified against this str in a case insensitive manner
`T`	`concat(String str)`
`T`	`concat(T str)`
`boolean`	`contains(char c)`
`abstract boolean`	`contains(CharSequence s)`
`abstract boolean`	`contentEquals(CharSequence chars)` Check if this str content is equals to the char sequence specified
`boolean`	`contentEquals(StringBuffer stringBuffer)` Wrapper of `String.contentEquals(StringBuffer)`
`abstract boolean`	`contentEquals(T str)` Check if this str content iks equals to the str specified
`T`	`copy()` Returns a copy of this str.
`void`	`copy(int srcBegin, int srcEnd, char[] dst, int dstBegin)`
`int`	`count(String s)`
`abstract int`	`count(String search, boolean overlap)`
`int`	`count(T s)`
`abstract int`	`count(T search, boolean overlap)`
`int`	`countWithOverlap(String s)`
`int`	`countWithOverlap(T s)`
`T`	`cutOff(int max)`
`abstract T`	`decodeBASE64()`
`T`	`drop(int n)` Returns a `Sequence` consisting of the elements from this `Sequence` except the first `n` if number `n` is positive and the `Sequence` contains more than `n` elements
`abstract T`	`dropWhile(Lang.Function<? super Character,Boolean> predicate)` Return a str that without the first N characters in the string.
`T`	`eager()` Returns this traversable and make sure `C.Feature.LAZY` is unset
`boolean`	`empty()`
`abstract T`	`encodeBASE64()`
`boolean`	`endsWith(CharSequence prefix)` Check if this str ends with the given char sequence
`abstract boolean`	`endsWith(CharSequence prefix, int toffset)` Check if this str ends with a char sequence, with the search starts at the specified offset
`boolean`	`endsWith(T prefix)` Check if this str ends with the given str
`abstract boolean`	`endsWith(T prefix, int toffset)` Check this str instance ends with str, with the search starts at specified offset
`boolean`	`eq(CharSequence x)` Alias of `contentEquals(CharSequence)`
`boolean`	`eq(StringBuffer stringBuffer)` Alias of `contentEquals(StringBuffer)`
`boolean`	`eq(T x)` Alias of `contentEquals(StrBase)`
`boolean`	`equals(Object o)`
`abstract boolean`	`equalsIgnoreCase(CharSequence x)` Compare content of the str and the specified char sequence, case insensitive
`T`	`filter(Lang.Function<? super Character,Boolean> predicate)` Returns an new traversable that contains all elements in the current traversable except that does not pass the test of the filter function specified.
`<R> C.List<R>`	`flatMap(Lang.Function<? super Character,? extends Iterable<? extends R>> mapper)` Returns a traversable consisting of the results of replacing each element of this stream with the contents of the iterable produced by applying the provided mapping function to each element.
`Character`	`get(int index)`
`abstract byte[]`	`getBytes()` Encodes this str into a sequence of bytes using the platform’s default charset, storing the result into a new byte array.
`abstract byte[]`	`getBytes(Charset charset)` Encodes this str into a sequence of bytes using the given charset, storing the result into a new byte array.
`abstract byte[]`	`getBytes(String charsetName)` Encodes this str into a sequence of bytes using the named charset, storing the result into a new byte array.
`abstract byte[]`	`getBytesAscII()` Returns byte array of string composed of only ascii chars
`abstract byte[]`	`getBytesUTF8()` Returns byte array of string composed of UTF-8 chars
`abstract void`	`getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)` Copy part of the char sequence into another array
`T`	`head(int n)` Alias of `C.Sequence.take(int)`
`int`	`indexOf(CharSequence str)` Returns the index within this str of the first occurrence of the specified substring, starting at 0.
`abstract 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)` Returns the index within this str of the first occurrence of the specified character.
`abstract int`	`indexOf(int ch, int fromIndex)` Returns the index within this str of the first occurrence of the specified character.
`int`	`indexOf(List<Character> list)` Returns the index within this str of the first occurrence of the specified character list
`int`	`indexOf(List<Character> list, int startIndex)` Returns the index within this str of the first occurrence of the specified character list, starting at the specified index
`int`	`indexOf(Object o)` Returns the index within this str of the first occurrence of the specified object.
`int`	`indexOf(T x)` Locate another str inside this str, start at the specified index
`abstract int`	`indexOf(T s, int fromIndex)` Locate another str inside this str, start at the specified index
`protected EnumSet<C.Feature>`	`initFeatures()` Sub class should override this method to provide initial feature set for the feature based instance
`abstract T`	`insert(int index, char... ta)` Return a new str with character array inserted into the char sequence of this str
`abstract T`	`insert(int index, char character)` Return a new str with character inserted into the char sequence of this str
`abstract T`	`insert(int index, Character... ca)` Return a new str with character array inserted into the char sequence of this str
`abstract T`	`insert(int index, Character character)` Return a new str with character inserted into the char sequence of this str
`abstract T`	`insert(int index, StrBase<?> str)` Returns a new str with a string specified inserted into the char sequence of this str
`abstract T`	`insert(int index, String s)` Returns a new str with a string specified inserted into the char sequence of this str
`abstract String`	`intern()`
`abstract boolean`	`isBlank()` Check if this str is blank (empty or all space characters)
`int`	`lastIndexOf(CharSequence str)` Returns the index within this str of the last occurrence of the specified substring.
`abstract 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)` Returns the index within this str of the last occurrence of the specified character.
`abstract 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(List<Character> list)` Returns the index within this str of the last occurrence of the specified character list
`int`	`lastIndexOf(List<Character> list, int startIndex)` Returns the index within this str of the last occurrence of the specified character list, starting at the specified index from tail to head
`int`	`lastIndexOf(Object o)` Returns the index within this str of the last occurrence of the specified object.
`int`	`lastIndexOf(T str)` Returns the index within this str of the last occurrence of the specified substr.
`abstract int`	`lastIndexOf(T str, int fromIndex)` Returns the index within this str of the last occurrence of the specified str, searching backward starting at the specified index.
`T`	`lazy()` Returns this traversable and make sure `C.Feature.LAZY` is set
`ListIterator<Character>`	`listIterator(int index)`
`T`	`lower()`
`T`	`lower(Locale locale)`
`abstract T`	`lpad(char c, int times)` Alias of `padLeft(char, int)`
`abstract T`	`lpad(int times)` Alias of `padLeft(int)`
`<R> C.List<R>`	`map(Lang.Function<? super Character,? extends R> mapper)` Returns an new traversable with a mapper function specified.
`abstract boolean`	`matches(String regex)` Tells whether or not this str matches the given regular expression.
`T`	`maxLength(int max)`
`boolean`	`notEmpty()`
`abstract T`	`padLeft(char c, int times)` Returns a str instance with `times` of char `c` left pad to the current str
`abstract T`	`padLeft(int times)` Returns a str instance with `times` of char `' '` (space) left pad to the current str
`abstract T`	`padRight(char c, int times)` Returns a str instance with `times` of char `c` right pad to the current str
`abstract T`	`padRight(int times)` Returns a str instance with `times` of char `' '` (space) right pad to the current str
`T`	`parallel()` Returns this traversable and make sure `C.Feature.PARALLEL` is set
`int`	`pos(CharSequence x)` Alias of `indexOf(CharSequence)`
`int`	`pos(CharSequence x, int fromIndex)` Alias of `indexOf(CharSequence, int)`
`int`	`pos(int ch)` Alias of `indexOf(int)`
`int`	`pos(int ch, int fromIndex)` Alias of `indexOf(int, int)`
`int`	`pos(T x)` Alias of `indexOf(StrBase)`
`int`	`pos(T x, int fromIndex)` Alias of `indexOf(StrBase, int)`
`abstract T`	`prepend(C.List<Character> list)` Return a str instance contains all characters of this str instance prepended with all characters in the list specified
`abstract T`	`prepend(char... chars)` Return a str instance contains all characters of this str instance prepended with all characters in the array specified
`abstract T`	`prepend(Character character)` Returns a str instance contains all characters of this str instance prepended with the character specified
`abstract T`	`prepend(Collection<? extends Character> collection)` Returns a str instance contains all characters of this str instance prepended with all characters in teh collection
`abstract T`	`prepend(String s)` Returns a str instance contains all characters of this str instance prepended with all characters in the `String` specified
`abstract T`	`prepend(T s)` Returns a str instance contains all characters of this str instance prepended with all characters in the str specified
`T`	`readOnly()` Returns a view of this list that is readonly.
`abstract boolean`	`regionMatches(boolean ignoreCase, int toffset, CharSequence other, int ooffset, int len)` Tests if two string regions are equal.
`abstract boolean`	`regionMatches(boolean ignoreCase, int toffset, T other, int ooffset, int len)` Tests if two string regions are equal.
`boolean`	`regionMatches(int toffset, String other, int ooffset, int len)`
`boolean`	`regionMatches(int toffset, T other, int ooffset, int len)`
`Character`	`remove(int index)`
`abstract T`	`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
`abstract T`	`replace(char oldChar, char newChar)` Returns a new str resulting from replacing all occurrences of `oldChar` in this string with `newChar`.
`abstract T`	`replace(CharSequence target, CharSequence replacement)` Replaces each substring of this str that matches the literal target sequence with the specified literal replacement sequence.
`abstract T`	`replaceAll(String regex, String replacement)` Replaces each substr of this str that matches the given regular expression with the given replacement.
`abstract T`	`replaceFirst(String regex, String replacement)` Replaces the first substring of this str that matches the given regular expression with the given replacement.
`abstract T`	`reverse()` Returns a str that contains all characters in this str instance but in a reversed order.
`abstract T`	`rpad(char c, int times)` Alias of `padRight(char, int)`
`abstract T`	`rpad(int times)` Alias of `padRight(int)`
`int`	`rpos(CharSequence str)` alias of `lastIndexOf(CharSequence)`
`int`	`rpos(CharSequence str, int fromIndex)` alias of `lastIndexOf(CharSequence, int)`
`int`	`rpos(int ch)` Alias of `lastIndexOf(int)`
`int`	`rpos(int ch, int fromIndex)` Alias of `lastIndexOf(int, int)`
`int`	`rpos(T x)` alias of `lastIndexOf(StrBase)`
`int`	`rpos(T str, int fromIndex)` alias of `lastIndexOf(StrBase, int)`
`Character`	`set(int index, Character element)`
`protected T`	`setFeature(C.Feature feature)`
`int`	`size()` Return the size of this traversal
`T`	`snapshot()` Returns an immutable list contains all elements of the current list.
`C.List<T>`	`split(String regex)`
`abstract C.List<T>`	`split(String regex, int limit)`
`boolean`	`startsWith(CharSequence prefix)` Check if this str starts with the given char sequence
`abstract 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(T prefix)` Check if this str starts with the given str
`abstract boolean`	`startsWith(T prefix, int toffset)` Check this str instance starts with str, with the search starts at specified offset
`abstract T`	`strip(String prefix, String suffix)`
`abstract T`	`subList(int fromIndex, int toIndex)` Returns a sub str that is a part of this str
`abstract T`	`subSequence(int start, int end)` Return a part of this str specified by start inclusive and end exclusive position.
`T`	`substr(int beginIndex)` Synonym of `substring(int)` but return Str instead of String
`T`	`substr(int beginIndex, int endIndex)`
`abstract 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
`abstract String`	`substring(int beginIndex, int endIndex)` Returns a new string that is a substring of this str.
`T`	`tail()` Returns the rest part of the `Sequence` except the first element
`T`	`tail(int n)` Returns a `Sequence` consisting the last `n` elements from this `Sequence` if number `n` is positive and the `Sequence` contains more than `n` elements
`T`	`take(int n)` Returns a `Sequence` consisting the first `n` elements from this `Sequence` if number `n` is positive and the `Sequence` contains more than `n` elements
`abstract T`	`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.
`abstract T`	`times(int n)` Returns a str instance that repeat this str’s char sequence for `n` times
`char[]`	`toCharArray()` Wrapper of `String.toCharArray()`
`abstract FastStr`	`toFastStr()` Return a `FastStr` that contains all the char sequence in this str instance
`T`	`toLowerCase()`
`abstract T`	`toLowerCase(Locale locale)`
`T`	`toUpperCase()`
`abstract T`	`toUpperCase(Locale locale)`
`abstract T`	`trim()`
`protected T`	`unsetFeature(C.Feature feature)`
`T`	`upper()`
`T`	`upper(Locale locale)`
`abstract T`	`urlEncode()`
`String`	`val()`
`String`	`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, hashCode, 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, isEmpty, remove, removeAll, retainAll, toArray, toArray, toString

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

Methods inherited from interface java.lang.CharSequence
charAt, chars, codePoints, length, toString

Methods inherited from interface java.lang.Comparable
compareTo

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

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

Methods inherited from interface org.osgl.util.C.Traversable
isEmpty

Methods inherited from interface java.lang.Iterable
forEach

- Constructor Detail
  - StrBase
```
protected StrBase()
```
- Method Detail
  - _impl
```
protected abstract Class<T> _impl()
```
    Return the class of the implementation
    
    Returns:
    
    the implementation class
  - _empty
```
protected abstract T _empty()
```
    Check if the str is empty
    
    Returns:
    
    true if the str is empty
  - subList
```
public abstract T subList(int fromIndex,
                          int toIndex)
                   throws StringIndexOutOfBoundsException
```
    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>
    
    Overrides:
    
    subList in class ListBase<Character>
    
    Parameters:
    
    fromIndex - the from (inclusive)
    
    toIndex - the to (exclusive)
    
    Returns:
    
    a sub str start at fromIndex and end at (@code toIndex)
    
    Throws:
    
    StringIndexOutOfBoundsException - if fromIndex is lesser than 0 or greater than or equals to size() of the str
    
    See Also:
    
    subSequence(int, int), substr(int, int)
  - insert
```
public abstract T insert(int index,
                         char character)
                  throws StringIndexOutOfBoundsException
```
    Return a new str with character inserted into the char sequence of this 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 size() of the str
  - insert
```
public abstract T insert(int index,
                         Character character)
                  throws StringIndexOutOfBoundsException
```
    Return a new str with character inserted into the char sequence of this str
    
    Specified by:
    
    insert in interface C.List<Character>
    
    Overrides:
    
    insert in class ListBase<Character>
    
    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 size() of the str
  - insert
```
public abstract T insert(int index,
                         Character... ca)
                  throws StringIndexOutOfBoundsException
```
    Return a new str with character array inserted into the char sequence of this str
    
    Specified by:
    
    insert in interface C.List<Character>
    
    Overrides:
    
    insert in class ListBase<Character>
    
    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 size() of the str
  - insert
```
public abstract T insert(int index,
                         char... ta)
                  throws StringIndexOutOfBoundsException
```
    Return a new str with character array inserted into the char sequence of this str
    
    Parameters:
    
    index - the position to insert the character
    
    ta - 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 size() of the str
  - insert
```
public abstract T insert(int index,
                         StrBase<?> str)
                  throws StringIndexOutOfBoundsException
```
    Returns a new str with a string specified inserted into the char sequence of this 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 size() of the str
  - insert
```
public abstract T insert(int index,
                         String s)
                  throws StringIndexOutOfBoundsException
```
    Returns a new str with a string specified inserted into the char sequence of this 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 size() of the str
  - remove
```
public abstract T 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
    
    Specified by:
    
    remove in interface C.List<Character>
    
    Overrides:
    
    remove in class ListBase<Character>
    
    Parameters:
    
    predicate - the function determine which character in this str will be removed
    
    Returns:
    
    a str with characters identified by predicate removed
  - takeWhile
```
public abstract T 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. 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>
    
    Overrides:
    
    takeWhile in class ListBase<Character>
    
    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 abstract T dropWhile(Lang.Function<? super Character,Boolean> predicate)
```
    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>
    
    Overrides:
    
    dropWhile in class ListBase<Character>
    
    Parameters:
    
    predicate - the function test if character should be dropped in the new str or stop match operation
    
    Returns:
    
    the new str as described
  - reverse
```
public abstract T reverse()
```
    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>
    
    Overrides:
    
    reverse in class ListBase<Character>
    
    Returns:
    
    a reversed str
    
    See Also:
    
    C.Feature.LIMITED, C.Featured.is(org.osgl.util.C.Feature)
  - append
```
public abstract T append(Collection<? extends Character> collection)
```
    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>
    
    Overrides:
    
    append in class ListBase<Character>
    
    Parameters:
    
    collection - the character collection to be appended
    
    Returns:
    
    the new str instance as described
  - append
```
public abstract T append(C.List<Character> list)
```
    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>
    
    Overrides:
    
    append in class ListBase<Character>
    
    Parameters:
    
    list - the list of characters to be appended
    
    Returns:
    
    the new str instance as described
  - append
```
public abstract T append(char... array)
```
    Return a str instance contains all characters of this str instance append with all characters in the array specified
    
    Parameters:
    
    array - the array of characters to be appended
    
    Returns:
    
    the new str instance as described
  - append
```
public abstract T append(Character character)
```
    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>
    
    Overrides:
    
    append in class ListBase<Character>
    
    Parameters:
    
    character - the character to be appended
    
    Returns:
    
    the new str instance as described
  - append
```
public abstract T append(T s)
```
    Returns a str instance contains all characters of this str instance appended with all characters in teh str specified
    
    Parameters:
    
    s - the str in which characters to be appended
    
    Returns:
    
    the new str instance as described
  - append
```
public abstract T append(String s)
```
    Returns a str instance contains all characters of this str instance appended with all characters in the String specified
    
    Parameters:
    
    s - the String in which characters to be appended
    
    Returns:
    
    the new str instance as described
  - prepend
```
public abstract T prepend(Collection<? extends Character> collection)
```
    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>
    
    Overrides:
    
    prepend in class ListBase<Character>
    
    Parameters:
    
    collection - the collection in which characters to be prepended
    
    Returns:
    
    the new str instance as described
  - prepend
```
public abstract T prepend(C.List<Character> list)
```
    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>
    
    Overrides:
    
    prepend in class ListBase<Character>
    
    Parameters:
    
    list - the list of characters to be prepended
    
    Returns:
    
    the new str instance as described
  - prepend
```
public abstract T prepend(char... chars)
```
    Return a str instance contains all characters of this str instance prepended with all characters in the array specified
    
    Parameters:
    
    chars - the array of characters to be prepended
    
    Returns:
    
    the new str instance as described
  - prepend
```
public abstract T prepend(Character character)
```
    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>
    
    Overrides:
    
    prepend in class ListBase<Character>
    
    Parameters:
    
    character - the character to be preppended
    
    Returns:
    
    the new str instance as described
  - prepend
```
public abstract T prepend(T s)
```
    Returns a str instance contains all characters of this str instance prepended with all characters in the str specified
    
    Parameters:
    
    s - the str in which characters to be prepended
    
    Returns:
    
    the new str instance as described
  - prepend
```
public abstract T prepend(String s)
```
    Returns a str instance contains all characters of this str instance prepended with all characters in the String specified
    
    Parameters:
    
    s - the String in which characters to be prepended
    
    Returns:
    
    the new str instance as described
  - subSequence
```
public abstract T subSequence(int start,
                              int end)
```
    Return a part of this str specified by start inclusive and end exclusive position.
    Note calling this method has the same effect with calling subList(int, int) and calling substr(int, int)
    
    Specified by:
    
    subSequence in interface CharSequence
    
    Parameters:
    
    start - the start position
    
    end - the end position
    
    Returns:
    
    the part of this str as described
    
    See Also:
    
    subList(int, int), substr(int, int)
  - times
```
public abstract T times(int n)
```
    Returns a str instance that repeat this str’s char sequence for n times
    
    Parameters:
    
    n - repeat times
    
    Returns:
    
    the new str as described
  - padLeft
```
public abstract T padLeft(char c,
                          int times)
```
    Returns a str instance with times of char c left pad to the current str
    
    Parameters:
    
    c - the char used to pad to this str
    
    times - the repeat times
    
    Returns:
    
    the str instance as described above
  - lpad
```
public abstract T lpad(char c,
                       int times)
```
    Alias of padLeft(char, int)
    
    Parameters:
    
    c - the char used to pad to this str
    
    times - the repeat times
    
    Returns:
    
    the str instance as described above
  - padLeft
```
public abstract T padLeft(int times)
```
    Returns a str instance with times of char ' ' (space) left pad to the current str
    
    Parameters:
    
    times - the repeat times
    
    Returns:
    
    the str instance as described above
  - lpad
```
public abstract T lpad(int times)
```
    Alias of padLeft(int)
    
    Parameters:
    
    times - the repeat times
    
    Returns:
    
    the str instance as described above
  - padRight
```
public abstract T padRight(char c,
                           int times)
```
    Returns a str instance with times of char c right pad to the current str
    
    Parameters:
    
    c - the char used to pad to this str
    
    times - the repeat times
    
    Returns:
    
    the str instance as described above
  - rpad
```
public abstract T rpad(char c,
                       int times)
```
    Alias of padRight(char, int)
    
    Parameters:
    
    c - the char used to pad to this str
    
    times - the repeat times
    
    Returns:
    
    the str instance as described above
  - padRight
```
public abstract T padRight(int times)
```
    Returns a str instance with times of char ' ' (space) right pad to the current str
    
    Parameters:
    
    times - the repeat times
    
    Returns:
    
    the str instance as described above
  - rpad
```
public abstract T rpad(int times)
```
    Alias of padRight(int)
    
    Parameters:
    
    times - the repeat times
    
    Returns:
    
    the str instance as described above
  - getChars
```
public abstract void getChars(int srcBegin,
                              int srcEnd,
                              char[] dst,
                              int dstBegin)
```
    Copy part of the char sequence into another array
    
    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
  - getBytesAscII
```
public abstract byte[] getBytesAscII()
```
    Returns byte array of string composed of only ascii chars
    
    Returns:
    
    ASCII char array of this str
  - getBytesUTF8
```
public abstract byte[] getBytesUTF8()
```
    Returns byte array of string composed of UTF-8 chars
    
    Returns:
    
    UTF-8 char array of this str
  - getBytes
```
public abstract byte[] getBytes()
```
    Encodes this str into a sequence of bytes using the platform’s default charset, storing the result into a new byte array.
    
    Returns:
    
    The resultant byte array
    
    See Also:
    
    String.getBytes()
  - getBytes
```
public abstract byte[] getBytes(Charset charset)
```
    Encodes this str into a sequence of bytes using the given charset, storing the result into a new byte array.
    
    Parameters:
    
    charset - The Charset to be used to encode the String. If charset is null then this function shall return the result of getBytes()
    
    Returns:
    
    The resultant byte array
    
    See Also:
    
    String.getBytes(Charset)
  - getBytes
```
public abstract byte[] getBytes(String charsetName)
```
    Encodes this str into a sequence of bytes using the named charset, storing the result into a new byte array.
    
    Parameters:
    
    charsetName - The name of a supported charset. If charsetName is null then this function shall return the result of getBytes()
    
    Returns:
    
    The resultant byte array
    
    See Also:
    
    String.getBytes(String)
  - toFastStr
```
public abstract FastStr toFastStr()
```
    Return a FastStr that contains all the char sequence in this str instance
    
    Returns:
    
    a FastStr as described
  - contentEquals
```
public abstract boolean contentEquals(CharSequence chars)
```
    Check if this str content is equals to the char sequence specified
    
    Parameters:
    
    chars - the char sequence to be checked agains this str
    
    Returns:
    
    true if content of this str equals to that of the chars
  - contentEquals
```
public abstract boolean contentEquals(T str)
```
    Check if this str content iks equals to the str specified
    
    Parameters:
    
    str - the str instance
    
    Returns:
    
    true if content of this str equals to that of the str
  - isBlank
```
public abstract boolean isBlank()
```
    Check if this str is blank (empty or all space characters)
    
    Returns:
    
    true if this str is blank
  - indexOf
```
public final int indexOf(int ch)
```
    Returns the index within this str of the first occurrence of the specified character.
    
    Parameters:
    
    ch - a character (Unicode code point).
    
    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)
  - indexOf
```
public int indexOf(Object o)
```
    Returns the index within this str of the first occurrence of the specified object. The function will check if the object is an instance of StrBase, String, Character or Integer, and delegate to the indexOf(...) override methods respectively.
    If the object is not of the above types, then -1 returned
    
    Specified by:
    
    indexOf in interface List<Character>
    
    Overrides:
    
    indexOf in class AbstractList<Character>
    
    Parameters:
    
    o - the object
    
    Returns:
    
    the index of the first occurrence of the object in this str
  - indexOf
```
public abstract int indexOf(int ch,
                            int fromIndex)
```
    Returns the index within this str of the first occurrence of the specified character.
    
    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)
  - indexOf
```
public abstract 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.
    
    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 abstract int indexOf(T s,
                            int fromIndex)
```
    Locate another str inside this str, start at the specified index
    
    Parameters:
    
    s - the search string
    
    fromIndex - from where the search should begin
    
    Returns:
    
    the location found or -1 if not found
  - indexOf
```
public int indexOf(List<Character> list)
```
    Returns the index within this str of the first occurrence of the specified character list
    
    Parameters:
    
    list - the list of chars to search for
    
    Returns:
    
    the index of the first occurrence of the specified char list
  - indexOf
```
public int indexOf(List<Character> list,
                   int startIndex)
```
    Returns the index within this str of the first occurrence of the specified character list, starting at the specified index
    
    Parameters:
    
    list - the list of chars to search for
    
    startIndex - the index from which to start the search
    
    Returns:
    
    the index of the first occurrence of the specified char list
  - lastIndexOf
```
public final int lastIndexOf(int ch)
```
    Returns the index within this str of the last occurrence of the specified character.
    
    Parameters:
    
    ch - a character (Unicode code point).
    
    Returns:
    
    the index of the last occurrence of the character in the character sequence represented by this object, or -1 if the character does not occur.
    
    See Also:
    
    String.lastIndexOf(int)
  - lastIndexOf
```
public final int lastIndexOf(CharSequence str)
```
    Returns the index within this str of the last occurrence of the specified substring. The last occurrence of the empty string "" is considered to occur at the index value this.length().
    
    The returned index is the largest value k for which:
    this.startsWith(str, k)
    If no such value of k exists, then -1 is returned.
    Parameters:
    
    str - the substring to search for.
    
    Returns:
    
    the index of the last occurrence of the specified substring, or -1 if there is no such occurrence.
    
    See Also:
    
    String.lastIndexOf(String)
  - lastIndexOf
```
public final int lastIndexOf(T str)
```
    Returns the index within this str of the last occurrence of the specified substr. The last occurrence of the empty str is considered to occur at the index value this.length().
    
    The returned index is the largest value k for which:
    this.startsWith(str, k)
    If no such value of k exists, then -1 is returned.
    Parameters:
    
    str - the substring to search for.
    
    Returns:
    
    the index of the last occurrence of the specified substring, or -1 if there is no such occurrence.
    
    See Also:
    
    lastIndexOf(CharSequence)
  - lastIndexOf
```
public int lastIndexOf(List<Character> list)
```
    Returns the index within this str of the last occurrence of the specified character list
    
    Parameters:
    
    list - the list of chars to search for
    
    Returns:
    
    the index of the last occurrence of the specified char list
  - lastIndexOf
```
public int lastIndexOf(List<Character> list,
                       int startIndex)
```
    Returns the index within this str of the last occurrence of the specified character list, starting at the specified index from tail to head
    
    Parameters:
    
    list - the list of chars to search for
    
    startIndex - the index from which to start the search backwards
    
    Returns:
    
    the index of the last occurrence of the specified char list
  - lastIndexOf
```
public int lastIndexOf(Object o)
```
    Returns the index within this str of the last occurrence of the specified object. The function will check if the object is an instance of StrBase, String, Character or Integer, and delegate to the lastIndexOf(...) override methods respectively.
    If the object is not of the above types, then -1 returned
    
    Specified by:
    
    lastIndexOf in interface List<Character>
    
    Overrides:
    
    lastIndexOf in class AbstractList<Character>
    
    Parameters:
    
    o - the object
    
    Returns:
    
    the index of the last occurrence of the object in this str
  - lastIndexOf
```
public abstract 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.
    
    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)
  - lastIndexOf
```
public abstract 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.
    
    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.
    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 abstract int lastIndexOf(T str,
                                int fromIndex)
```
    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.
    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), lastIndexOf(CharSequence, int)
  - substring
```
public abstract 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
    
    Parameters:
    
    beginIndex - the start index of the sub string
    
    Returns:
    
    the sub string as described
  - equalsIgnoreCase
```
public abstract boolean equalsIgnoreCase(CharSequence x)
```
    Compare content of the str and the specified char sequence, case insensitive
    
    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 abstract int compareTo(CharSequence x)
```
    Compare the char sequence specified against this 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 abstract int compareToIgnoreCase(T x)
```
    Compare the str specified against this str in a case insensitive manner
    
    Parameters:
    
    x - the str to be compared to this str
    
    Returns:
    
    the result of the comparison
    
    See Also:
    
    String.compareToIgnoreCase(String)
  - compareToIgnoreCase
```
public abstract int compareToIgnoreCase(CharSequence x)
```
    Compare the char sequence specified against this str in a case insensitive manner
    
    Parameters:
    
    x - the char sequence to be compared to this str
    
    Returns:
    
    the result of the comparison
    
    See Also:
    
    String.compareToIgnoreCase(String)
  - regionMatches
```
public abstract boolean regionMatches(boolean ignoreCase,
                                      int toffset,
                                      T other,
                                      int ooffset,
                                      int len)
```
    Tests if two string regions are equal.
    
    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 abstract boolean regionMatches(boolean ignoreCase,
                                      int toffset,
                                      CharSequence other,
                                      int ooffset,
                                      int len)
```
    Tests if two string regions are equal.
    
    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 final boolean startsWith(CharSequence prefix)
```
    Check if this str starts with the given char sequence
    
    Parameters:
    
    prefix - the char sequence
    
    Returns:
    
    true if this str starts with the char sequence specified or false otherwise
  - startsWith
```
public final boolean startsWith(T prefix)
```
    Check if this str starts with the given str
    
    Parameters:
    
    prefix - the str argument
    
    Returns:
    
    true if this str starts with the str specified or false otherwise
  - startsWith
```
public abstract boolean startsWith(T prefix,
                                   int toffset)
```
    Check this str instance starts with str, with the search starts at specified offset
    
    Parameters:
    
    prefix - the str arguments
    
    toffset - the offset where the search begins
    
    Returns:
    
    true if the search matches or false otherwise
  - startsWith
```
public abstract boolean startsWith(CharSequence prefix,
                                   int toffset)
```
    Check if this str starts with a char sequence, with the search starts at the specified offset
    
    Parameters:
    
    prefix - the char sequence argument
    
    toffset - the start offset where search begins
    
    Returns:
    
    true if search matches or false otherwise
  - endsWith
```
public final boolean endsWith(CharSequence prefix)
```
    Check if this str ends with the given char sequence
    
    Parameters:
    
    prefix - the char sequence
    
    Returns:
    
    true if this str ends with the char sequence specified or false otherwise
  - endsWith
```
public final boolean endsWith(T prefix)
```
    Check if this str ends with the given str
    
    Parameters:
    
    prefix - the str argument
    
    Returns:
    
    true if this str ends with the str specified or false otherwise
  - endsWith
```
public abstract boolean endsWith(T prefix,
                                 int toffset)
```
    Check this str instance ends with str, with the search starts at specified offset
    
    Parameters:
    
    prefix - the str arguments
    
    toffset - the offset where the search begins (backwards)
    
    Returns:
    
    true if the search matches or false otherwise
  - endsWith
```
public abstract boolean endsWith(CharSequence prefix,
                                 int toffset)
```
    Check if this str ends with a char sequence, with the search starts at the specified offset
    
    Parameters:
    
    prefix - the char sequence argument
    
    toffset - the start offset where search begins backwards
    
    Returns:
    
    true if search matches or false otherwise
  - substring
```
public abstract String substring(int beginIndex,
                                 int endIndex)
```
    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.
    
    Parameters:
    
    beginIndex - the beginning index, inclusive.
    
    endIndex - the ending index, exclusive.
    
    Returns:
    
    the specified substring.
    
    Throws:
    
    IndexOutOfBoundsException - if the beginIndex is negative, or endIndex is larger than the length of this String object, or beginIndex is larger than endIndex.
    
    See Also:
    
    String.substring(int, int)
  - replace
```
public abstract T replace(char oldChar,
                          char newChar)
```
    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.
    
    Parameters:
    
    oldChar - the old character.
    
    newChar - the new character.
    
    Returns:
    
    a str derived from this str by replacing every occurrence of oldChar with newChar.
  - replace
```
public abstract T replace(CharSequence target,
                          CharSequence replacement)
```
    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”.
    
    Parameters:
    
    target - The sequence of char values to be replaced
    
    replacement - The replacement sequence of char values
    
    Returns:
    
    The resulting string
    
    Throws:
    
    NullPointerException - if target or replacement is null.
  - replaceAll
```
public abstract T replaceAll(String regex,
                             String replacement)
```
    Replaces each substr of this str that matches the given regular expression with the given replacement.
    
    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
    
    Throws:
    
    PatternSyntaxException - if the regular expression’s syntax is invalid
    
    See Also:
    
    Pattern, String.replaceAll(String, String)
  - replaceFirst
```
public abstract T replaceFirst(String regex,
                               String replacement)
```
    Replaces the first substring of this str that matches the given regular expression with the given replacement.
    
    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
    
    Throws:
    
    PatternSyntaxException - if the regular expression’s syntax is invalid
    
    See Also:
    
    Pattern, String.replaceFirst(String, String)
  - matches
```
public abstract boolean matches(String regex)
```
    Tells whether or not this str matches the given regular expression.
    
    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
    
    Throws:
    
    PatternSyntaxException - if the regular expression’s syntax is invalid
    
    See Also:
    
    Pattern, String.matches(String)
  - contains
```
public abstract boolean contains(CharSequence s)
```
  - split
```
public abstract C.List<T> split(String regex,
                                int limit)
```
  - toLowerCase
```
public abstract T toLowerCase(Locale locale)
```
  - toUpperCase
```
public abstract T toUpperCase(Locale locale)
```
  - trim
```
public abstract T trim()
```
  - charArray
```
public abstract char[] charArray()
```
  - intern
```
public abstract String intern()
```
  - afterFirst
```
public abstract T afterFirst(String s)
```
  - afterFirst
```
public abstract T afterFirst(T s)
```
  - afterFirst
```
public abstract T afterFirst(char c)
```
  - afterLast
```
public abstract T afterLast(String s)
```
  - afterLast
```
public abstract T afterLast(T characters)
```
  - afterLast
```
public abstract T afterLast(char c)
```
  - beforeFirst
```
public abstract T beforeFirst(String s)
```
  - beforeFirst
```
public abstract T beforeFirst(char c)
```
  - beforeFirst
```
public abstract T beforeFirst(T s)
```
  - beforeLast
```
public abstract T beforeLast(String s)
```
  - beforeLast
```
public abstract T beforeLast(T s)
```
  - beforeLast
```
public abstract T beforeLast(char c)
```
  - strip
```
public abstract T strip(String prefix,
                        String suffix)
```
  - urlEncode
```
public abstract T urlEncode()
```
  - decodeBASE64
```
public abstract T decodeBASE64()
```
  - encodeBASE64
```
public abstract T encodeBASE64()
```
  - capFirst
```
public abstract T capFirst()
```
  - count
```
public abstract int count(String search,
                          boolean overlap)
```
  - count
```
public abstract int count(T search,
                          boolean overlap)
```
  - equals
```
public boolean equals(Object o)
```
    Specified by:
    
    equals in interface Collection<Character>
    
    Specified by:
    
    equals in interface List<Character>
    
    Overrides:
    
    equals in class AbstractList<Character>
  - initFeatures
```
protected EnumSet<C.Feature> initFeatures()
```
    Description copied from class: ListBase
    
    Sub class should override this method to provide initial feature set for the feature based instance
    
    Specified by:
    
    initFeatures in class ListBase<Character>
    
    Returns:
    
    the initial feature set configuration
  - lazy
```
public T lazy()
```
    Description copied from interface: C.List
    
    Returns this traversable and make sure C.Feature.LAZY is set
    
    Specified by:
    
    lazy in interface C.List<Character>
    
    Specified by:
    
    lazy in interface C.ReversibleSequence<Character>
    
    Specified by:
    
    lazy in interface C.Sequence<Character>
    
    Specified by:
    
    lazy in interface C.Traversable<Character>
    
    Overrides:
    
    lazy in class ListBase<Character>
    
    Returns:
    
    this reference with lazy turned on
  - eager
```
public T eager()
```
    Description copied from interface: C.List
    
    Returns this traversable and make sure C.Feature.LAZY is unset
    
    Specified by:
    
    eager in interface C.List<Character>
    
    Specified by:
    
    eager in interface C.ReversibleSequence<Character>
    
    Specified by:
    
    eager in interface C.Sequence<Character>
    
    Specified by:
    
    eager in interface C.Traversable<Character>
    
    Overrides:
    
    eager in class ListBase<Character>
    
    Returns:
    
    this reference with lazy turned off
  - snapshot
```
public T snapshot()
```
    Description copied from interface: C.List
    
    Returns an immutable list contains all elements of the current list. If the current list is immutable, then return the current list itself.
    
    Specified by:
    
    snapshot in interface C.List<Character>
    
    Overrides:
    
    snapshot in class ListBase<Character>
    
    Returns:
    
    an immutable list.
    
    See Also:
    
    C.List.readOnly()
  - readOnly
```
public T readOnly()
```
    Description copied from interface: C.List
    
    Returns a view of this list that is readonly. If the current list is readonly or immutable then return the current list itself
    
    Specified by:
    
    readOnly in interface C.List<Character>
    
    Overrides:
    
    readOnly in class ListBase<Character>
    
    Returns:
    
    a readonly view of this list
  - copy
```
public T copy()
```
    Returns a copy of this str. The char buf is copied
    
    Specified by:
    
    copy in interface C.List<Character>
    
    Overrides:
    
    copy in class ListBase<Character>
    
    Returns:
    
    a mutable list contains all elements of this list
  - copy
```
public final void copy(int srcBegin,
                       int srcEnd,
                       char[] dst,
                       int dstBegin)
```
  - setFeature
```
protected T setFeature(C.Feature feature)
```
    Overrides:
    
    setFeature in class ListBase<Character>
  - parallel
```
public T parallel()
```
    Description copied from interface: C.List
    
    Returns this traversable and make sure C.Feature.PARALLEL is set
    
    Specified by:
    
    parallel in interface C.List<Character>
    
    Specified by:
    
    parallel in interface C.ReversibleSequence<Character>
    
    Specified by:
    
    parallel in interface C.Sequence<Character>
    
    Specified by:
    
    parallel in interface C.Traversable<Character>
    
    Overrides:
    
    parallel in class ListBase<Character>
    
    Returns:
    
    this reference with parallel turned on
  - unsetFeature
```
protected T unsetFeature(C.Feature feature)
```
    Overrides:
    
    unsetFeature in class ListBase<Character>
  - get
```
public final Character get(int index)
```
    Specified by:
    
    get in interface List<Character>
    
    Specified by:
    
    get in class AbstractList<Character>
  - size
```
public final int size()
```
    Description copied from interface: C.Traversable
    
    Return the size of this traversal
    
    Specified by:
    
    size in interface Collection<Character>
    
    Specified by:
    
    size in interface List<Character>
    
    Specified by:
    
    size in interface C.Traversable<Character>
    
    Specified by:
    
    size in class AbstractCollection<Character>
    
    Returns:
    
    the size of the structure
  - set
```
public final Character set(int index,
                           Character element)
```
    Specified by:
    
    set in interface List<Character>
    
    Overrides:
    
    set in class AbstractList<Character>
  - add
```
public final void add(int index,
                      Character element)
```
    Specified by:
    
    add in interface List<Character>
    
    Overrides:
    
    add in class ListBase<Character>
  - remove
```
public final Character remove(int index)
```
    Specified by:
    
    remove in interface List<Character>
    
    Overrides:
    
    remove in class AbstractList<Character>
  - listIterator
```
public ListIterator<Character> listIterator(int index)
```
    Specified by:
    
    listIterator in interface List<Character>
    
    Specified by:
    
    listIterator in class ListBase<Character>
  - take
```
public T take(int n)
```
    Description copied from interface: C.List
    Returns a Sequence consisting the first n elements from this Sequence if number n is positive and the Sequence contains more than n elements
    If this Sequence contains less than n elements, then a Sequence consisting the whole elements of this Sequence is returned. Note it might return this Sequence itself if the Sequence is immutable.
    
    If the number n is zero, then an empty Sequence is returned in reverse order
    
    If the number n is negative, then the last -n elements from this Sequence is returned in an new Sequence, or throw UnsupportedOperationException if this operation is not supported
```
  Sequence seq = C.list(1, 2, 3, 4);  assertEquals(C.list(1, 2), seq.take(2));  assertEquals(C.list(1, 2, 3, 4), seq.take(100));  assertEquals(C.list(), seq.take(0));  assertEquals(C.list(3, 4), seq.take(-2));  assertEquals(C.list(1, 2, 3, 4), seq.take(-200)); 
```
    This method does not alter the underline list
    Specified by:
    
    take in interface C.List<Character>
    
    Specified by:
    
    take in interface C.ReversibleSequence<Character>
    
    Specified by:
    
    take in interface C.Sequence<Character>
    
    Overrides:
    
    take in class ListBase<Character>
    
    Parameters:
    
    n - specify the number of elements to be taken from the head of this Sequence
    
    Returns:
    
    A list contains first n items in this list
    
    See Also:
    
    C.Sequence.head(int)
  - head
```
public T head(int n)
```
    Description copied from interface: C.List
    
    Alias of C.Sequence.take(int)
    
    Specified by:
    
    head in interface C.List<Character>
    
    Specified by:
    
    head in interface C.ReversibleSequence<Character>
    
    Specified by:
    
    head in interface C.Sequence<Character>
    
    Overrides:
    
    head in class ListBase<Character>
    
    Parameters:
    
    n - specify the number of elements to be included in the return list
    
    Returns:
    
    A List contains first n items in this List
  - drop
```
public T drop(int n)
       throws IndexOutOfBoundsException
```
    Description copied from interface: C.List
    Returns a Sequence consisting of the elements from this Sequence except the first n if number n is positive and the Sequence contains more than n elements
    If this Sequence contains less than n elements, then an empty Sequence is returned
    
    If the number n is zero, then a copy of this Sequence or this Sequence itself is returned depending on the implementation
    
    If the number n is negative, then either IllegalArgumentException should be thrown out if this sequence is not C.Feature.LIMITED or it drop -n element starts from the tail side
```
  C.Sequence seq = C.list(1, 2, 3, 4, 5);  assertEquals(C.list(3, 4, 5), seq.drop(2));  assertEquals(C.list(1, 2, 3, 4, 5), seq.drop(0));  assertEquals(C.list(), seq.drop(100)); 
```
    Note this method does NOT modify the current sequence, instead it returns an new sequence structure containing the elements as required
    
    This method does not alter the underline list
    Specified by:
    
    drop in interface C.List<Character>
    
    Specified by:
    
    drop in interface C.ReversibleSequence<Character>
    
    Specified by:
    
    drop in interface C.Sequence<Character>
    
    Overrides:
    
    drop in class ListBase<Character>
    
    Parameters:
    
    n - specify the number of elements to be taken from the head of this Sequence or the -n number of elements to be taken from the tail of this sequence if n is an negative number
    
    Returns:
    
    a List contains all elements of this list except the first n number
    
    Throws:
    
    IndexOutOfBoundsException
  - map
```
public <R> C.List<R> map(Lang.Function<? super Character,? extends R> mapper)
```
    Description copied from interface: C.Sequence
    Returns an new traversable with a mapper function specified. The element in the new traversal is the result of the mapper function applied to this traversal element.
```
  Traversable traversable = C.list(23, .NONE, null);  assertEquals(C.list(true, false, false), traversal.map(.F.NOT_NULL));  assertEquals(C.list(“23”, "“, ”"), traversal.map(_.F.AS_STRING)); 
```
    For Lazy Traversable, it must use lazy evaluation for this method. Otherwise it is up to implementation to decide whether use lazy evaluation or not
    Specified by:
    
    map in interface C.List<Character>
    
    Specified by:
    
    map in interface C.ReversibleSequence<Character>
    
    Specified by:
    
    map in interface C.Sequence<Character>
    
    Specified by:
    
    map in interface C.Traversable<Character>
    
    Overrides:
    
    map in class ListBase<Character>
    
    Type Parameters:
    
    R - the element type of the new traversal
    
    Parameters:
    
    mapper - the function that applied to element in this traversal and returns element in the result traversal
    
    Returns:
    
    a Sequence of R that are mapped from this sequence
  - flatMap
```
public <R> C.List<R> flatMap(Lang.Function<? super Character,? extends Iterable<? extends R>> mapper)
```
    Description copied from interface: C.List
    
    Returns a traversable consisting of the results of replacing each element of this stream with the contents of the iterable produced by applying the provided mapping function to each element. If the result of the mapping function is null, this is treated as if the result is an empty traversable.
    
    Specified by:
    
    flatMap in interface C.List<Character>
    
    Specified by:
    
    flatMap in interface C.ReversibleSequence<Character>
    
    Specified by:
    
    flatMap in interface C.Sequence<Character>
    
    Specified by:
    
    flatMap in interface C.Traversable<Character>
    
    Overrides:
    
    flatMap in class ListBase<Character>
    
    Type Parameters:
    
    R - the element type of the the new traversable
    
    Parameters:
    
    mapper - the function produce an iterable when applied to an element
    
    Returns:
    
    a List of R type element that are mapped from this sequences
  - filter
```
public T filter(Lang.Function<? super Character,Boolean> predicate)
```
    Description copied from interface: C.Sequence
    Returns an new traversable that contains all elements in the current traversable except that does not pass the test of the filter function specified.
```
  Traversable traversable = C.list(-1, 0, 1, -3, 7);  Traversable filtered = traversable.filter(_.F.gt(0));  assertTrue(filtered.contains(1));  assertFalse(filtered.contains(-3)); 
```
    Specified by:
    
    filter in interface C.List<Character>
    
    Specified by:
    
    filter in interface C.ReversibleSequence<Character>
    
    Specified by:
    
    filter in interface C.Sequence<Character>
    
    Specified by:
    
    filter in interface C.Traversable<Character>
    
    Overrides:
    
    filter in class ListBase<Character>
    
    Parameters:
    
    predicate - the function that test if the element in the traversable should be kept in the resulting traversable. When applying the filter function to the element, if the result is true then the element will be kept in the resulting traversable.
    
    Returns:
    
    An new Sequence consists of elements that passed the predicate
  - accept
```
public T accept(Lang.Visitor<? super Character> visitor)
```
    Description copied from interface: C.Traversable
    
    Iterate this Traversable with a visitor function. This method does not specify the approach to iterate through this structure. The implementation might choose iterate from left to right, or vice versa. It might even choose to split the structure into multiple parts, and iterate through them in parallel
    
    Specified by:
    
    accept in interface C.List<Character>
    
    Specified by:
    
    accept in interface C.ReversibleSequence<Character>
    
    Specified by:
    
    accept in interface C.Sequence<Character>
    
    Specified by:
    
    accept in interface C.Traversable<Character>
    
    Overrides:
    
    accept in class ListBase<Character>
    
    Parameters:
    
    visitor - a function that apply to element in this Traversable. The return value of the function is ignored
    
    Returns:
    
    this Traversable instance for chained call
  - acceptLeft
```
public T acceptLeft(Lang.Visitor<? super Character> visitor)
```
    Description copied from interface: C.Sequence
    
    Iterate through this sequence from head to tail with the visitor function specified
    
    Specified by:
    
    acceptLeft in interface C.List<Character>
    
    Specified by:
    
    acceptLeft in interface C.ReversibleSequence<Character>
    
    Specified by:
    
    acceptLeft in interface C.Sequence<Character>
    
    Overrides:
    
    acceptLeft in class ListBase<Character>
    
    Parameters:
    
    visitor - the function to visit elements in this sequence
    
    Returns:
    
    this sequence
    
    See Also:
    
    C.Traversable.accept(Lang.Visitor), C.ReversibleSequence.acceptRight(Lang.Visitor)
  - acceptRight
```
public T acceptRight(Lang.Visitor<? super Character> visitor)
```
    Description copied from interface: C.ReversibleSequence
    
    Iterate through this sequence from tail to head with the visitor function specified
    
    Specified by:
    
    acceptRight in interface C.List<Character>
    
    Specified by:
    
    acceptRight in interface C.ReversibleSequence<Character>
    
    Overrides:
    
    acceptRight in class ListBase<Character>
    
    Parameters:
    
    visitor - the function to visit elements in this sequence
    
    Returns:
    
    this sequence
    
    See Also:
    
    C.Traversable.accept(Lang.Visitor), C.Sequence.acceptLeft(Lang.Visitor)
  - tail
```
public T tail()
```
    Description copied from interface: C.List
    
    Returns the rest part of the Sequence except the first element
    
    Specified by:
    
    tail in interface C.List<Character>
    
    Specified by:
    
    tail in interface C.ReversibleSequence<Character>
    
    Specified by:
    
    tail in interface C.Sequence<Character>
    
    Overrides:
    
    tail in class ListBase<Character>
    
    Returns:
    
    A list contains all elements in this list except the first one
    
    See Also:
    
    C.Sequence.head(), C.ReversibleSequence.tail(int)
  - tail
```
public T tail(int n)
```
    Description copied from interface: C.List
    Returns a Sequence consisting the last n elements from this Sequence if number n is positive and the Sequence contains more than n elements
    If this Sequence contains less than n elements, then a Sequence consisting the whole elements of this Sequence is returned. Note it might return this Sequence itself if the Sequence is immutable.
    
    If the number n is zero, then an empty Sequence is returned in reverse order
    
    If the number n is negative, then the first -n elements from this Sequence is returned in an new Sequence
```
  Sequence seq = C1.list(1, 2, 3, 4);  assertEquals(C1.list(3, 4), seq.tail(2));  assertEquals(C1.list(1, 2, 3, 4), seq.tail(100));  assertEquals(C1.list(), seq.tail(0));  assertEquals(C1.list(1, 2, 3), seq.tail(-3));  assertEquals(C1.list(1, 2, 3, 4), seq.tail(-200)); 
```
    This method does not mutate the underline container
    
    This method does not alter the underline list
    Specified by:
    
    tail in interface C.List<Character>
    
    Specified by:
    
    tail in interface C.ReversibleSequence<Character>
    
    Overrides:
    
    tail in class ListBase<Character>
    
    Parameters:
    
    n - specify the number of elements to be taken from the tail of this Sequence
    
    Returns:
    
    A list contains last n items in this list
    
    See Also:
    
    C.Feature.LIMITED, C.Featured.is(org.osgl.util.C.Feature)
  - value
```
public String value()
```
  - val
```
public String val()
```
  - substr
```
public final T substr(int beginIndex,
                      int endIndex)
```
  - empty
```
public boolean empty()
```
  - notEmpty
```
public boolean notEmpty()
```
  - maxLength
```
public T maxLength(int max)
```
    Return a string no longer than specified max length.
    If the string supplied is longer than the specified max length then only it’s part that is less than the max length returned, appended with “…”
    
    Parameters:
    
    max - the maximum length of the result
    
    Returns:
    
    A StrBase instance that contains at most max number of chars of this instance
  - cutOff
```
public T cutOff(int max)
```
    Return a string no longer than specified max length.
    If the string supplied is longer than the specified max length then only it’s part that is less than the max length returned, appended with “…”
    
    Parameters:
    
    max - the maximum length of the result
    
    Returns:
    
    the string described above
  - contentEquals
```
public final boolean contentEquals(StringBuffer stringBuffer)
```
    Wrapper of String.contentEquals(StringBuffer)
    
    Parameters:
    
    stringBuffer - string buffer
    
    Returns:
    
    true if content equals the content of the specified buffer
  - eq
```
public final boolean eq(CharSequence x)
```
    Alias of contentEquals(CharSequence)
    
    Parameters:
    
    x - an instance of CharSequence type
    
    Returns:
    
    true if chars inside this instance equals to the chars inside x
  - eq
```
public final boolean eq(T x)
```
    Alias of contentEquals(StrBase)
    
    Parameters:
    
    x - another instance
    
    Returns:
    
    true if this instance equals to the x
  - eq
```
public final boolean eq(StringBuffer stringBuffer)
```
    Alias of contentEquals(StringBuffer)
    
    Parameters:
    
    stringBuffer - the string buffer
    
    Returns:
    
    true if content of this instance equals to content of the string buffer
  - pos
```
public final int pos(CharSequence x,
                     int fromIndex)
```
    Alias of indexOf(CharSequence, int)
    
    Parameters:
    
    x - the substr to search for
    
    fromIndex - the index from where the search starts, backwards
    
    Returns:
    
    the index of the occurrence
  - pos
```
public final int pos(CharSequence x)
```
    Alias of indexOf(CharSequence)
    
    Parameters:
    
    x - the substr to search for
    
    Returns:
    
    the index of the occurrence
  - indexOf
```
public final int indexOf(T x)
```
    Locate another str inside this str, start at the specified index
    
    Parameters:
    
    x - the search str
    
    Returns:
    
    the location found or -1 if not found
  - indexOf
```
public final int indexOf(CharSequence str)
```
    Returns the index within this str of the first occurrence of the specified substring, starting at 0.
    
    Parameters:
    
    str - the substring to search for.
    
    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)
  - pos
```
public final int pos(int ch)
```
    Alias of indexOf(int)
    
    Parameters:
    
    ch - the character to be located
    
    Returns:
    
    the position of the character in this str
  - pos
```
public final int pos(T x)
```
    Alias of indexOf(StrBase)
    
    Parameters:
    
    x - the str to be located
    
    Returns:
    
    the position of the str in this str
  - pos
```
public final int pos(int ch,
                     int fromIndex)
```
    Alias of indexOf(int, int)
    
    Parameters:
    
    ch - the char to be located
    
    fromIndex - the index the search begins
    
    Returns:
    
    the position of the char in this str
  - pos
```
public final int pos(T x,
                     int fromIndex)
```
    Alias of indexOf(StrBase, int)
    
    Parameters:
    
    x - a StrBase to search
    
    fromIndex - the index from where the search should begins
    
    Returns:
    
    the found position or -1 if not found
  - rpos
```
public final int rpos(int ch)
```
    Alias of lastIndexOf(int)
    
    Parameters:
    
    ch - the char to be located
    
    Returns:
    
    the last occurrence position the char found in this str
  - rpos
```
public final int rpos(T x)
```
    alias of lastIndexOf(StrBase)
    
    Parameters:
    
    x - the str to be located
    
    Returns:
    
    the last occurrence position the str found in this str
  - rpos
```
public final int rpos(CharSequence str,
                      int fromIndex)
```
    alias of lastIndexOf(CharSequence, int)
    
    Parameters:
    
    str - the string to be located
    
    fromIndex - the index from where the search begins backwards
    
    Returns:
    
    the last occurrence of the string in this str
  - rpos
```
public final int rpos(T str,
                      int fromIndex)
```
    alias of lastIndexOf(StrBase, int)
    
    Parameters:
    
    str - the str to be located
    
    fromIndex - the index from where the search begins backwards
    
    Returns:
    
    the last occurrence of the str in this str
  - rpos
```
public final int rpos(CharSequence str)
```
    alias of lastIndexOf(CharSequence)
    
    Parameters:
    
    str - the string to be located
    
    Returns:
    
    the last occurrence of the string in this str
  - rpos
```
public final int rpos(int ch,
                      int fromIndex)
```
    Alias of lastIndexOf(int, int)
    
    Parameters:
    
    ch - the char to be located
    
    fromIndex - the index from where the search begins backwards
    
    Returns:
    
    the last occurrence of the char in this str
  - contains
```
public final boolean contains(char c)
```
  - regionMatches
```
public final boolean regionMatches(int toffset,
                                   T other,
                                   int ooffset,
                                   int len)
```
  - regionMatches
```
public final boolean regionMatches(int toffset,
                                   String other,
                                   int ooffset,
                                   int len)
```
  - substr
```
public final T substr(int beginIndex)
```
    Synonym of substring(int) but return Str instead of String
    
    Parameters:
    
    beginIndex - the begin index
    
    Returns:
    
    A sub str that starts from the index specified
  - concat
```
public final T concat(String str)
```
  - concat
```
public final T concat(T str)
```
  - split
```
public final C.List<T> split(String regex)
```
  - toLowerCase
```
public final T toLowerCase()
```
  - lower
```
public final T lower()
```
  - lower
```
public final T lower(Locale locale)
```
  - toUpperCase
```
public final T toUpperCase()
```
  - upper
```
public final T upper()
```
  - upper
```
public final T upper(Locale locale)
```
  - before
```
public final T before(String s)
```
  - before
```
public final T before(T s)
```
  - after
```
public final T after(T s)
```
  - after
```
public final T after(String s)
```
  - count
```
public final int count(String s)
```
  - count
```
public final int count(T s)
```
  - countWithOverlap
```
public final int countWithOverlap(String s)
```
  - countWithOverlap
```
public final int countWithOverlap(T s)
```
  - toCharArray
```
public final char[] toCharArray()
```
    Wrapper of String.toCharArray()
    
    Returns:
    
    char array backed this instance

Class StrBase<T extends StrBase<T>>

Nested Class Summary

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.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.lang.Comparable

Methods inherited from interface java.util.List

Methods inherited from interface java.util.Collection

Methods inherited from interface org.osgl.util.C.Traversable

Methods inherited from interface java.lang.Iterable

Constructor Detail

StrBase

Method Detail

_impl

_empty

subList

insert

insert

insert

insert

insert

insert

remove

takeWhile

dropWhile

reverse

append

append

append

append

append

append

prepend

prepend

prepend

prepend

prepend

prepend

subSequence

times

padLeft

lpad

padLeft

lpad

padRight

rpad

padRight

rpad

getChars

getBytesAscII

getBytesUTF8

getBytes

getBytes

getBytes

toFastStr

contentEquals

contentEquals

isBlank

indexOf

indexOf

indexOf

indexOf

indexOf

indexOf

indexOf

lastIndexOf

lastIndexOf

lastIndexOf

lastIndexOf

lastIndexOf

lastIndexOf

lastIndexOf