AsciiString (Netty API Reference (4.1.22.Final))

java.lang.Object
- io.netty.util.AsciiString

All Implemented Interfaces:

java.lang.CharSequence，java.lang.Comparable <java.lang.CharSequence>
```
public final class AsciiString
extends java.lang.Object
implements java.lang.CharSequence, java.lang.Comparable<java.lang.CharSequence>
```
一个已编码为字符编码的字符串，其字符总是需要一个字节，与ASCII相似。它在内部将其内容保存在一个字节数组中，与使用字符数组的String不同，它可以减少内存占用并实现更快的数据从/到字节数组和ByteBuffer等基于字节的数据结构的ByteBuffer 。它经常被用来结合Headers需要一个CharSequence 。
此类旨在提供不可变的字节数组，并根据此数组的值缓存一些内部状态。但是，通过不复制构造上的数组或array()提供对该字节数组的底层访问。如果对底层字节数组进行任何更改，则用户有责任调用arrayChanged()，以便可以重置此类的状态。

Field Summary

Fields
Modifier and Type	Field and Description
`static HashingStrategy<java.lang.CharSequence>`	`CASE_INSENSITIVE_HASHER`
`static HashingStrategy<java.lang.CharSequence>`	`CASE_SENSITIVE_HASHER`
`static AsciiString`	`EMPTY_STRING`
`static int`	`INDEX_NOT_FOUND`

构造方法摘要

构造方法
Constructor and Description
`AsciiString(byte[] value)` 基于字节数组初始化该字节字符串。
`AsciiString(byte[] value, boolean copy)` 基于字节数组初始化该字节字符串。
`AsciiString(byte[] value, int start, int length, boolean copy)` 从 `byte[]`阵列构建新的实例。
`AsciiString(java.nio.ByteBuffer value)` 从 `value`创建底层存储的 `value` 。
`AsciiString(java.nio.ByteBuffer value, boolean copy)` 基于来自 `value`的基础存储初始化实例。
`AsciiString(java.nio.ByteBuffer value, int start, int length, boolean copy)` 根据value的基础存储初始化`value` 。
`AsciiString(char[] value)` 假设使用ASCII编码，将 `value`的副本创建到此实例中。
`AsciiString(char[] value, java.nio.charset.Charset charset)` 使用编码类型 `charset`将 `value`的副本创建到此实例中。
`AsciiString(char[] value, java.nio.charset.Charset charset, int start, int length)` 使用编码类型 `charset`将 `value`的副本创建到此实例中。
`AsciiString(char[] value, int start, int length)` 假设使用ASCII编码，将 `value`的副本创建到此实例中。
`AsciiString(java.lang.CharSequence value)` 假设使用ASCII编码，将 `value`的副本创建到此实例中。
`AsciiString(java.lang.CharSequence value, java.nio.charset.Charset charset)` 使用编码类型 `charset`将 `value`的副本创建到此实例中。
`AsciiString(java.lang.CharSequence value, java.nio.charset.Charset charset, int start, int length)` 使用编码类型 `charset`将 `value`的副本创建到此实例中。
`AsciiString(java.lang.CharSequence value, int start, int length)` 使用ASCII编码将 `value`的副本创建到此实例中。

方法摘要

所有方法静态方法接口方法具体的方法
Modifier and Type	Method and Description
`byte[]`	`array()` 这可以直接访问底层存储阵列。
`void`	`arrayChanged()` 在正常使用情况下， `AsciiString`应该是不可变的，但是如果底层数组是共享的，那么需要调用它。
`int`	`arrayOffset()` 此ByteString的数据开始的 `array()`的偏移量。
`static char`	`b2c(byte b)`
`byte`	`byteAt(int index)`
`static byte`	`c2b(char c)`
`static AsciiString`	`cached(java.lang.String string)` 返回包含给定字符串的`AsciiString` ，并保留/缓存输入字符串以供稍后在`toString()`中使用。
`char`	`charAt(int index)`
`int`	`compareTo(java.lang.CharSequence string)` 使用字符的ASCII值将指定的字符串与此字符串进行比较。
`AsciiString`	`concat(java.lang.CharSequence string)` 连接此字符串和指定的字符串。
`boolean`	`contains(java.lang.CharSequence cs)` 确定 `String`包含通过的 `CharSequence`的字符序列。
`static boolean`	`contains(java.lang.CharSequence a, java.lang.CharSequence b)` 以区分大小写的方式确定 `a`包含 `b` 。
`static boolean`	`containsAllContentEqualsIgnoreCase(java.util.Collection<java.lang.CharSequence> a, java.util.Collection<java.lang.CharSequence> b)` 确定是否 `a`包含的所有值 `b`使用 `contentEqualsIgnoreCase(CharSequence, CharSequence)`来比较值。
`static boolean`	`containsContentEqualsIgnoreCase(java.util.Collection<java.lang.CharSequence> collection, java.lang.CharSequence value)` 确定 `collection`包含 `value`并使用 `contentEqualsIgnoreCase(CharSequence, CharSequence)`来比较值。
`static boolean`	`containsIgnoreCase(java.lang.CharSequence a, java.lang.CharSequence b)` 以不区分大小写的方式确定 `a`包含 `b` 。
`boolean`	`contentEquals(java.lang.CharSequence a)` 将 `CharSequence`与 `String`进行比较，以确定它们的内容是否相等。
`static boolean`	`contentEquals(java.lang.CharSequence a, java.lang.CharSequence b)` 如果两个 `CharSequence`的内容 `true`则返回 `true` 。
`boolean`	`contentEqualsIgnoreCase(java.lang.CharSequence string)` 将指定的字符串与此字符串进行比较，忽略字符的大小写，如果相等，则返回true。
`static boolean`	`contentEqualsIgnoreCase(java.lang.CharSequence a, java.lang.CharSequence b)` 如果两个 `CharSequence`在忽略大小写时相等，则返回 `true` 。
`void`	`copy(int srcIdx, byte[] dst, int dstIdx, int length)` 将此字符串的内容复制到字节数组。
`void`	`copy(int srcIdx, char[] dst, int dstIdx, int length)` 将此字符串的内容复制到字符数组中。
`boolean`	`endsWith(java.lang.CharSequence suffix)` 将指定的字符串与此字符串进行比较，以确定指定的字符串是否为后缀。
`boolean`	`equals(java.lang.Object obj)`
`int`	`forEachByte(ByteProcessor visitor)` 用指定的 `processor`按升序对此缓冲区的可读字节进行迭代。
`int`	`forEachByte(int index, int length, ByteProcessor visitor)` 以指定的 `processor`按升序迭代该缓冲区的指定区域。
`int`	`forEachByteDesc(ByteProcessor visitor)` 使用指定的 `processor`按降序对此缓冲区的可读字节进行迭代。
`int`	`forEachByteDesc(int index, int length, ByteProcessor visitor)` 用指定的 `processor`按降序遍历此缓冲区的指定区域。
`int`	`hashCode()` 为Ascii提供像字节字符串一样的不区分大小写的哈希码。
`static int`	`hashCode(java.lang.CharSequence value)` 返回指定字符串的不区分大小写的哈希码。
`int`	`indexOf(char ch, int start)` 在此字符串中搜索指定的字符 `ch`的索引。
`int`	`indexOf(java.lang.CharSequence string)` 在此字符串中搜索指定字符串的第一个索引。
`static int`	`indexOf(java.lang.CharSequence cs, char searchChar, int start)` 查找 `CharSequence`中与指定字符匹配的第一个索引。
`int`	`indexOf(java.lang.CharSequence subString, int start)` 在此字符串中搜索指定字符串的索引。
`static int`	`indexOfIgnoreCase(java.lang.CharSequence str, java.lang.CharSequence searchStr, int startPos)` 大小写敏感地查找指定位置的CharSequence内的第一个索引。
`static int`	`indexOfIgnoreCaseAscii(java.lang.CharSequence str, java.lang.CharSequence searchStr, int startPos)` 大小写敏感地查找指定位置的CharSequence内的第一个索引。
`boolean`	`isEmpty()` 确定此实例是否具有0长度。
`boolean`	`isEntireArrayUsed()` 确定 `array()`表示的存储是否完全使用。
`static boolean`	`isUpperCase(byte value)`
`static boolean`	`isUpperCase(char value)`
`int`	`lastIndexOf(java.lang.CharSequence string)` 在此字符串中搜索指定字符串的最后一个索引。
`int`	`lastIndexOf(java.lang.CharSequence subString, int start)` 在此字符串中搜索指定字符串的索引。
`int`	`length()` 此实例的字节长度。
`boolean`	`matches(java.lang.String expr)` 确定此字符串是否与给定的正则表达式匹配。
`static AsciiString`	`of(java.lang.CharSequence string)` 返回包含给定字符序列的`AsciiString` 。
`boolean`	`parseBoolean()`
`char`	`parseChar()`
`char`	`parseChar(int start)`
`double`	`parseDouble()`
`double`	`parseDouble(int start, int end)`
`float`	`parseFloat()`
`float`	`parseFloat(int start, int end)`
`int`	`parseInt()`
`int`	`parseInt(int radix)`
`int`	`parseInt(int start, int end)`
`int`	`parseInt(int start, int end, int radix)`
`long`	`parseLong()`
`long`	`parseLong(int radix)`
`long`	`parseLong(int start, int end)`
`long`	`parseLong(int start, int end, int radix)`
`short`	`parseShort()`
`short`	`parseShort(int radix)`
`short`	`parseShort(int start, int end)`
`short`	`parseShort(int start, int end, int radix)`
`boolean`	`regionMatches(boolean ignoreCase, int thisStart, java.lang.CharSequence string, int start, int length)` 将指定的字符串与此字符串进行比较，并比较指定的字符范围以确定它们是否相同。
`static boolean`	`regionMatches(java.lang.CharSequence cs, boolean ignoreCase, int csStart, java.lang.CharSequence string, int start, int length)` 此方法可以正确地为字符串中的任何字符进行regionMatches操作
`boolean`	`regionMatches(int thisStart, java.lang.CharSequence string, int start, int length)` 将指定的字符串与此字符串进行比较，并比较指定的字符范围以确定它们是否相同。
`static boolean`	`regionMatchesAscii(java.lang.CharSequence cs, boolean ignoreCase, int csStart, java.lang.CharSequence string, int start, int length)` 这是仅针对带有ASCII字符的字符串的regionMatches的优化版本
`AsciiString`	`replace(char oldChar, char newChar)` 复制此字符串，用其他字符替换指定字符的出现位置。
`AsciiString[]`	`split(char delim)` 用指定的分隔符分割指定的 `String` ..
`AsciiString[]`	`split(java.lang.String expr, int max)` 使用提供的正则表达式 `expr`分割此字符串。
`boolean`	`startsWith(java.lang.CharSequence prefix)` 将指定的字符串与此字符串进行比较，以确定指定的字符串是否为前缀。
`boolean`	`startsWith(java.lang.CharSequence prefix, int start)` 将指定的字符串与此字符串进行比较，从指定的偏移量开始，以确定指定的字符串是否为前缀。
`AsciiString`	`subSequence(int start)` 将一系列字符复制到新字符串中。
`AsciiString`	`subSequence(int start, int end)` 将一系列字符复制到新字符串中。
`AsciiString`	`subSequence(int start, int end, boolean copy)` 复制或共享底层字节子序列的子集。
`byte[]`	`toByteArray()` 将此字符串转换为字节数组。
`byte[]`	`toByteArray(int start, int end)` 将此字符串的子集转换为字节数组。
`char[]`	`toCharArray()` 将此字符串中的字符复制到字符数组。
`char[]`	`toCharArray(int start, int end)` 将此字符串中的字符复制到字符数组。
`AsciiString`	`toLowerCase()` 使用默认的Locale将此字符串中的字符转换为小写字母。
`java.lang.String`	`toString()` 将整个字节字符串转换为 `String` 。
`java.lang.String`	`toString(int start)` 使用 `charset`编码将整个字节字符串转换为 `String` 。
`java.lang.String`	`toString(int start, int end)` 平移[ `start` ， `end` ）范围该字节字符串到的 `String` 。
`AsciiString`	`toUpperCase()` 使用默认的Locale将此字符串中的字符转换为大写。
`AsciiString`	`trim()` 复制此字符串，从字符串的开头和结尾删除空格字符，而不进行复制。
`static java.lang.CharSequence`	`trim(java.lang.CharSequence c)` 复制此字符串，从字符串的开头和结尾删除空格字符，并尽可能不复制。

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

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

- 字段详细信息
  - EMPTY_STRING
```
public static final AsciiString EMPTY_STRING
```
  - INDEX_NOT_FOUND
```
public static final int INDEX_NOT_FOUND
```
    另请参见：
    
    Constant Field Values
  - CASE_INSENSITIVE_HASHER
```
public static final HashingStrategy<java.lang.CharSequence> CASE_INSENSITIVE_HASHER
```
  - CASE_SENSITIVE_HASHER
```
public static final HashingStrategy<java.lang.CharSequence> CASE_SENSITIVE_HASHER
```
- 构造方法详细信息
  - AsciiString
```
public AsciiString(byte[] value)
```
    基于字节数组初始化该字节字符串。副本将被制作。
  - AsciiString
```
public AsciiString(byte[] value,
                   boolean copy)
```
    基于字节数组初始化该字节字符串。 copy决定是否创建副本或共享阵列。
  - AsciiString
```
public AsciiString(byte[] value,
                   int start,
                   int length,
                   boolean copy)
```
    从 byte[]阵列构建一个新实例。
    
    参数
    
    copy - true然后将true一个内存的副本。 false底层内存将被共享。
  - AsciiString
```
public AsciiString(java.nio.ByteBuffer value)
```
    从value创建底层存储的value 。该副本将从Buffer.position()开始并复制Buffer.remaining()字节。
  - AsciiString
```
public AsciiString(java.nio.ByteBuffer value,
                   boolean copy)
```
    根据value的基础存储初始化实例。如果ByteBuffer.hasArray()是true则可能共享底层阵列存储。如果copy是true复制内存。如果copy是false则底层存储将尽可能共享。
  - AsciiString
```
public AsciiString(java.nio.ByteBuffer value,
                   int start,
                   int length,
                   boolean copy)
```
    初始化一个AsciiString基于从底层存储value 。如果ByteBuffer.hasArray()是true则可能共享底层阵列存储。如果copy是true复制内存。如果copy是false则底层存储将尽可能共享。
  - AsciiString
```
public AsciiString(char[] value)
```
    假设使用ASCII编码，将 value的副本创建到此实例中。
  - AsciiString
```
public AsciiString(char[] value,
                   int start,
                   int length)
```
    假设使用ASCII编码，将value的副本创建到此实例中。该副本将从索引start开始并复制length字节。
  - AsciiString
```
public AsciiString(char[] value,
                   java.nio.charset.Charset charset)
```
    使用编码类型 charset将 value的副本创建到此实例中。
  - AsciiString
```
public AsciiString(char[] value,
                   java.nio.charset.Charset charset,
                   int start,
                   int length)
```
    使用编码类型charset为此实例创建一个value的副本。该副本将从索引start开始并复制length字节。
  - AsciiString
```
public AsciiString(java.lang.CharSequence value)
```
    假设使用ASCII编码，将 value的副本创建到此实例中。
  - AsciiString
```
public AsciiString(java.lang.CharSequence value,
                   int start,
                   int length)
```
    使用ASCII编码将value的副本创建到此实例中。该副本将从索引start开始并复制length字节。
  - AsciiString
```
public AsciiString(java.lang.CharSequence value,
                   java.nio.charset.Charset charset)
```
    使用编码类型 charset将 value的副本创建到此实例中。
  - AsciiString
```
public AsciiString(java.lang.CharSequence value,
                   java.nio.charset.Charset charset,
                   int start,
                   int length)
```
    使用编码类型charset将value的副本创建到此实例中。该副本将从索引start开始并复制length字节。
- 方法详细信息
  - forEachByte
```
public int forEachByte(ByteProcessor visitor)
                throws java.lang.Exception
```
    使用指定的 processor按升序对此缓冲区的可读字节进行迭代。
    
    结果
    
    -1如果处理器迭代到或超出可读字节的末尾。最后访问的索引如果ByteProcessor.process(byte)返回false 。
    
    异常
    
    java.lang.Exception
  - forEachByte
```
public int forEachByte(int index,
                       int length,
                       ByteProcessor visitor)
                throws java.lang.Exception
```
    以指定的processor按升序迭代该缓冲区的指定区域。（即index ， (index + 1) ，.. (index + length - 1) ）。
    
    结果
    
    -1如果处理器迭代到或超出指定区域的末尾。最后访问的索引如果ByteProcessor.process(byte)返回false 。
    
    异常
    
    java.lang.Exception
  - forEachByteDesc
```
public int forEachByteDesc(ByteProcessor visitor)
                    throws java.lang.Exception
```
    使用指定的 processor按降序对此缓冲区的可读字节进行迭代。
    
    结果
    
    -1如果处理器迭代到或超出可读字节的开始位置。最后访问的索引如果ByteProcessor.process(byte)返回false 。
    
    异常
    
    java.lang.Exception
  - forEachByteDesc
```
public int forEachByteDesc(int index,
                           int length,
                           ByteProcessor visitor)
                    throws java.lang.Exception
```
    使用指定的processor按降序对此缓冲区的指定区域进行迭代。（即(index + length - 1) ， (index + length - 2) ，... index ）。
    
    结果
    
    -1如果处理器迭代到或超出指定区域的开始位置。最后访问的索引如果ByteProcessor.process(byte)返回false 。
    
    异常
    
    java.lang.Exception
  - byteAt
```
public byte byteAt(int index)
```
  - isEmpty
```
public boolean isEmpty()
```
    确定此实例是否具有0长度。
  - length
```
public int length()
```
    此实例的字节长度。
    
    Specified by:
    
    length ，界面 java.lang.CharSequence
  - arrayChanged
```
public void arrayChanged()
```
    在正常使用情况下， AsciiString应该是不可变的，但是如果底层数组是共享的，那么需要调用它。
  - array
```
public byte[] array()
```
    这可以直接访问底层存储阵列。 toByteArray()应该优于此方法。如果返回值更改，则必须调用arrayChanged() 。
    
    另请参见：
    
    arrayOffset() ， isEntireArrayUsed()
  - arrayOffset
```
public int arrayOffset()
```
    此ByteString数据开始的 array()的偏移量。
    
    另请参见：
    
    array() ， isEntireArrayUsed()
  - isEntireArrayUsed
```
public boolean isEntireArrayUsed()
```
    确定是否完全使用 array()表示的存储。
    
    另请参见：
    
    array()
  - toByteArray
```
public byte[] toByteArray()
```
    将此字符串转换为字节数组。
  - toByteArray
```
public byte[] toByteArray(int start,
                          int end)
```
    将此字符串的子集转换为字节数组。该子集是由范围[定义start ， end ）。
  - copy
```
public void copy(int srcIdx,
                 byte[] dst,
                 int dstIdx,
                 int length)
```
    将此字符串的内容复制到字节数组。
    
    参数
    
    srcIdx - 要复制的字符的起始偏移量。
    
    dst - 目标字节数组。
    
    dstIdx - 目标字节数组中的起始偏移量。
    
    length - 要复制的字符数。
  - charAt
```
public char charAt(int index)
```
    Specified by:
    
    charAt在界面 java.lang.CharSequence
  - contains
```
public boolean contains(java.lang.CharSequence cs)
```
    确定 String包含通过的 CharSequence的字符序列。
    
    参数
    
    cs - 要搜索的字符序列。
    
    结果
    
    true如果字符序列包含在此字符串中，否则为 false 。
  - compareTo
```
public int compareTo(java.lang.CharSequence string)
```
    使用字符的ASCII值将指定的字符串与此字符串进行比较。如果字符串包含相同顺序的相同字符，则返回0。如果此字符串中的第一个非等号字符的ASCII值小于指定字符串中相同位置的字符的ASCII值，或者此字符串是指定字符串的前缀，则返回负整数。如果此字符串中的第一个非等号字符的ASCII值大于指定字符串中相同位置处字符的ASCII值，或者指定的字符串是此字符串的前缀，则返回正整数。
    
    Specified by:
    
    compareTo在界面 java.lang.Comparable<java.lang.CharSequence>
    
    参数
    
    string - 要比较的字符串。
    
    结果
    
    如果字符串相等，则为0;如果此字符串位于指定字符串之前，则为负整数;如果此字符串位于指定字符串之后，则为正整数。
    
    异常
    
    java.lang.NullPointerException - 如果 string是 null 。
  - concat
```
public AsciiString concat(java.lang.CharSequence string)
```
    连接此字符串和指定的字符串。
    
    参数
    
    string - 要连接的字符串
    
    结果
    
    一个新的字符串，它是这个字符串和指定字符串的连接。
  - endsWith
```
public boolean endsWith(java.lang.CharSequence suffix)
```
    将指定的字符串与此字符串进行比较，以确定指定的字符串是否为后缀。
    
    参数
    
    suffix - 寻找的后缀。
    
    结果
    
    true如果指定的字符串是这个字符串的后缀， false其他。
    
    异常
    
    java.lang.NullPointerException - 如果 suffix是 null 。
  - contentEqualsIgnoreCase
```
public boolean contentEqualsIgnoreCase(java.lang.CharSequence string)
```
    将指定的字符串与此字符串进行比较，忽略字符的大小写，如果相等，则返回true。
    
    参数
    
    string - 要比较的字符串。
    
    结果
    
    true如果指定的字符串是等于该字符串， false否则。
  - toCharArray
```
public char[] toCharArray()
```
    将此字符串中的字符复制到字符数组。
    
    结果
    
    包含此字符串的字符的字符数组。
  - toCharArray
```
public char[] toCharArray(int start,
                          int end)
```
    将此字符串中的字符复制到字符数组。
    
    结果
    
    包含此字符串的字符的字符数组。
  - copy
```
public void copy(int srcIdx,
                 char[] dst,
                 int dstIdx,
                 int length)
```
    将此字符串的内容复制到字符数组中。
    
    参数
    
    srcIdx - 要复制的字符的起始偏移量。
    
    dst - 目标字符数组。
    
    dstIdx - 目标字节数组中的起始偏移量。
    
    length - 要复制的字符数。
  - subSequence
```
public AsciiString subSequence(int start)
```
    将一系列字符复制到新字符串中。
    
    参数
    
    start - 第一个字符的偏移量（含）。
    
    结果
    
    一个包含字符串从开始到结束的字符的新字符串。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果 start < 0或 start > length() 。
  - subSequence
```
public AsciiString subSequence(int start,
                               int end)
```
    将一系列字符复制到新字符串中。
    
    Specified by:
    
    subSequence ，界面 java.lang.CharSequence
    
    参数
    
    start - 第一个字符的偏移量（含）。
    
    end - 停止（不包括）的索引。
    
    结果
    
    一个包含字符串从开始到结束的字符的新字符串。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果 start < 0或 start > length() 。
  - subSequence
```
public AsciiString subSequence(int start,
                               int end,
                               boolean copy)
```
    复制或共享底层字节子序列的子集。
    
    参数
    
    start - 第一个字符的偏移量（含）。
    
    end - 停止（不包括）的索引。
    
    copy - 如果true那么将创建底层存储的副本。如果false那么底层存储将被共享。
    
    结果
    
    一个包含字符串从开始到结束的字符的新字符串。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果 start < 0或 start > length() 。
  - indexOf
```
public int indexOf(java.lang.CharSequence string)
```
    在此字符串中搜索指定字符串的第一个索引。搜索字符串从头开始，并移向该字符串的末尾。
    
    参数
    
    string - 要查找的字符串。
    
    结果
    
    此字符串中指定字符串的第一个字符的索引，如果指定的字符串不是子字符串，则为-1。
    
    异常
    
    java.lang.NullPointerException - 如果 string是 null 。
  - indexOf
```
public int indexOf(java.lang.CharSequence subString,
                   int start)
```
    在此字符串中搜索指定字符串的索引。搜索字符串从指定的偏移量开始并移向该字符串的末尾。
    
    参数
    
    subString - 要查找的字符串。
    
    start - 起始偏移量。
    
    结果
    
    此字符串中指定字符串的第一个字符的索引，如果指定的字符串不是子字符串，则为-1。
    
    异常
    
    java.lang.NullPointerException - 如果 subString是 null 。
  - indexOf
```
public int indexOf(char ch,
                   int start)
```
    在此字符串中搜索指定字符的索引ch 。对字符的搜索从指定的偏移量start开始，并移向该字符串的末尾。
    
    参数
    
    ch - 找到的字符。
    
    start - 起始偏移量。
    
    结果
    
    该字符串中指定的第一个字符 ch的索引，如果未找到，则为-1。
  - lastIndexOf
```
public int lastIndexOf(java.lang.CharSequence string)
```
    在此字符串中搜索指定字符串的最后一个索引。对字符串的搜索从结尾开始并移向该字符串的开头。
    
    参数
    
    string - 要查找的字符串。
    
    结果
    
    此字符串中指定字符串的第一个字符的索引，如果指定的字符串不是子字符串，则为-1。
    
    异常
    
    java.lang.NullPointerException - 如果 string是 null 。
  - lastIndexOf
```
public int lastIndexOf(java.lang.CharSequence subString,
                       int start)
```
    在此字符串中搜索指定字符串的索引。搜索字符串从指定的偏移量开始，并移动到该字符串的开头。
    
    参数
    
    subString - 要查找的字符串。
    
    start - 起始偏移量。
    
    结果
    
    此字符串中指定字符串的第一个字符的索引，如果指定的字符串不是子字符串，则为-1。
    
    异常
    
    java.lang.NullPointerException - 如果 subString是 null 。
  - regionMatches
```
public boolean regionMatches(int thisStart,
                             java.lang.CharSequence string,
                             int start,
                             int length)
```
    将指定的字符串与此字符串进行比较，并比较指定的字符范围以确定它们是否相同。
    
    参数
    
    thisStart - 此字符串中的起始偏移量。
    
    string - 要比较的字符串。
    
    start - 指定字符串中的起始偏移量。
    
    length - 要比较的字符数。
    
    结果
    
    true如果字符的范围相等， false
    
    异常
    
    java.lang.NullPointerException - 如果 string是 null 。
  - regionMatches
```
public boolean regionMatches(boolean ignoreCase,
                             int thisStart,
                             java.lang.CharSequence string,
                             int start,
                             int length)
```
    将指定的字符串与此字符串进行比较，并比较指定的字符范围以确定它们是否相同。当ignoreCase为true时，字符的大小写在比较过程中被忽略。
    
    参数
    
    ignoreCase - 指定是否应该忽略大小写。
    
    thisStart - 此字符串中的起始偏移量。
    
    string - 要比较的字符串。
    
    start - 指定字符串中的起始偏移量。
    
    length - 要比较的字符数。
    
    结果
    
    true如果字符的范围相等， false 。
    
    异常
    
    java.lang.NullPointerException - 如果 string是 null 。
  - replace
```
public AsciiString replace(char oldChar,
                           char newChar)
```
    复制此字符串，用其他字符替换指定字符的出现位置。
    
    参数
    
    oldChar - 要替换的字符。
    
    newChar - 替换角色。
    
    结果
    
    一个newChar被newChar替换的新字符串。
  - startsWith
```
public boolean startsWith(java.lang.CharSequence prefix)
```
    将指定的字符串与此字符串进行比较，以确定指定的字符串是否为前缀。
    
    参数
    
    prefix - 要查找的字符串。
    
    结果
    
    true如果指定的字符串是这个字符串的前缀， false否则
    
    异常
    
    java.lang.NullPointerException - 如果 prefix是 null 。
  - startsWith
```
public boolean startsWith(java.lang.CharSequence prefix,
                          int start)
```
    将指定的字符串与此字符串进行比较，从指定的偏移量开始，以确定指定的字符串是否为前缀。
    
    参数
    
    prefix - 要查找的字符串。
    
    start - 起始偏移量。
    
    结果
    
    true如果指定的字符串出现在指定偏移量的此字符串中，则 false否则 false 。
    
    异常
    
    java.lang.NullPointerException - 如果 prefix是 null 。
  - toLowerCase
```
public AsciiString toLowerCase()
```
    使用默认的Locale将此字符串中的字符转换为小写字母。
    
    结果
    
    一个包含小写字符的新字符串，与该字符串中的字符相同。
  - toUpperCase
```
public AsciiString toUpperCase()
```
    使用默认的Locale将此字符串中的字符转换为大写。
    
    结果
    
    包含大写字符的新字符串，与该字符串中的字符相同。
  - trim
```
public static java.lang.CharSequence trim(java.lang.CharSequence c)
```
    复制此字符串，从字符串的开头和结尾删除空格字符，并尽可能不复制。
    
    参数
    
    c - 修剪 CharSequence 。
    
    结果
    
    一个新的字符串，其字符 <= \\u0020从开头和结尾删除。
  - trim
```
public AsciiString trim()
```
    复制此字符串，从字符串的开头和结尾删除空格字符，而不进行复制。
    
    结果
    
    一个新的字符串，其字符从开始和结束中删除 <= \\u0020 。
  - contentEquals
```
public boolean contentEquals(java.lang.CharSequence a)
```
    将 CharSequence与 String进行比较，以确定它们的内容是否相等。
    
    参数
    
    a - 与之比较的字符序列。
    
    结果
    
    true如果相等，否则 false
  - matches
```
public boolean matches(java.lang.String expr)
```
    确定此字符串是否与给定的正则表达式匹配。
    
    参数
    
    expr - 要匹配的正则表达式。
    
    结果
    
    true如果表达式相匹配，否则 false 。
    
    异常
    
    java.util.regex.PatternSyntaxException - 如果提供的正则表达式的语法无效。
    
    java.lang.NullPointerException - 如果 expr是 null 。
  - split
```
public AsciiString[] split(java.lang.String expr,
                           int max)
```
    使用提供的正则表达式expr分割此字符串。参数max控制模式应用于字符串的次数。
    
    参数
    
    expr - 用于分割字符串的正则表达式。
    
    max - 结果数组中的条目数。
    
    结果
    
    通过沿正则表达式的匹配将字符串分开创建的字符串数组。
    
    异常
    
    java.lang.NullPointerException - 如果 expr是 null 。
    
    java.util.regex.PatternSyntaxException - 如果提供的正则表达式的语法无效。
    
    另请参见：
    
    Pattern.split(CharSequence, int)
  - split
```
public AsciiString[] split(char delim)
```
    用指定的分隔符分割指定的 String ..
  - hashCode
```
public int hashCode()
```
    为Ascii提供像字节字符串一样的不区分大小写的哈希码。
    
    重写：
    
    hashCode在课程 java.lang.Object
  - equals
```
public boolean equals(java.lang.Object obj)
```
    重写：
    
    equals在课程 java.lang.Object
  - toString
```
public java.lang.String toString()
```
    将整个字节字符串转换为 String 。
    
    Specified by:
    
    toString ，界面 java.lang.CharSequence
    
    重写：
    
    toString在课程 java.lang.Object
    
    另请参见：
    
    toString(int)
  - toString
```
public java.lang.String toString(int start)
```
    使用 charset编码将整个字节字符串转换为 String 。
    
    另请参见：
    
    toString(int, int)
  - toString
```
public java.lang.String toString(int start,
                                 int end)
```
    平移[ start ， end ）范围该字节字符串到的 String 。
  - parseBoolean
```
public boolean parseBoolean()
```
  - parseChar
```
public char parseChar()
```
  - parseChar
```
public char parseChar(int start)
```
  - parseShort
```
public short parseShort()
```
  - parseShort
```
public short parseShort(int radix)
```
  - parseShort
```
public short parseShort(int start,
                        int end)
```
  - parseShort
```
public short parseShort(int start,
                        int end,
                        int radix)
```
  - parseInt
```
public int parseInt()
```
  - parseInt
```
public int parseInt(int radix)
```
  - parseInt
```
public int parseInt(int start,
                    int end)
```
  - parseInt
```
public int parseInt(int start,
                    int end,
                    int radix)
```
  - parseLong
```
public long parseLong()
```
  - parseLong
```
public long parseLong(int radix)
```
  - parseLong
```
public long parseLong(int start,
                      int end)
```
  - parseLong
```
public long parseLong(int start,
                      int end,
                      int radix)
```
  - parseFloat
```
public float parseFloat()
```
  - parseFloat
```
public float parseFloat(int start,
                        int end)
```
  - parseDouble
```
public double parseDouble()
```
  - parseDouble
```
public double parseDouble(int start,
                          int end)
```
  - of
```
public static AsciiString of(java.lang.CharSequence string)
```
    返回包含给定字符序列的AsciiString 。如果给定的字符串已经是AsciiString ，则返回相同的实例。
  - cached
```
public static AsciiString cached(java.lang.String string)
```
    返回包含给定字符串的AsciiString ，并保留/缓存输入字符串以供稍后在toString()中使用。用于常量（已存储在JVM的字符串表中）以及保证使用toString()方法的情况。
  - hashCode
```
public static int hashCode(java.lang.CharSequence value)
```
    返回指定字符串的不区分大小写的哈希码。请注意，此方法对hashCode()使用相同的哈希算法，因此您可以将AsciiString和任意CharSequence放入相同的头文件中。
  - contains
```
public static boolean contains(java.lang.CharSequence a,
                               java.lang.CharSequence b)
```
    以区分大小写的方式确定 a包含 b 。
  - containsIgnoreCase
```
public static boolean containsIgnoreCase(java.lang.CharSequence a,
                                         java.lang.CharSequence b)
```
    以不区分大小写的方式确定 a包含 b 。
  - contentEqualsIgnoreCase
```
public static boolean contentEqualsIgnoreCase(java.lang.CharSequence a,
                                              java.lang.CharSequence b)
```
    如果两个CharSequence在忽略大小写时均为等于，则返回true 。这仅支持8位ASCII。
  - containsContentEqualsIgnoreCase
```
public static boolean containsContentEqualsIgnoreCase(java.util.Collection<java.lang.CharSequence> collection,
                                                      java.lang.CharSequence value)
```
    确定 collection包含 value并使用 contentEqualsIgnoreCase(CharSequence, CharSequence)来比较值。
    
    参数
    
    collection - 要查找的集合和等效元素为 value 。
    
    value - 在 collection查找的值。
    
    结果
    
    true如果collection包含value根据contentEqualsIgnoreCase(CharSequence, CharSequence) 。否则为false 。
    
    另请参见：
    
    contentEqualsIgnoreCase(CharSequence, CharSequence)
  - containsAllContentEqualsIgnoreCase
```
public static boolean containsAllContentEqualsIgnoreCase(java.util.Collection<java.lang.CharSequence> a,
                                                         java.util.Collection<java.lang.CharSequence> b)
```
    确定是否 a包含的所有值 b使用 contentEqualsIgnoreCase(CharSequence, CharSequence)来比较值。
    
    参数
    
    a - 被测试的集合。
    
    b - 要测试的值。
    
    结果
    
    true如果a包含的所有值b使用contentEqualsIgnoreCase(CharSequence, CharSequence)来比较值。 false否则。
    
    另请参见：
    
    contentEqualsIgnoreCase(CharSequence, CharSequence)
  - contentEquals
```
public static boolean contentEquals(java.lang.CharSequence a,
                                    java.lang.CharSequence b)
```
    如果两个CharSequence的内容true则返回true 。这仅支持8位ASCII。
  - regionMatches
```
public static boolean regionMatches(java.lang.CharSequence cs,
                                    boolean ignoreCase,
                                    int csStart,
                                    java.lang.CharSequence string,
                                    int start,
                                    int length)
```
    此方法可以正确地为字符串中的任何字符进行regionMatches操作
    
    参数
    
    cs - 要处理的 CharSequence
    
    ignoreCase - 指定是否应该忽略大小写。
    
    csStart - cs CharSequence的起始偏移量
    
    string - CharSequence进行比较。
    
    start - 指定的 string的起始偏移量。
    
    length - 要比较的字符数。
    
    结果
    
    true如果字符的范围相等， false否则。
  - regionMatchesAscii
```
public static boolean regionMatchesAscii(java.lang.CharSequence cs,
                                         boolean ignoreCase,
                                         int csStart,
                                         java.lang.CharSequence string,
                                         int start,
                                         int length)
```
    这是仅针对带有ASCII字符的字符串的regionMatches的优化版本
    
    参数
    
    cs - 要处理的 CharSequence
    
    ignoreCase - 指定是否应该忽略大小写。
    
    csStart - cs CharSequence中的起始偏移量
    
    string - CharSequence进行比较。
    
    start - 指定的 string的起始偏移量。
    
    length - 要比较的字符数。
    
    结果
    
    true如果字符的范围相等， false 。
  - indexOfIgnoreCase
```
public static int indexOfIgnoreCase(java.lang.CharSequence str,
                                    java.lang.CharSequence searchStr,
                                    int startPos)
```
    大小写敏感地查找指定位置的CharSequence内的第一个索引。
    
    null CharSequence将返回-1 。负的起始位置被视为零。一个空的（“”）搜索CharSequence总是匹配。大于字符串长度的起始位置只与空搜索CharSequence匹配。
```
  AsciiString.indexOfIgnoreCase(null, *, *)          = -1
 AsciiString.indexOfIgnoreCase(*, null, *)          = -1
 AsciiString.indexOfIgnoreCase("", "", 0)           = 0
 AsciiString.indexOfIgnoreCase("aabaabaa", "A", 0)  = 0
 AsciiString.indexOfIgnoreCase("aabaabaa", "B", 0)  = 2
 AsciiString.indexOfIgnoreCase("aabaabaa", "AB", 0) = 1
 AsciiString.indexOfIgnoreCase("aabaabaa", "B", 3)  = 5
 AsciiString.indexOfIgnoreCase("aabaabaa", "B", 9)  = -1
 AsciiString.indexOfIgnoreCase("aabaabaa", "B", -1) = 2
 AsciiString.indexOfIgnoreCase("aabaabaa", "", 2)   = 2
 AsciiString.indexOfIgnoreCase("abc", "", 9)        = -1 
```
    参数
    
    str - 要检查的CharSequence可能为空
    
    searchStr - 查找的CharSequence可能为null
    
    startPos - 起始位置，负数视为零
    
    结果
    
    搜索CharSequence的第一个索引（始终为“startPos”），如果不匹配则 null -1或输入字符串 null
  - indexOfIgnoreCaseAscii
```
public static int indexOfIgnoreCaseAscii(java.lang.CharSequence str,
                                         java.lang.CharSequence searchStr,
                                         int startPos)
```
    大小写敏感地查找指定位置的CharSequence内的第一个索引。此方法仅针对ASCII CharSequences进行了优化和正确工作
    
    一个null CharSequence将返回-1 。负的起始位置被视为零。一个空的（“”）搜索CharSequence总是匹配。大于字符串长度的起始位置只与空搜索CharSequence匹配。
```
  AsciiString.indexOfIgnoreCase(null, *, *)          = -1
 AsciiString.indexOfIgnoreCase(*, null, *)          = -1
 AsciiString.indexOfIgnoreCase("", "", 0)           = 0
 AsciiString.indexOfIgnoreCase("aabaabaa", "A", 0)  = 0
 AsciiString.indexOfIgnoreCase("aabaabaa", "B", 0)  = 2
 AsciiString.indexOfIgnoreCase("aabaabaa", "AB", 0) = 1
 AsciiString.indexOfIgnoreCase("aabaabaa", "B", 3)  = 5
 AsciiString.indexOfIgnoreCase("aabaabaa", "B", 9)  = -1
 AsciiString.indexOfIgnoreCase("aabaabaa", "B", -1) = 2
 AsciiString.indexOfIgnoreCase("aabaabaa", "", 2)   = 2
 AsciiString.indexOfIgnoreCase("abc", "", 9)        = -1 
```
    参数
    
    str - 要检查的CharSequence可能为空
    
    searchStr - 查找的CharSequence可能为null
    
    startPos - 起始位置，负数视为零
    
    结果
    
    搜索CharSequence的第一个索引（始终为<startPos>），如果不匹配则 null -1或者输入 null字符串
  - indexOf
```
public static int indexOf(java.lang.CharSequence cs,
                          char searchChar,
                          int start)
```
    查找CharSequence中与指定字符匹配的第一个索引。
    
    参数
    
    cs - 要处理的 CharSequence ，不为null
    
    searchChar - 要搜索的字符
    
    start - 起始索引，负数从字符串开始处开始
    
    结果
    
    找到搜索字符的索引，-1（如果未找到字符 searchChar ）或 cs == null
  - isUpperCase
```
public static boolean isUpperCase(byte value)
```
  - isUpperCase
```
public static boolean isUpperCase(char value)
```
  - c2b
```
public static byte c2b(char c)
```
  - b2c
```
public static char b2c(byte b)
```

Class AsciiString

Field Summary

构造方法摘要

方法摘要

Methods inherited from class java.lang.Object

Methods inherited from interface java.lang.CharSequence

字段详细信息

EMPTY_STRING

INDEX_NOT_FOUND

CASE_INSENSITIVE_HASHER

CASE_SENSITIVE_HASHER

构造方法详细信息

AsciiString

AsciiString

AsciiString

AsciiString

AsciiString

AsciiString

AsciiString

AsciiString

AsciiString

AsciiString

AsciiString

AsciiString

AsciiString

AsciiString

方法详细信息

forEachByte

forEachByte

forEachByteDesc

forEachByteDesc

byteAt

isEmpty

length

arrayChanged

array

arrayOffset

isEntireArrayUsed

toByteArray

toByteArray

copy

charAt

contains

compareTo

concat

endsWith

contentEqualsIgnoreCase

toCharArray

toCharArray

copy

subSequence

subSequence

subSequence

indexOf

indexOf

indexOf

lastIndexOf

lastIndexOf

regionMatches

regionMatches

replace

startsWith

startsWith

toLowerCase

toUpperCase

trim

trim

contentEquals

matches

split

split

hashCode

equals

toString

toString

toString

parseBoolean

parseChar

parseChar

parseShort