FastStr (Java Tool 1.2.2 API)

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

All Implemented Interfaces:

Serializable, CharSequence, Comparable<FastStr>, Iterable<Character>, Collection<Character>, List<Character>, RandomAccess, C.Featured, C.List<Character>, C.ReversibleSequence<Character>, C.Sequence<Character>, C.Traversable<Character>
```
public class FastStr
extends StrBase<FastStr>
implements RandomAccess, CharSequence, Serializable, Comparable<FastStr>
```
FastStr implements the same contract of Str with the a char array. This class is marked as Fast because of the following points: 1. When unsafeOf(String) is called, it share the internal value (the char array) of the String been passed in 2. when unsafeOf(char[]) is called, it use the char array passed in directly without copy operation 3. subList and substring works at O(1) because it will NOT copy the internal char array Note, this class shall be used with caution as it might prevent a very large char array from been garbage collected when the char array is passed to a FastStr or substr of the fast string

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 FastStr EMPTY_STR
- Fields inherited from class java.util.AbstractList
  modCount

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

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`protected FastStr`	`_empty()` Check if the str is empty
`protected Class<FastStr>`	`_impl()` Return the class of the implementation
`FastStr`	`afterFirst(char c)`
`FastStr`	`afterFirst(FastStr s)`
`FastStr`	`afterFirst(String s)`
`FastStr`	`afterLast(char c)`
`FastStr`	`afterLast(FastStr s)`
`FastStr`	`afterLast(String s)`
`FastStr`	`append(C.List<Character> list)` Return a str instance contains all characters of this str instance append with all characters in the list specified
`FastStr`	`append(char... array)` Return a str instance contains all characters of this str instance append with all characters in the array specified
`FastStr`	`append(Character character)` Returns a str instance contains all characters of this str instance appended with the character specified
`FastStr`	`append(Collection<? extends Character> collection)` Return a str instance contains all characters of this str append with all characters in the collection specified
`FastStr`	`append(FastStr s)` Returns a str instance contains all characters of this str instance appended with all characters in teh str specified
`FastStr`	`append(String s)` Returns a str instance contains all characters of this str instance appended with all characters in the `String` specified
`FastStr`	`beforeFirst(char c)`
`FastStr`	`beforeFirst(FastStr s)`
`FastStr`	`beforeFirst(String s)`
`FastStr`	`beforeLast(char c)`
`FastStr`	`beforeLast(FastStr s)`
`FastStr`	`beforeLast(String s)`
`static char[]`	`bufOf(CharSequence chars)` Return the char array that backed the char sequence specified
`FastStr`	`canonical()`
`FastStr`	`capFirst()`
`char[]`	`charArray()` Alias of `StrBase.toCharArray()`
`char`	`charAt(int index)`
`int`	`compareTo(CharSequence x)` Compare the char sequence specified against this str
`int`	`compareTo(FastStr o)`
`int`	`compareToIgnoreCase(CharSequence o)` Compare the char sequence specified against this str in a case insensitive manner
`int`	`compareToIgnoreCase(FastStr o)` Compare the str specified against this str in a case insensitive manner
`boolean`	`contains(CharSequence s)` Wrapper of `String.contains(CharSequence)`
`boolean`	`contentEquals(CharSequence x)` Wrapper of `String.contentEquals(CharSequence)`
`boolean`	`contentEquals(FastStr x)` Check if this str content iks equals to the str specified
`FastStr`	`copy()` Returns a copy of this str.
`int`	`count(FastStr search, boolean overlap)`
`int`	`count(String search, boolean overlap)`
`FastStr`	`decodeBASE64()`
`FastStr`	`dropWhile(Osgl.Function<? super Character,Boolean> predicate)` Return a str that without the first N characters in the string.
`FastStr`	`encodeBASE64()`
`boolean`	`endsWith(CharSequence suffix, int toffset)` Check if this str ends with a char sequence, with the search starts at the specified offset
`boolean`	`endsWith(FastStr prefix, int toffset)` Check this str instance ends with str, with the search starts at specified offset
`boolean`	`equals(Object o)`
`boolean`	`equalsIgnoreCase(CharSequence x)` Wrapper of `String.equalsIgnoreCase(String)`
`boolean`	`equalsIgnoreCase(FastStr x)`
`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(FastStr str, int fromIndex)` Locate another str inside this str, start at the specified index
`int`	`indexOf(int ch, int fromIndex)` Returns the index within this str of the first occurrence of the specified character.
`FastStr`	`insert(int index, char... ca)` Return a new str with character array inserted into the char sequence of this str
`FastStr`	`insert(int index, char character)` Return a new str with character inserted into the char sequence of this str
`FastStr`	`insert(int index, Character... ca)` Return a new str with character array inserted into the char sequence of this str
`FastStr`	`insert(int index, Character character)` Return a new str with character inserted into the char sequence of this str
`FastStr`	`insert(int index, StrBase<?> str)` Returns a new str with a string specified inserted into the char sequence of this str
`FastStr`	`insert(int index, String s)` Returns a new str with a string specified inserted into the char sequence of this str
`String`	`intern()` Wrapper of `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(FastStr 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`	`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`	`length()`
`FastStr`	`lpad(char c, int times)` Alias of `StrBase.padLeft(char, int)`
`FastStr`	`lpad(int times)` Alias of `StrBase.padLeft(int)`
`boolean`	`matches(String regex)` Wrapper of `String.matches(String)`
`static FastStr`	`of(byte[] bytes, String encoding)`
`static FastStr`	`of(char[] ca)` Construct a FastStr from a char array
`static FastStr`	`of(CharSequence cs)` Construct a FastStr from a CharSequence
`static FastStr`	`of(Collection<Character> col)` Construct a FastStr instance from a collection of characters
`static FastStr`	`of(Iterable<Character> itr)` Construct a FastStr instance from an iterable of characters
`static FastStr`	`of(Iterator<Character> itr)` Construct a FastStr instance from an iterator of characters
`static FastStr`	`of(String s)` Construct a FastStr from a String
`static FastStr`	`of(StringBuffer sb)` Construct a FastStr from a StringBuffer
`static FastStr`	`of(StringBuilder sb)` Construct a FastStr from a StringBuilder
`FastStr`	`padLeft(char c, int times)` Returns a str instance with `times` of char `c` left pad to the current str
`FastStr`	`padLeft(int times)` Returns a str instance with `times` of char `' '` (space) left pad to the current str
`FastStr`	`padRight(char c, int times)` Returns a str instance with `times` of char `c` right pad to the current str
`FastStr`	`padRight(int times)` Returns a str instance with `times` of char `' '` (space) right pad to the current str
`FastStr`	`parallel()` Returns this traversable and make sure `C.Feature.PARALLEL` is set
`FastStr`	`prepend(C.List<Character> list)` Return a str instance contains all characters of this str instance prepended with all characters in the list specified
`FastStr`	`prepend(char... chars)` Return a str instance contains all characters of this str instance prepended with all characters in the array specified
`FastStr`	`prepend(Character character)` Returns a str instance contains all characters of this str instance prepended with the character specified
`FastStr`	`prepend(Collection<? extends Character> collection)` Returns a str instance contains all characters of this str instance prepended with all characters in teh collection
`FastStr`	`prepend(FastStr s)` Returns a str instance contains all characters of this str instance prepended with all characters in the str specified
`FastStr`	`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, FastStr other, int ooffset, int len)` Tests if two string regions are equal.
`FastStr`	`remove(Osgl.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
`FastStr`	`replace(char oldChar, char newChar)` Wrapper of `String.replace(char, char)` but return FastStr instance
`FastStr`	`replace(CharSequence target, CharSequence replacement)` Wrapper of `String.replace(CharSequence, CharSequence)` but return FastStr type instance
`FastStr`	`replaceAll(String regex, String replacement)` Wrapper of `String.replaceAll(String, String)` but return FastStr type instance
`FastStr`	`replaceFirst(String regex, String replacement)` Wrapper of `String.replaceFirst(String, String)` but return FastStr inance
`FastStr`	`reverse()` Returns a str that contains all characters in this str instance but in a reversed order.
`FastStr`	`rpad(char c, int times)` Alias of `StrBase.padRight(char, int)`
`FastStr`	`rpad(int times)` Alias of `StrBase.padRight(int)`
`C.List<FastStr>`	`split(String regex, int limit)` Wrapper of `String.split(String, int)` but return an immutable List of FastStr instances
`boolean`	`startsWith(CharSequence suffix, int toffset)` Check if this str starts with a char sequence, with the search starts at the specified offset
`boolean`	`startsWith(FastStr prefix, int toffset)` Check this str instance starts with str, with the search starts at specified offset
`FastStr`	`strip(FastStr prefix, FastStr suffix)`
`FastStr`	`strip(String prefix, String suffix)`
`FastStr`	`subList(int fromIndex, int toIndex)` Returns a sub str that is a part of this str
`FastStr`	`subSequence(int start, int end)` Return a part of this str specified by start inclusive and end exclusive position.
`String`	`substring(int beginIndex)` Wrapper of `String.substring(int)`
`String`	`substring(int beginIndex, int endIndex)` Wrapper of `String.substring(int, int)`
`FastStr`	`takeWhile(Osgl.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.
`FastStr`	`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
`FastStr`	`toLowerCase(Locale locale)` Wrapper of `String.toLowerCase(java.util.Locale)` but return FastStr type instance
`String`	`toString()`
`FastStr`	`toUpperCase(Locale locale)` Wrapper of `String.toUpperCase(java.util.Locale)` but return FastStr type instance
`FastStr`	`trim()` Wrapper of `String.trim()` and return FastStr type instance
`char[]`	`unsafeChars()` Return char array buf of this FastStr instance.
`static FastStr`	`unsafeOf(char[] buf)` Construct a FastStr instance from char array without array copying
`static FastStr`	`unsafeOf(char[] buf, int start, int end)` Construct a FastStr instance from char array, from the start position, finished at end position without copying the array.
`static FastStr`	`unsafeOf(String s)` Construct a FastStr instance from a String instance.
`FastStr`	`urlEncode()`

Methods inherited from class org.osgl.util.StrBase
accept, acceptLeft, acceptRight, add, after, after, before, before, concat, concat, contains, contentEquals, copy, count, count, countWithOverlap, countWithOverlap, cutOff, drop, eager, empty, endsWith, endsWith, eq, eq, eq, filter, flatMap, get, head, indexOf, indexOf, indexOf, indexOf, indexOf, indexOf, initFeatures, lastIndexOf, lastIndexOf, lastIndexOf, lastIndexOf, lastIndexOf, lastIndexOf, lazy, listIterator, lower, lower, map, maxLength, notEmpty, 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, 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, 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 FastStr EMPTY_STR
```
- Method Detail
  - _impl
```
protected Class<FastStr> _impl()
```
    Description copied from class: StrBase
    
    Return the class of the implementation
    
    Specified by:
    
    _impl in class StrBase<FastStr>
    
    Returns:
    
    the implementation class
  - _empty
```
protected FastStr _empty()
```
    Description copied from class: StrBase
    
    Check if the str is empty
    
    Specified by:
    
    _empty in class StrBase<FastStr>
    
    Returns:
    
    true if the str is empty
  - length
```
public int length()
```
    Specified by:
    
    length in interface CharSequence
  - 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<FastStr>
    
    Returns:
    
    true if this str is blank
  - subList
```
public FastStr 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<FastStr>
    
    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 FastStr takeWhile(Osgl.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<FastStr>
    
    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 FastStr dropWhile(Osgl.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<FastStr>
    
    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 FastStr remove(Osgl.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<FastStr>
    
    Parameters:
    
    predicate - the function determine which character in this str will be removed
    
    Returns:
    
    a str with characters identified by predicate removed
  - insert
```
public FastStr 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<FastStr>
    
    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 FastStr insert(int index,
                      Character 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 interface C.List<Character>
    
    Specified by:
    
    insert in class StrBase<FastStr>
    
    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 FastStr 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<FastStr>
    
    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 FastStr 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<FastStr>
    
    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 FastStr 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<FastStr>
    
    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 FastStr 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<FastStr>
    
    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 FastStr 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<FastStr>
    
    Returns:
    
    a reversed str
    
    See Also:
    
    C.Feature.LIMITED, C.Featured.is(org.osgl.util.C.Feature)
  - append
```
public FastStr 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<FastStr>
    
    Parameters:
    
    collection - the character collection to be appended
    
    Returns:
    
    the new str instance as described
  - append
```
public FastStr 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<FastStr>
    
    Parameters:
    
    list - the list of characters to be appended
    
    Returns:
    
    the new str instance as described
  - parallel
```
public FastStr 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 StrBase<FastStr>
    
    Returns:
    
    this reference with parallel turned on
  - append
```
public FastStr 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<FastStr>
    
    Parameters:
    
    array - the array of characters to be appended
    
    Returns:
    
    the new str instance as described
  - append
```
public FastStr 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<FastStr>
    
    Parameters:
    
    character - the character to be appended
    
    Returns:
    
    the new str instance as described
  - append
```
public FastStr append(FastStr 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<FastStr>
    
    Parameters:
    
    s - the str in which characters to be appended
    
    Returns:
    
    the new str instance as described
  - append
```
public FastStr 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<FastStr>
    
    Parameters:
    
    s - the String in which characters to be appended
    
    Returns:
    
    the new str instance as described
  - prepend
```
public FastStr 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<FastStr>
    
    Parameters:
    
    collection - the collection in which characters to be prepended
    
    Returns:
    
    the new str instance as described
  - prepend
```
public FastStr 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<FastStr>
    
    Parameters:
    
    list - the list of characters to be prepended
    
    Returns:
    
    the new str instance as described
  - prepend
```
public FastStr 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<FastStr>
    
    Parameters:
    
    chars - the array of characters to be prepended
    
    Returns:
    
    the new str instance as described
  - prepend
```
public FastStr 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<FastStr>
    
    Parameters:
    
    character - the character to be preppended
    
    Returns:
    
    the new str instance as described
  - prepend
```
public FastStr prepend(FastStr 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<FastStr>
    
    Parameters:
    
    s - the str in which characters to be prepended
    
    Returns:
    
    the new str instance as described
  - prepend
```
public FastStr 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<FastStr>
    
    Parameters:
    
    s - the String in which characters to be prepended
    
    Returns:
    
    the new str instance as described
  - padLeft
```
public FastStr 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<FastStr>
    
    Parameters:
    
    c - the char used to pad to this str
    
    times - the repeat times
    
    Returns:
    
    the str instance as described above
  - lpad
```
public FastStr lpad(char c,
                    int times)
```
    Description copied from class: StrBase
    
    Alias of StrBase.padLeft(char, int)
    
    Specified by:
    
    lpad in class StrBase<FastStr>
    
    Parameters:
    
    c - the char used to pad to this str
    
    times - the repeat times
    
    Returns:
    
    the str instance as described above
  - padLeft
```
public FastStr 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<FastStr>
    
    Parameters:
    
    times - the repeat times
    
    Returns:
    
    the str instance as described above
  - lpad
```
public FastStr lpad(int times)
```
    Description copied from class: StrBase
    
    Alias of StrBase.padLeft(int)
    
    Specified by:
    
    lpad in class StrBase<FastStr>
    
    Parameters:
    
    times - the repeat times
    
    Returns:
    
    the str instance as described above
  - padRight
```
public FastStr 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<FastStr>
    
    Parameters:
    
    c - the char used to pad to this str
    
    times - the repeat times
    
    Returns:
    
    the str instance as described above
  - rpad
```
public FastStr rpad(char c,
                    int times)
```
    Description copied from class: StrBase
    
    Alias of StrBase.padRight(char, int)
    
    Specified by:
    
    rpad in class StrBase<FastStr>
    
    Parameters:
    
    c - the char used to pad to this str
    
    times - the repeat times
    
    Returns:
    
    the str instance as described above
  - padRight
```
public FastStr 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<FastStr>
    
    Parameters:
    
    times - the repeat times
    
    Returns:
    
    the str instance as described above
  - rpad
```
public FastStr rpad(int times)
```
    Description copied from class: StrBase
    
    Alias of StrBase.padRight(int)
    
    Specified by:
    
    rpad in class StrBase<FastStr>
    
    Parameters:
    
    times - the repeat times
    
    Returns:
    
    the str instance as described above
  - charAt
```
public char charAt(int index)
```
    Specified by:
    
    charAt in interface CharSequence
  - subSequence
```
public FastStr 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<FastStr>
    
    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)
  - copy
```
public FastStr copy()
```
    Description copied from class: StrBase
    
    Returns a copy of this str. The char buf is copied
    
    Specified by:
    
    copy in interface C.List<Character>
    
    Overrides:
    
    copy in class StrBase<FastStr>
    
    Returns:
    
    a mutable list contains all elements of this list
  - times
```
public FastStr 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<FastStr>
    
    Parameters:
    
    n - repeat times
    
    Returns:
    
    the new str as described
  - canonical
```
public FastStr canonical()
```
  - compareTo
```
public int compareTo(FastStr o)
```
    Specified by:
    
    compareTo in interface Comparable<FastStr>
  - 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<FastStr>
    
    Returns:
    
    a FastStr as described
  - equals
```
public boolean equals(Object o)
```
    Specified by:
    
    equals in interface Collection<Character>
    
    Specified by:
    
    equals in interface List<Character>
    
    Overrides:
    
    equals in class StrBase<FastStr>
  - 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<FastStr>
    
    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<FastStr>
    
    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<FastStr>
    
    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<FastStr>
    
    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<FastStr>
    
    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<FastStr>
    
    Returns:
    
    UTF-8 char array of this str
  - contentEquals
```
public boolean contentEquals(CharSequence x)
```
    Wrapper of String.contentEquals(CharSequence)
    
    Specified by:
    
    contentEquals in class StrBase<FastStr>
    
    Parameters:
    
    x - the char sequence to be compared
    
    Returns:
    
    true if content equals content of the specified char sequence
  - contentEquals
```
public boolean contentEquals(FastStr x)
```
    Description copied from class: StrBase
    
    Check if this str content iks equals to the str specified
    
    Specified by:
    
    contentEquals in class StrBase<FastStr>
    
    Parameters:
    
    x - the str instance
    
    Returns:
    
    true if content of this str equals to that of the str
  - equalsIgnoreCase
```
public boolean equalsIgnoreCase(CharSequence x)
```
    Wrapper of String.equalsIgnoreCase(String)
    
    Specified by:
    
    equalsIgnoreCase in class StrBase<FastStr>
    
    Parameters:
    
    x - the char sequence to be compared
    
    Returns:
    
    true if the argument is not null and it represents an equivalent String ignoring case; false otherwise
  - equalsIgnoreCase
```
public boolean equalsIgnoreCase(FastStr x)
```
  - 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<FastStr>
    
    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(FastStr o)
```
    Description copied from class: StrBase
    
    Compare the str specified against this str in a case insensitive manner
    
    Specified by:
    
    compareToIgnoreCase in class StrBase<FastStr>
    
    Parameters:
    
    o - the str to be compared to this str
    
    Returns:
    
    the result of the comparison
    
    See Also:
    
    String.compareToIgnoreCase(String)
  - compareToIgnoreCase
```
public int compareToIgnoreCase(CharSequence o)
```
    Description copied from class: StrBase
    
    Compare the char sequence specified against this str in a case insensitive manner
    
    Specified by:
    
    compareToIgnoreCase in class StrBase<FastStr>
    
    Parameters:
    
    o - 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,
                             FastStr other,
                             int ooffset,
                             int len)
```
    Description copied from class: StrBase
    
    Tests if two string regions are equal.
    
    Specified by:
    
    regionMatches in class StrBase<FastStr>
    
    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<FastStr>
    
    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(FastStr 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<FastStr>
    
    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 suffix,
                          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<FastStr>
    
    Parameters:
    
    suffix - 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 toffset)
```
    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<FastStr>
    
    Parameters:
    
    suffix - the char sequence argument
    
    toffset - the start offset where search begins backwards
    
    Returns:
    
    true if search matches or false otherwise
  - endsWith
```
public boolean endsWith(FastStr prefix,
                        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<FastStr>
    
    Parameters:
    
    prefix - 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<FastStr>
    
    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<FastStr>
    
    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<FastStr>
    
    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(FastStr 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<FastStr>
    
    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<FastStr>
    
    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(FastStr 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<FastStr>
    
    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)
```
    Wrapper of String.substring(int)
    
    Specified by:
    
    substring in class StrBase<FastStr>
    
    Parameters:
    
    beginIndex - the begin index
    
    Returns:
    
    a String instance that is equivalent to a sub part of this FastStr
  - substring
```
public String substring(int beginIndex,
                        int endIndex)
```
    Wrapper of String.substring(int, int)
    
    Specified by:
    
    substring in class StrBase<FastStr>
    
    Parameters:
    
    beginIndex - begin index
    
    endIndex - end index
    
    Returns:
    
    a String instance that is equivalent to sub part of this FastStr
    
    See Also:
    
    String.substring(int, int)
  - replace
```
public FastStr replace(char oldChar,
                       char newChar)
```
    Wrapper of String.replace(char, char) but return FastStr instance
    
    Specified by:
    
    replace in class StrBase<FastStr>
    
    Parameters:
    
    oldChar - char to be replaced
    
    newChar - char used to replace oldChar
    
    Returns:
    
    a FastStr instance with all oldChar been replaced with newChar
  - matches
```
public boolean matches(String regex)
```
    Wrapper of String.matches(String)
    
    Specified by:
    
    matches in class StrBase<FastStr>
    
    Parameters:
    
    regex - the regular expression to checked against this FastStr
    
    Returns:
    
    true if this FastStr matches regex
    
    See Also:
    
    Pattern, String.matches(String)
  - contains
```
public boolean contains(CharSequence s)
```
    Wrapper of String.contains(CharSequence)
    
    Specified by:
    
    contains in class StrBase<FastStr>
    
    Parameters:
    
    s - the char sequence to be found
    
    Returns:
    
    true if s has been found
  - replaceFirst
```
public FastStr replaceFirst(String regex,
                            String replacement)
```
    Wrapper of String.replaceFirst(String, String) but return FastStr inance
    
    Specified by:
    
    replaceFirst in class StrBase<FastStr>
    
    Parameters:
    
    regex - the regular expression specifies the place to be replaced
    
    replacement - the string to replace the found part
    
    Returns:
    
    a FastStr that has the first found part replaced
    
    See Also:
    
    Pattern, String.replaceFirst(String, String)
  - replaceAll
```
public FastStr replaceAll(String regex,
                          String replacement)
```
    Wrapper of String.replaceAll(String, String) but return FastStr type instance
    
    Specified by:
    
    replaceAll in class StrBase<FastStr>
    
    Parameters:
    
    regex - the regular expression specifies the pattern to be replaced
    
    replacement - the replacement string
    
    Returns:
    
    a FastStr instance with all found part replaced
    
    See Also:
    
    Pattern, String.replaceAll(String, String)
  - replace
```
public FastStr replace(CharSequence target,
                       CharSequence replacement)
```
    Wrapper of String.replace(CharSequence, CharSequence) but return FastStr type instance
    
    Specified by:
    
    replace in class StrBase<FastStr>
    
    Parameters:
    
    target - the char sequence to be replaced
    
    replacement - the char sequence used to replace target
    
    Returns:
    
    a FastStr instance with all target being replaced with replacement
  - split
```
public C.List<FastStr> split(String regex,
                             int limit)
```
    Wrapper of String.split(String, int) but return an immutable List of FastStr instances
    
    Specified by:
    
    split in class StrBase<FastStr>
    
    Parameters:
    
    regex - the regular expression matches the seperator
    
    limit - the result threshold
    
    Returns:
    
    a C.List of FastStr instances split from this FastStr
  - toLowerCase
```
public FastStr toLowerCase(Locale locale)
```
    Wrapper of String.toLowerCase(java.util.Locale) but return FastStr type instance
    
    Specified by:
    
    toLowerCase in class StrBase<FastStr>
    
    Parameters:
    
    locale - the locale
    
    Returns:
    
    a FastStr instance with all characters from this FastStr be converted into lowercase based on the locale specified
  - toUpperCase
```
public FastStr toUpperCase(Locale locale)
```
    Wrapper of String.toUpperCase(java.util.Locale) but return FastStr type instance
    
    Specified by:
    
    toUpperCase in class StrBase<FastStr>
    
    Parameters:
    
    locale - the locale
    
    Returns:
    
    a FastStr instance with all characters from this FastStr be converted into uppercase based on the locale specified
  - trim
```
public FastStr trim()
```
    Wrapper of String.trim() and return FastStr type instance
    
    Specified by:
    
    trim in class StrBase<FastStr>
    
    Returns:
    
    a FastStr instance without leading and tail space characters from this FastStr instance
  - charArray
```
public char[] charArray()
```
    Alias of StrBase.toCharArray()
    
    Specified by:
    
    charArray in class StrBase<FastStr>
    
    Returns:
    
    char array buf copy of this FastStr
  - unsafeChars
```
public char[] unsafeChars()
```
    Return char array buf of this FastStr instance. Note this method might return the char array buf directly without copy operation
    
    Returns:
    
    the char array buf of this FastStr
  - intern
```
public String intern()
```
    Wrapper of String.intern()
    
    Specified by:
    
    intern in class StrBase<FastStr>
    
    Returns:
    
    the intern of the string
  - afterFirst
```
public FastStr afterFirst(String s)
```
    Specified by:
    
    afterFirst in class StrBase<FastStr>
  - afterLast
```
public FastStr afterLast(String s)
```
    Specified by:
    
    afterLast in class StrBase<FastStr>
  - afterFirst
```
public FastStr afterFirst(FastStr s)
```
    Specified by:
    
    afterFirst in class StrBase<FastStr>
  - afterLast
```
public FastStr afterLast(FastStr s)
```
    Specified by:
    
    afterLast in class StrBase<FastStr>
  - afterFirst
```
public FastStr afterFirst(char c)
```
    Specified by:
    
    afterFirst in class StrBase<FastStr>
  - afterLast
```
public FastStr afterLast(char c)
```
    Specified by:
    
    afterLast in class StrBase<FastStr>
  - beforeFirst
```
public FastStr beforeFirst(String s)
```
    Specified by:
    
    beforeFirst in class StrBase<FastStr>
  - beforeLast
```
public FastStr beforeLast(String s)
```
    Specified by:
    
    beforeLast in class StrBase<FastStr>
  - beforeFirst
```
public FastStr beforeFirst(FastStr s)
```
    Specified by:
    
    beforeFirst in class StrBase<FastStr>
  - beforeLast
```
public FastStr beforeLast(FastStr s)
```
    Specified by:
    
    beforeLast in class StrBase<FastStr>
  - beforeFirst
```
public FastStr beforeFirst(char c)
```
    Specified by:
    
    beforeFirst in class StrBase<FastStr>
  - beforeLast
```
public FastStr beforeLast(char c)
```
    Specified by:
    
    beforeLast in class StrBase<FastStr>
  - strip
```
public FastStr strip(String prefix,
                     String suffix)
```
    Specified by:
    
    strip in class StrBase<FastStr>
  - strip
```
public FastStr strip(FastStr prefix,
                     FastStr suffix)
```
  - urlEncode
```
public FastStr urlEncode()
```
    Specified by:
    
    urlEncode in class StrBase<FastStr>
  - decodeBASE64
```
public FastStr decodeBASE64()
```
    Specified by:
    
    decodeBASE64 in class StrBase<FastStr>
  - encodeBASE64
```
public FastStr encodeBASE64()
```
    Specified by:
    
    encodeBASE64 in class StrBase<FastStr>
  - capFirst
```
public FastStr capFirst()
```
    Specified by:
    
    capFirst in class StrBase<FastStr>
  - count
```
public int count(String search,
                 boolean overlap)
```
    Specified by:
    
    count in class StrBase<FastStr>
  - count
```
public int count(FastStr search,
                 boolean overlap)
```
    Specified by:
    
    count in class StrBase<FastStr>
  - of
```
public static FastStr of(char[] ca)
```
    Construct a FastStr from a char array
    
    Parameters:
    
    ca - the char array
    
    Returns:
    
    a FastStr
  - of
```
public static FastStr of(CharSequence cs)
```
    Construct a FastStr from a CharSequence
    
    Parameters:
    
    cs - the CharSequence instance
    
    Returns:
    
    a FastStr
  - of
```
public static FastStr of(String s)
```
    Construct a FastStr from a String
    
    Parameters:
    
    s - the String
    
    Returns:
    
    a FastStr
  - of
```
public static FastStr of(StringBuilder sb)
```
    Construct a FastStr from a StringBuilder
    
    Parameters:
    
    sb - the string builder
    
    Returns:
    
    a FastStr
  - of
```
public static FastStr of(StringBuffer sb)
```
    Construct a FastStr from a StringBuffer
    
    Parameters:
    
    sb - the string buffer
    
    Returns:
    
    the FastStr
  - of
```
public static FastStr of(Iterable<Character> itr)
```
    Construct a FastStr instance from an iterable of characters
    
    Parameters:
    
    itr - the character iterable
    
    Returns:
    
    the FastStr
  - of
```
public static FastStr of(Collection<Character> col)
```
    Construct a FastStr instance from a collection of characters
    
    Parameters:
    
    col - the character collection
    
    Returns:
    
    a FastStr instance
  - of
```
public static FastStr of(Iterator<Character> itr)
```
    Construct a FastStr instance from an iterator of characters
    
    Parameters:
    
    itr - the character iterator
    
    Returns:
    
    a FastStr instance consists of all chars in the iterator
  - of
```
public static FastStr of(byte[] bytes,
                         String encoding)
```
  - unsafeOf
```
public static FastStr unsafeOf(String s)
```
    Construct a FastStr instance from a String instance. The FastStr instance will share the char array buf with the String instance
    
    Parameters:
    
    s - the string instance
    
    Returns:
    
    A FastStr instance
  - unsafeOf
```
public static FastStr unsafeOf(char[] buf)
```
    Construct a FastStr instance from char array without array copying
    
    Parameters:
    
    buf - the char array
    
    Returns:
    
    a FastStr instance from the char array
  - unsafeOf
```
public static FastStr unsafeOf(char[] buf,
                               int start,
                               int end)
```
    Construct a FastStr instance from char array, from the start position, finished at end position without copying the array. This method might use the array directly instead of copying elements from the array. Thus it is extremely important that the array buf passed in will NOT be updated outside the FastStr instance.
    
    Parameters:
    
    buf - the char array
    
    start - the start position (inclusive)
    
    end - the end position (exclusive)
    
    Returns:
    
    a FastStr instance that consist of chars specified
  - bufOf
```
public static char[] bufOf(CharSequence chars)
```
    Return the char array that backed the char sequence specified
    
    Parameters:
    
    chars - the char sequence
    
    Returns:
    
    an array of chars of the char sequence

Class FastStr

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

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

Method Detail

_impl

_empty

length

isEmpty

isBlank

subList

takeWhile

dropWhile

remove

insert

insert

insert

insert

insert

insert

reverse

append

append

parallel

append

append

append

append

prepend

prepend

prepend

prepend

prepend

prepend

padLeft

lpad

padLeft

lpad

padRight

rpad

padRight

rpad

charAt

subSequence

copy

times

canonical

compareTo

toString

toFastStr

equals

hashCode

getChars

getBytes

getBytes

getBytes

getBytesAscII

getBytesUTF8

contentEquals

contentEquals

equalsIgnoreCase

equalsIgnoreCase

compareTo

compareToIgnoreCase

compareToIgnoreCase