涉及API

涉及API
类 java.io.InputStream
abstract  int read() : 从输入流中读取数据的下一个字节。
int read(byte[] b) : 从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中。即读入一个字节数组，并返回实际读入的字节数，或者在碰到流的结尾时返回-1，这个read方法最多读入b.length个字节。将读取的第一个字节存储在元素 b[0]中。
int read(byte[] b, int off, int len) : 将输入流中最多 len 个数据字节读入 byte 数组。返回实际读入的字节数，或者在碰到流的结尾时返回-1。
    参数：
        b - 读入数据的缓冲区。
        off - 数组 b 中将写入数据的初始偏移量。
        len - 要读取的最大字节数。
long skip(long n) : 跳过和丢弃此输入流中数据的 n 个字节。返回实际跳过的字节数(如果碰到流的结尾，则可能小于n)
int available() : 返回此输入流下一个方法调用可以不受阻塞地从此输入流读取（或跳过）的估计字节数。(阻塞意味着当前线程将失去它对资源的占用)
void close() : 关闭此输入流并释放与该流关联的所有系统资源。
void mark(int readlimit) : 此输入流中标记当前的位置(并非所有流都支持这个特性)。如果从输入流中已经读入的字节多于readlimit，则这个流允许忽略这个标记。
void reset() : 将此流重新定位到最后一次对此输入流调用 mark 方法时的位置。随后的read方法的调用将重复读入这个字节，如果当前流没有任何标记，则这个流不被重置。
boolean markSupported() : 测试此输入流是否支持 mark 和 reset 方法。如果此输入流实例支持 mark 和 reset 方法，则返回 true；否则返回 false。
   
类 java.io.OutputStream
abstract  void write(int b) : 将指定的字节写入此输出流。
void write(byte[] b) : 将 b.length 个字节从指定的 byte 数组写入此输出流。
void write(byte[] b, int off, int len) : 将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流。
    参数：
        b - 数据。
        off - 数据中的初始偏移量。
        len - 要写入的字节数。  
void close() : 关闭此输出流并释放与此流有关的所有系统资源。
void flush() : 刷新此输出流并强制写出所有缓冲的输出字节。

类 java.io.File
boolean canExecute() : 测试应用程序是否可以执行此抽象路径名表示的文件。
boolean canRead() : 测试应用程序是否可以读取此抽象路径名表示的文件。
boolean canWrite() : 测试应用程序是否可以修改此抽象路径名表示的文件。
boolean setReadable(boolean readable, boolean ownerOnly) : 设置此抽象路径名的所有者或所有用户的读权限。
boolean setWritable(boolean writable, boolean ownerOnly) : 设置此抽象路径名的所有者或所有用户的写权限。
boolean setExecutable(boolean executable, boolean ownerOnly) : 设置此抽象路径名的所有者或所有用户的执行权限。
    参数：
        readable - 如果为 true，则设置允许读操作的访问权限；如果为 false，则不允许读操作。
        writable - 如果为 true，则设置允许写操作的访问权限；如果为 false，则不允许写操作。
        executable - 如果为 true，则设置允许执行操作的访问权限；如果为 false，则不允许执行操作。
        ownerOnly - 如果为 true，则执行权限只适用于所有者的执行权限；否则适用于所有用户。如果底层文件系统不能区分所有者执行权限与其他执行权限，那么无论该参数为何值，执行权限将适用于所有用户。
static File createTempFile(String prefix, String suffix) : 在默认临时文件目录中创建一个空文件，使用给定前缀和后缀生成其名称。
static File createTempFile(String prefix, String suffix, File directory) : 在指定目录中创建一个新的空文件，使用给定的前缀和后缀字符串生成其名称。
    参数：
        prefix - 用于生成文件名的前缀字符串；必须至少是三字符长
        suffix - 用于生成文件名的后缀字符串；可以为 null，在这种情况下，将使用后缀 ".tmp"
        directory - 将创建的文件所在的目录；如果使用默认临时文件目录，则该参数为 null
boolean delete() : 删除此抽象路径名表示的文件或目录。当且仅当成功删除文件或目录时，返回 true；否则返回 false
void deleteOnExit() : 在虚拟机终止时，请求删除此抽象路径名表示的文件或目录。       
boolean exists() : 测试此抽象路径名表示的文件或目录是否存在。
File getAbsoluteFile() : 返回此抽象路径名的绝对路径名形式。
String getAbsolutePath() : 返回此抽象路径名的绝对路径名字符串。
File getCanonicalFile() : 返回此抽象路径名的规范形式。
String getCanonicalPath() : 返回此抽象路径名的规范路径名字符串。
String getName() : 返回由此抽象路径名表示的文件或目录的名称。
String getParent() : 返回此抽象路径名父目录的路径名字符串；如果此路径名没有指定父目录，则返回 null。
String getPath() : 将此抽象路径名转换为一个路径名字符串。
boolean isDirectory() : 测试此抽象路径名表示的文件是否是一个目录。
boolean isFile() : 测试此抽象路径名表示的文件是否是一个标准文件。
boolean isHidden() : 测试此抽象路径名指定的文件是否是一个隐藏文件。
long lastModified() : 返回此抽象路径名表示的文件最后一次被修改的时间。
long length() : 返回由此抽象路径名表示的文件的长度。
String[] list() : 返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中的文件和目录。
String[] list(FilenameFilter filter) : 返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中满足指定过滤器的文件和目录。
File[] listFiles() : 返回一个抽象路径名数组，这些路径名表示此抽象路径名表示的目录中的文件。
File[] listFiles(FileFilter filter) : 返回抽象路径名数组，这些路径名表示此抽象路径名表示的目录中满足指定过滤器的文件和目录。
File[] listFiles(FilenameFilter filter) : 返回抽象路径名数组，这些路径名表示此抽象路径名表示的目录中满足指定过滤器的文件和目录。
static File[] listRoots() : 列出可用的文件系统根。
boolean createNewFile() : 当且仅当不存在具有此抽象路径名指定名称的文件时，不可分地创建一个新的空文件。
boolean mkdir() : 创建此抽象路径名指定的目录。
boolean mkdirs() : 创建此抽象路径名指定的目录，包括所有必需但不存在的父目录。
boolean renameTo(File dest) : 重新命名此抽象路径名表示的文件。
boolean setLastModified(long time) : 设置此抽象路径名指定的文件或目录的最后一次修改时间。
boolean setReadOnly() : 标记此抽象路径名指定的文件或目录，从而只能对其进行读操作。
URI toURI() : 构造一个表示此抽象路径名的 file: URI。
long getTotalSpace() : 返回此抽象路径名指定的分区大小。
long getFreeSpace() : 返回此抽象路径名指定的分区中未分配的字节数。
long getUsableSpace() : 返回此抽象路径名指定的分区上可用于此虚拟机的字节数。

类 java.io.FileInputStream
构造 FileInputStream(File file) : 通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的 File 对象 file 指定。
构造 FileInputStream(String name) : 通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的路径名 name 指定。
FileChannel getChannel() : 返回与此文件输入流有关的唯一 FileChannel 对象。

类 java.io.FileOutputStream
构造 FileOutputStream(File file) : 创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
构造 FileOutputStream(File file, boolean append) : 创建一个向指定 File 对象表示的文件中写入数据的文件输出流。append - 如果为 true，则将字节写入文件末尾处，而不是写入文件开始处
构造 FileOutputStream(String name) : 创建一个向具有指定名称的文件中写入数据的输出文件流。
构造 FileOutputStream(String name, boolean append) : 创建一个向具有指定 name 的文件中写入数据的输出文件流。
FileChannel getChannel() : 返回与此文件输出流有关的唯一 FileChannel 对象。

类 java.io.RandomAccessFile
构造 RandomAccessFile(File file, String mode) : 创建从中读取和向其中写入（可选）的随机访问文件流，该文件由 File 参数指定。
构造 RandomAccessFile(String name, String mode) : 创建从中读取和向其中写入（可选）的随机访问文件流，该文件具有指定名称。
long getFilePointer() : 返回此文件中的当前偏移量。
void seek(long pos) : 设置到此文件开头测量到的文件指针偏移量，在该位置发生下一个读取或写入操作。
long length() : 返回此文件的长度。
FileChannel getChannel() : 返回与此文件关联的唯一 FileChannel 对象。

类 java.io.BufferedInputStream
构造 BufferedInputStream(InputStream in) : 创建一个 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。
 
类 java.io.BufferedOutputStream
构造 BufferedOutputStream(OutputStream out) : 创建一个新的缓冲输出流，以将数据写入指定的底层输出流。

接口 java.io.DataInput
boolean readBoolean() : 读取一个输入字节，如果该字节不是零，则返回 true，如果是零，则返回 false。
byte readByte() : 读取并返回一个输入字节。
char readChar() : 读取两个输入字节并返回一个 char 值。
double readDouble() : 读取八个输入字节并返回一个 double 值。
float readFloat() : 读取四个输入字节并返回一个 float 值。
void readFully(byte[] b) : 从输入流中读取一些字节，并将它们存储在缓冲区数组 b 中。
void readFully(byte[] b, int off, int len) : 从输入流中读取 len 个字节。
int readInt() : 读取四个输入字节并返回一个 int 值。
String readLine() : 从输入流中读取下一文本行。
long readLong() : 读取八个输入字节并返回一个 long 值。
short readShort() : 读取两个输入字节并返回一个 short 值。
int readUnsignedByte() : 读取一个输入字节，将它左侧补零 (zero-extend) 转变为 int 类型，并返回结果，所以结果的范围是 0 到 255。
int readUnsignedShort() : 读取两个输入字节，并返回 0 到 65535 范围内的一个 int 值。
String readUTF() : 读入一个已使用 UTF-8 修改版格式编码的字符串。
int skipBytes(int n) : 试图在输入流中跳过数据的 n 个字节，并丢弃跳过的字节。

接口 java.io.DataOutput
void write(byte[] b) : 将数组 b 中的所有字节写入输出流。
void write(byte[] b, int off, int len) : 将数组 b 中的 len 个字节按顺序写入输出流。
void write(int b) : 将参数 b 的八个低位写入输出流。
void writeBoolean(boolean v) : 将一个 boolean 值写入输出流。
void writeByte(int v) : 将参数 v 的八个低位写入输出流。
void writeBytes(String s) : 将一个字符串写入输出流。
void writeChar(int v) : 将一个 char 值写入输出流，该值由两个字节组成。
void writeChars(String s) : 将字符串 s 中的所有字符按顺序写入输出流，每个字符用两个字节表示。
void writeDouble(double v) : 将一个 double 值写入输出流，该值由八个字节组成。
void writeFloat(float v) : 将一个 float 值写入输出流，该值由四个字节组成。
void writeInt(int v) : 将一个 int 值写入输出流，该值由四个字节组成。
void writeLong(long v) : 将一个 long 值写入输出流，该值由八个字节组成。
void writeShort(int v) : 将两个字节写入输出流，用它们表示参数值。
void writeUTF(String s) : 将表示长度信息的两个字节写入输出流，后跟字符串 s 中每个字符的 UTF-8 修改版表示形式。

类 java.io.PrintWriter
构造 PrintWriter(Writer out) : 创建不带自动行刷新的新 PrintWriter。
构造 PrintWriter(Writer out, boolean autoFlush) : 创建新 PrintWriter。
构造 PrintWriter(OutputStream out) : 根据现有的 OutputStream 创建不带自动行刷新的新 PrintWriter。
构造 PrintWriter(OutputStream out, boolean autoFlush) : 通过现有的 OutputStream 创建新的 PrintWriter。
构造 PrintWriter(String fileName) : 创建具有指定文件名称且不带自动行刷新的新 PrintWriter。
构造 PrintWriter(String fileName, String csn) : 创建具有指定文件名称和字符集且不带自动行刷新的新 PrintWriter。
void print(Object obj) : 打印对象。
void println(Object x) : 打印 Object，然后终止该行。  
PrintWriter printf(String format, Object... args) : 使用指定格式字符串和参数将格式化的字符串写入此 writer 的便捷方法
boolean checkError() : 如果流没有关闭，则刷新流且检查其错误状态。
protected  void clearError() : 清除此流的错误状态。  

类 java.io.PushbackInputStream
构造 PushbackInputStream(InputStream in) : 创建一个字节的回推缓冲区的 PushbackInputStream 并保存其参数（即输入流 in），以供将来使用。
构造 PushbackInputStream(InputStream in, int size) : 使用指定 size 的推回缓冲区创建 PushbackInputStream，并保存其参数（即输入流 in），以供将来使用。
void unread(int b) : 推回一个字节：将其复制到推回缓冲区之前。

接口 java.io.Closeable
void close() : 关闭此流并释放与此流关联的所有系统资源。

接口 java.io.Flushable
void flush() : 通过将所有已缓冲输出写入底层流来刷新此流。

接口 java.lang.Readable
int read(CharBuffer cb) : 试图将字符读入指定的字符缓冲区。返回读入char值的数量，如果此字符源位于缓冲区末端，则返回 -1。

接口 java.lang.Appendable
Appendable append(char c) : 向此 Appendable 添加指定字符。
Appendable append(CharSequence csq) : 向此 Appendable 添加指定的字符序列。
Appendable append(CharSequence csq, int start, int end) : 向此 Appendable 添加指定字符序列的子序列。

接口 java.lang.CharSequence
char charAt(int index) : 返回指定索引的 char 值。
int length() : 返回此字符序列的长度。
CharSequence subSequence(int start, int end) : 返回一个新的 CharSequence，它是此序列的子序列。
String toString() : 返回一个包含此序列中字符的字符串，该字符串与此序列的顺序相同。
 
类 java.nio.charset.Charset
static SortedMap<String,Charset> availableCharsets() : 构造从规范 charset 名称到 charset 对象的有序映射。
static Charset forName(String charsetName) : 返回指定 charset 的 charset 对象。
Set<String> aliases() : 返回包含此 charset 各个别名的集合。  
ByteBuffer encode(CharBuffer cb) : 将此 charset 中的 Unicode 字符编码成字节的便捷方法。
ByteBuffer encode(String str) : 将此 charset 中的字符串编码成字节的便捷方法。

类 java.nio.Buffer
boolean hasRemaining() : 告知在当前位置和限制之间是否有元素。如果当前的缓冲区位置没有到达这个缓冲区的界限位置则返回true。
int limit() : 返回此缓冲区的限制。
Buffer clear() : 清除此缓冲区。
Buffer flip() : 反转此缓冲区。
Buffer rewind() : 重绕此缓冲区。
Buffer mark() : 在此缓冲区的位置设置标记。
Buffer reset() : 将此缓冲区的位置重置为以前标记的位置。           
boolean hasRemaining() : 告知在当前位置和限制之间是否有元素。           
int position() : 返回此缓冲区的位置。
int capacity() : 返回此缓冲区的容量。
          
类 java.nio.ByteBuffer
byte[] array() : 返回实现此缓冲区的 byte 数组（可选操作）。
static ByteBuffer wrap(byte[] array) : 将 byte 数组包装到缓冲区中。
static ByteBuffer wrap(byte[] array, int offset, int length) : 将 byte 数组包装到缓冲区中。
abstract byte get() : 相对 get 方法。读取此缓冲区当前位置的字节，然后该位置递增。即从当前位置获得一个字节，并将当前位置推到下一个字节。
abstract  byte get(int index) : 绝对 get 方法。读取指定索引处的字节。
ByteBuffer get(byte[] dst) : 相对批量 get 方法。此方法将此缓冲区的字节传输到给定的目标数组中。调用此方法的形式为 src.get(a)，该调用与以下调用完全相同src.get(a, 0, a.length)
ByteBuffer get(byte[] dst, int offset, int length) : 相对批量 get 方法。此方法将此缓冲区的字节传输到给定的目标数组中。如果此缓冲中剩余的字节少于满足请求所需的字节（即如果 length > remaining()），则不传输字节且抛出 BufferUnderflowException。
abstract  ByteBuffer put(byte b) : 相对 put 方法（可选操作）。将给定的字节写入此缓冲区的当前位置，然后该位置递增。即向当前位置推入一个字节，并将当前位置推到下一个字节。返回对这个缓冲区的引用。
ByteBuffer put(byte[] src) : 相对批量 put 方法（可选操作）。
ByteBuffer put(byte[] src, int offset, int length) : 相对批量 put 方法（可选操作）。此方法将把给定源数组中的字节字传输到此缓冲区中。如果要从该数组中复制的字节多于此缓冲区中的剩余字节，即如果 length > remaining()），则不传输字节且将抛出 BufferOverflowException。
    参数：
    src - 要从中读取字节的数组
    offset - 要读取的第一个字节在数组中的偏移量；必须为非负且不大于 array.length
    length - 要从给定数组读取的字节的数量；必须为非负且不大于 array.length - offset
abstract  ByteBuffer put(int index, byte b) : 绝对 put 方法（可选操作）。将给定字节写入此缓冲区的给定索引处。
XXX getXXX()
XXX getXXX(int index)
ByteBuffer putXXX()
byteBUffer putXXX(int index, XXX value)
获取或放置一个二进制数，XXX为int,long,short,Char,float或double中的一个。
ByteOrder order() : 获取此缓冲区的字节顺序。
ByteBuffer order(ByteOrder bo) : 修改此缓冲区的字节顺序。bo - 新的字节顺序，要么是 BIG_ENDIAN，要么是 LITTLE_ENDIAN  

类 java.nio.CharBuffer
char[] array() : 返回实现此缓冲区的字符数组（可选操作）。
char charAt(int index) : 读取相对于当前位置的给定索引处的字符。
String toString() : 返回包含此缓冲区中字符的字符串。   
abstract char get() : 读取此缓冲区当前位置的字符，然后该位置递增。
CharBuffer get(char[] dst) : 此方法将此缓冲区的字符传输到给定的目标数组中。调用此方法的形式为 src.get(a)，该调用与以下调用完全相同：src.get(a, 0, a.length) 。
CharBuffer get(char[] dst, int offset, int length) : 此方法将此缓冲区中的字符传输到给定的目标数组中。如果缓冲区中剩余的字符少于满足请求所需的字符，即如果 length > remaining()，则不传输字符且抛出 BufferUnderflowException。
    参数：
    dst - 要写入字符的数组
    offset - 要写入的第一个字符在数组中的偏移量；必须为非负且不大于 dst.length
    length - 要写入给定数组中的字符的最大数量；必须为非负且不大于 dst.length - offset
abstract  CharBuffer put(char c) : 将给定字符写入此缓冲区的当前位置，然后该位置递增。
CharBuffer put(char[] src) : 此方法将给定源字符数组的所有内容传输到此缓冲区中。调用此方法的形式为 dst.put(a)，该调用与以下调用完全相同：dst.put(a, 0, a.length)  
CharBuffer put(char[] src, int offset, int length) : 此方法将给定源数组中的字符传输到此缓冲区中。如果要从数组复制的字符多于此缓冲区中的剩余字符空间，即如果 length > remaining()，则不传输字符且抛出 BufferOverflowException。
    参数：
    src - 要从中读取字符的数组
    offset - 要读取的第一个字符在数组中的偏移量；必须为非负且不大于 array.length
    length - 要从给定数组读取的字符数量；必须为非负且不大于 array.length - offset
CharBuffer put(String src) : 相对批量 put 方法（可选操作）。
CharBuffer put(CharBuffer src) : 此方法将给定源字符串中的所有内容传输到此缓冲区中。。
int read(CharBuffer target) : 此方法将给定源缓冲区中的剩余字符传输到此缓冲区中。如果源缓冲区中的剩余字符多于此缓冲区的剩余字符空间，即 src.remaining() > remaining()，则不传输字符且抛出 BufferOverflowException。

类 java.util.zip.ZipInputStream
构造 ZipInputStream(InputStream in) : 创建新的 ZIP 输入流。
void closeEntry() : 关闭当前 ZIP 条目并定位流以读取下一个条目。
protected  ZipEntry createZipEntry(String name) : 为指定条目名称创建一个新的 ZipEntry 对象。
ZipEntry getNextEntry() : 读取下一个 ZIP 文件条目并将流定位到该条目数据的开始处。

类 java.util.zip.ZipOutputStream
构造 ZipOutputStream(OutputStream out) : 创建新的 ZIP 输出流。     
void putNextEntry(ZipEntry e) : 开始写入新的 ZIP 文件条目并将流定位到条目数据的开始处。
void closeEntry() : 关闭当前 ZIP 条目并定位流以写入下一个条目。
void setLevel(int level) : 为后续的 DEFLATED 条目设置压缩级别。默认设置是 DEFAULT_COMPRESSION。level - 压缩级别 (0-9)
void setMethod(int method) : 设置用于后续条目的默认压缩方法。压缩方法 DEFLATED 用于已压缩 (DEFLATED) 条目的压缩方法和 STORED 用于未压缩 (STORED) 条目的压缩方法。

类 java.util.zip.ZipEntry
构造 ZipEntry(String name) : 使用指定名称创建新的 ZIP 条目。
long getCrc() : 返回未压缩条目数据的 CRC-32 校验和；如果未知，则返回 -1。
String getName() : 返回条目名称。
long getSize() : 返回条目数据的未压缩大小；如果未知，则返回 -1。
boolean isDirectory() : 如果为目录条目，则返回 true。
void setMethod(int method) : 设置条目的压缩方法。
void setSize(long size) : 设置条目数据的未压缩大小。 只有压缩方法是STORED时才是必须的， size 这一项不被压缩的大小。
void setCrc(long crc) : 设置未压缩条目数据的 CRC-32 校验和。 只有压缩方法是STORED时才是必须的。
 
类 java.util.zip.ZipFile
构造 ZipFile(String name) : 打开 ZIP 文件进行阅读。
构造 ZipFile(File file) : 打开供阅读的 ZIP 文件，由指定的 File 对象给出。
Enumeration<? extends ZipEntry> entries() : 返回 ZIP 文件条目的枚举。
ZipEntry getEntry(String name) : 返回指定名称的 ZIP 文件条目；如果未找到，则返回 null。
InputStream getInputStream(ZipEntry entry) : 返回输入流以读取指定 ZIP 文件条目的内容。
String getName() : 返回 ZIP 文件的路径名。

类 java.io.ObjectOutputStream
构造 ObjectOutputStream(OutputStream out) : 创建写入指定 OutputStream 的 ObjectOutputStream。
void writeObject(Object obj) : 将指定的对象写入 ObjectOutputStream。

类 java.io.ObjectInputStream
ObjectInputStream(InputStream in) : 创建从指定 InputStream 读取的 ObjectInputStream。
Object readObject() : 从 ObjectInputStream 读取对象。

类 java.nio.channels.FileChannel
abstract  MappedByteBuffer map(FileChannel.MapMode mode, long position, long size) : 将此通道的文件区域直接映射到内存中。
    参数：
    mode - 根据是按只读、读取/写入或专用（写入时拷贝）来映射文件，分别为 FileChannel.MapMode 类中所定义的 READ_ONLY、READ_WRITE 或 PRIVATE 之一
    position - 文件中的位置，映射区域从此位置开始；必须为非负数
    size - 要映射的区域大小；必须为非负数且不大于 Integer.MAX_VALUE
FileLock lock() : 获取对此通道的文件的独占锁定。
abstract  FileLock lock(long position, long size, boolean shared) : 获取此通道的文件给定区域上的锁定。
FileLock tryLock() : 试图获取对此通道的文件的独占锁定。
abstract  FileLock tryLock(long position, long size, boolean shared) : 试图获取对此通道的文件给定区域的锁定。
    参数：
    position - 锁定区域开始的位置；必须为非负数
    size - 锁定区域的大小；必须为非负数，并且 position + size 的和必须为非负数
    shared - 要请求共享锁定，则为 true，要请求独占锁定，则为 false

类 java.nio.channels.FileLock
abstract  void release() : 释放此锁定。
boolean isShared() : 判断此锁定是否为共享的。

类 java.util.regex.Pattern
static Pattern compile(String regex) :  将给定的正则表达式编译到模式中。
static Pattern compile(String regex, int flags) : 将给定的正则表达式编译到具有给定标志的模式中。
    参数：
    regex - 要编译的表达式
    flags - 匹配标志，可能包括 CASE_INSENSITIVE、MULTILINE、DOTALL、UNICODE_CASE、 CANON_EQ、UNIX_LINES、LITERAL 和 COMMENTS 的位掩码
Matcher matcher(CharSequence input) : 创建匹配给定输入与此模式的匹配器。
String[] split(CharSequence input) : 围绕此模式的匹配拆分给定输入序列。
String[] split(CharSequence input, int limit) : 围绕此模式的匹配拆分给定输入序列。
    参数：
    input - 要拆分的字符序列
    limit - 结果阈值，如上文中所述
    
类 java.util.regex.Matcher
boolean matches() : 尝试将整个区域与模式匹配。
boolean lookingAt() : 尝试将从区域开头开始的输入序列与该模式匹配。
boolean find() : 尝试查找与该模式匹配的输入序列的下一个子序列。
boolean find(int start) : 重置此匹配器，然后尝试查找匹配该模式、从指定索引开始的输入序列的下一个子序列。 start 开始查找索引的位置
int start() : 返回以前匹配的初始索引。
int end() : 返回最后匹配字符之后的偏移量。
String group() : 返回由以前匹配操作所匹配的输入子序列。
int groupCount() : 返回此匹配器模式中的捕获组数。
int start(int group) : 返回在以前的匹配操作期间，由给定组所捕获的子序列的初始索引。 group - 此匹配器模式中捕获组的索引。
int end(int group) : 返回在以前的匹配操作期间，由给定组所捕获子序列的最后字符之后的偏移量。 group - 此匹配器模式中捕获组的索引。