---------------------------------------- JavaEE+云物联、期待与您交流！---------------------------------------------
前期准备01-3.4
十三、IO流
①概述
❶作用
IO流用来处理设备之间的数据传输。Java对数据的操作就是通过IO流的方式来完成的。IO流也被称为数据流。
IO流存在的前提：所有的关于IO流的操作，都要有目的地。输入要有输入源，输出要有输出目的地。
❷分类
按操作的数据：字节流、字符流
按流向：输入流、输出流
字符流和字节流的区别：字符流是以字节流为基础的，所有的字符流内部都融合了一个编码表，用于对其中的数据进行解读。
字符流只用于对文本数据的操作。
字符流的出现，使得对同一个事物的差异化描述，依然可以被正确解读。因为字符流中既包含了对事物的描述信息，也包含了解读方式。只要解读方式是正确的，就可以还原对事物的原有描述。
简单来说，字符流就是字节流的一种特殊形态，编码时使用了所对应字符集的编码规则，读取时只有通过该字符集，才可以重新还原为原有的字符形式，否则将会是乱码。
❸IO流常用的四个基类
字节流的抽象基类：InputStream、OutputStream/*['stri:m]流*/
字符流的抽象基类：Reader、Writer
由这四个基类派生出来的子类的名称，大都是以其父类名做后缀，其前缀表示功能。
❹IO流中的异常处理
绝大部分的IO流中的方法，都会抛出IOException。对每一个可抛异常的方法，都要做异常处理。在捕捉和处理时，可以放在一个try-catch中；用finally关闭多个流时，要分别进行非null判断后再单独关闭。
处理异常时，要注意变量的生存周期。
❺IO流中的一些组合流
字符流
转换流：InputStreamReader,OutputStreamWriter
文本流：FileReader,FileWriter
缓冲流：BufferedReader,BufferedWriter
标号流：LineNumberReader
打印流：PrintWriter
字符数组流：CharArrayReader,CharArrayWriter
字符串流：StringReader,StringWriter
字节流
文本流：FileInputStream,FileOutputStream
缓冲流：BufferedInputStream,BufferedOutputStream
打印流：PrintStream
序列流：SequenceInputStream
对象流：ObjectInputStream,ObjectOutputStream(组合使用)
管道流：PipedInputStream,PipedOutputStream(组合使用)
基本类型数据流：DataInputStream,DataOutputStream
字节数组流：ByteArrayInputStream,ByteArrayOutputStream
❻随机访问流RandomAccessFile
此流不属于IO体系，但其中封装了字节文本流。
该类的对象中，封装了一个大型的byte数组，并设置了一个文件指针。可以通过对指针的操作，完成对数据的读写。
❼装饰设计模式
当需要对某个对象的功能进行增强时，可以定义一个类接收这个对象，并基于此对象的基本功能，提供更加强大的功能。这时，被定义的这个类，就被称为装饰类。
装饰与继承的区别：
装饰是对继承的优化，既能够实现继承的效果，又能够扩展继承的体系。继承是单向的，装饰是多维的。装饰利用多态的特性，实现了对继承体系的优化。装饰将继承结构变为了组合结构。
装饰比继承更灵活，并且避免了继承体系的臃肿。装饰类与被装饰的类同属于一个体系。
装饰有局限性，只能够增强对象的原有功能，不会拥有新的功能；继承可以拥有新的功能。
❽实际应用中对IO流的选择
一是明确源和目的：
源：使用输入流。InputStream，Reader。
目的：使用输出流。OutputStream，Writer。
二是明确操作的是否是纯文本：
是：使用字符流。Reader，Writer。
不是：使用字节流。InputStream，OutputStream。
三是明确使用的设备：
源设备：内存ArrayStream，硬盘FileStream，键盘System.in。
目的设备：内存ArrayStream，硬盘FileStream，键盘System.out。
四是明确是否需要转换，是否需要提高效率。
❾递归
函数自身调用自身的方式，即称为递归。
递归注意事项：
一是限定条件。一定要有限制的条件，避免造成无限循环。
二是递归次数。尽量减少递归的次数，避免内存溢出。
❿字符集
字符流的出现是为了更方便的操作字符。其基于字节流，并使用了字符集。
可以对字节数据进行编码的只有转换流和打印流。
编码表的由来：计算机只能识别二进制数据，各个国家将本国的文字用数字来表示，并一一对应，从而形成了一张表，就是编码表。
②Reader/*['ri:də]读取*/类
public abstract class Reader
extends Object
implements Readable,Closeable/*['ri:dəbl]可读的['kləuzəbl]可关闭的*/
成员方法
public abstract void close()
throws IOException
关闭此流，并释放与之相关联的所有资源。
public void mark(int readAheadLimit)
throws IOException
/*[ma:k]标记[ə'hed]前面的['limit]限定*/
标记此流的当前位置。并不是所有的字符输入流都支持此方法。
readAheadLimit：在仍保留该标记的情况下，对可读字符数量的限制。
public boolean markSupported()/*[sə'pɔ:tid]支持*/
判断此流是否支持mark方法。
public int read()
throws IOException
读取此流中的单个字符，并返回其Unicode码的int值。如果已达到流的末尾，则返回-1。
public int read(char[] cbuf)
throws IOException
将此流中的数据读入指定的字符数组中，并返回读取的字符个数。如果已达到流的末尾，则返回-1。
public abstract int read(char[] cbuf,int off,int len)/*[ɔf]离开*/
throws IOException
将此流中的数据读入指定字符数组的某一部分中，并返回读入的字符个数。如果已达到流的末尾，则返回-1。
public int read(CharBuffer target)/*['ta:git]目标*/
throws IOException
将此流中的数据读入指定的字符缓冲区中，并返回读入的字符个数。如果已达到流的末尾，则返回-1。
public boolean ready()/*['redi]就绪*/
throws IOException
判断此流是否已准备好被读取。返回false并不一定会阻塞下一次的读取。
public void reset()/*[ri:'set]重置*/
throws IOException
重置此流。如果已经标记该流，则会在该标记处(或以某种特定的方式)重新定位该流。并不是所有的字符输入流都支持此方法。
public long skip(long n)/*[skip]跳过*/
throws IOException
跳过指定数量的字符，并返回实际跳过的字符数。
③InputStreamReader类
public class InputStreamReader
extends Reader
❶此流是字节流通向字符流的桥梁，它使用指定的字符集解码读取到的字节数据。为了提高此流的执行效率，可以使用其对应的装饰类包装该流。例如，接受键盘录入最常见的写法为：BufferedReader in = newBufferedReader(new InputStreamReader(System.in))；
❷构造方法
public InputStreamReader(InputStream in)
创建一个使用默认字符集，并和指定字节输入流相关联的，输入转换流对象。
public InputStreamReader(InputStream in,Charset cs)
创建一个使用指定字符集，并和指定字节输入流相关联的，输入转换流对象。
public InputStreamReader(InputStream in,CharsetDecoderdec)
/*['tʃa:set]字符集[di:'kəudə]解码器*/
创建一个使用指定的字符集解码器，并和指定字节输入流相关联的，输入转换流对象。
public InputStreamReader(InputStream in,StringcharsetName)
throws UnsupportedEncodingException
/*[ʌnsə'pɔ:tid]不支持的[in'kəudiŋ]编码*/
创建一个使用指定名称的字符集，并和指定字节输入流相关联的，输入转换流对象。
❸成员方法
public void close()
throw IOException
关闭此流，并释放与之相关联的所有资源。
public String getEncoding()
返回此流所使用的字符集的名称。
public int read()
throws IOException
读取此流中的单个字符，并返回其Unicode码的int值。如果已达到流的末尾，则返回-1。
public int read(char[] cbuf,int offset,int length)/*['ɔfset]抵消*/
throws IOException
将此流中的数据读入指定字符数组的某一部分中，并返回读入的字符个数。如果已达到流的末尾，则返回-1。
public boolean ready()
throws IOException
判断此流是否已准备好被读取。返回false并不一定会阻塞下一次的读取。
④FileReader/*[fail]文件*/类
public class FileReader
extends InputStreamReader
❶此流是输入转换流的一种固化的简便形式，它固化了字符集为默认的字符集。并且可以直接读取文件，而不需要字节流的配合。
❷构造方法
public FileReader(File file)
throws FileNotFoundException
创建一个文件读取流，并指定读取源的路径。
public FileReader(FileDescriptor fd)/*[di'skriptə]描述符号*/
创建一个文件读取流，并指定读取源的FileDescriptor。
public FileReader(String fileName)
throws FileNotFoundException
创建一个文件读取流，并指定读取源的文件名。
⑤File类
public class File
extends Object
implements Serializable,Comparable<File>
❶此类用于描述文件或目录的路径。
绝对路径可以直接锁定目标文件或目录，相对路径则需要一个坐标。java.io包中的类，一般根据当前用户目录来解析相对路径。
File类的实例是不可变的。也就是说，一旦被创建，File对象所表示的抽象路径将永不改变。
此类将文件或文件夹封装成了对象，方便于对文件和文件夹属性信息的操作。
❷成员变量
public static final String pathSeparator/*['sepəreitə]分隔符*/
路径分隔符。此字符串中只包含一个字符，即pathSeparatorChar。
public static final char pathSeparatorChar
路径分隔符。用于标识各个路径(根目录)，只存在于绝对路径的起始处。
public static final String separator
名称分隔符。此字符串中只包含一个字符，即separatorChar。
public static final char separatorChar
名称分隔符。用于分隔路径中的各个目录与文件。
❸构造方法
public File(File parent,String child)/*['peərənt]父母[tʃaild]孩子*/
根据parent路径和child路径字符串，创建一个新的File实例。如果parent为null，则同单参数构造函数。
public File(String pathname)
根据指定的字符串所表示的路径，创建一个新的File实例。
public File(String parent,String child)
根据parent路径字符串和child路径字符串，创建一个新的File实例。如果parent为null，则同单参数构造函数。
public File(URI uri)
根据指定的file：URI所转换的路径，创建一个新的File实例。uri：表示一个统一资源标示符的引用。
❹成员方法(部分)
public boolean canExecute()/*['eksikju:t]执行*/
测试应用程序是否可以执行，此路径所表示的文件。
public boolean canRead()
测试应用程序是否可以读取，此路径所表示的文件。
public boolean canWrite()
测试应用程序是否可以修改，此路径所表示的文件。
public int compareTo(File anotherFile)
按字符顺序比较两个路径。此方法定义的顺序取决于底层系统。UNIX系统区分大小写，Windows不区分大小写。
public boolean createNewFile()/*[kri:'eit]创建*/
throws IOException
创建一个具有此路径的空文件。当且仅当依照此路径可以创建一个文件，并且没有旧的同名文件时，才可以创建成功。存在拥有此路径的文件，则不创建。
public static File createTempFile(String prefix,Stringsuffix)
throws IOException
在默认的临时文件目录中，创建一个空的临时文件，使用指定的前缀和后缀生成文件的路径。底层调用的是createTempFile(prefix,suffix,null)。
public static File createTempFile(String prefix,Stringsuffix,File directory)
throws IOException
/*[temp]临时文件夹[di'rektəri]目录['pri:fiks]前缀['sʌfiks]后缀*/
在指定的文件目录中，创建一个空的临时文件。Prefix至少包含三个字符；suffix可以为null，此时使用“.tmp”作后缀。
public boolean delete()
删除此对象所表示的文件或目录。如果此对象表示一个目录，则该目录必须为空时才可以被删除。当文件被其它程序使用时，此方法不能删除它，这时可以使用deleteOnExit方法。
public void deleteOnExit()
在虚拟机终止时，请求删除此对象所表示的文件或目录，此方法必将删除成功。一旦使用后，此请求不能被取消。
public boolean exists()/*[ig'zists]存在*/
测试此对象表示的文件或目录是否存在。
public File getAbsoluteFile()/*['æbsəlu:t]绝对的*/
返回此对象所对应的绝对路径的File实例。
public String getAbsolutePath()
返回此对象所对应的绝对路径的，字符串表示形式。
public String getName()
返回此对象所表示的文件或目录的名称。
public String getParent()
返回此对象父目录路径的字符串表示形式。如果没有指定父目录，则返回null。
public String getPath()
返回此对象的字符串表示形式。
public boolean isAbsolute()
判断此对象表示的是否是一个绝对路径。
public boolean isDirectory()
判断此对象表示的是否是一个目录。要先判断该对象是否存在。
public boolean isFile()
判断此对象表示的是否是一个标准文件。要先判断该对象是否存在。
public boolean isHidden()/*['hidn]隐藏的*/
判断此对象表示的是否是一个隐藏文件。要先判断该对象是否存在。
public long lastModified()/*['mɔdifaid]修改*/
返回此对象所表示的文件，最后一次被修改的时间。该时间是相对于标准基准时间的毫秒数 。
public long length()
返回此对象所表示的文件的长度，以字节为单位。如果此对象表示的是目录，返回值是不确定的。
public String[] list()/*[list]列出*/
返回一个字符串数组，其中的字符串表示该路径下的所有文件或目录的名称，其中包含隐藏文件。此方法并不保证元素存入的顺序。此时的路径对象，必须表示一个已存在的目录。如果该对象不存在或者表示的是一个文件，则返回null。
public String[] list(FilenameFilter filter)/*['filtə]过滤器*/
返回一个字符串数组，其中的字符串表示该路径下的，满足指定过滤器的文件或目录的名称。此方法并不保证元素存入的顺序。文件过滤器可以为null，此时返回其所包含的所有对象的名称。此时的路径对象，必须表示一个已存在的目录。如果该对象不存在或者表示的是一个文件，则返回null。
public File[] listFiles()
返回一个文件路径数组，其中的元素都是隶属于该目录的文件或目录。此方法并不保证元素存入的顺序。此时的路径对象，必须表示一个已存在的目录。如果该对象不存在或者表示的是一个文件，则返回null。
public File[] listFiles(FileFilter filter)
返回一个文件路径数组，其中的元素都是隶属于该目录的，并且同时满足指定过滤器的文件或目录。此方法并不保证元素存入的顺序。文件过滤器可以为null，此时返回其所包含的所有对象。此时的路径对象，必须表示一个已存在的目录。如果该对象不存在或者表示的是一个文件，则返回null。
public static File[] listRoots()/*[ru:ts]根目录*/
返回一个文件路径数组，其中包含了所有可用的系统根目录(有效盘符)。
public boolean mkdir()
创建一个拥有此路径的目录，只能创建一级目录。规则同创建文件。
public boolean mkdirs()
创建一个拥有此路径的目录，可以创建多级目录。规则同创建文件。
public boolean renameTo(File dest)
重命名此对象所表示的文件或文件夹。相当于将该对象剪切，但对于目标文件对象，不允许出现同名文件或文件夹，否则会剪切失败。调用此方法后，调用者依然表示原来的路径。
public String toString()
返回此对象的字符串表示形式。
public URI toURI()
返回一个表示此对象的file：URI。
❺FileFilter接口
public interface FileFilter
过滤器，用于对目录中的文件路径进行过滤。
public boolean accept(File pathname)/*[ə'ksept]容纳*/
判断指定的路径，是否隶属于另一个路径(该过滤器的使用者)。此方法需要被覆盖。
❻FilenameFilter接口
pubic interface FilenameFilter
过滤器，用于对目录中的文件名进行过滤。
public boolean accept(File dir,String name)
判断指定名称的文件，是否包含在指定的目录中。此方法需要被覆盖。
⑥Writer/*['raitə]写入*/类
public abstract class Writer
extends Object
implements Appendable,Closeable,Flushable
成员方法
public Writer append(char c)/*[ə'pend]添加*/
throws IOException
将指定字符添加到此流中。
public Writer append(CharSequence csq)
throws IOException
将指定字符序列添加到此流中。
public Writer append(CharSequence csq,int start,int end)
throws IOException
将指定的字符子序列添加到此流中。
public abstract void close()
throws IOException
先刷新此流，再关闭它，并释放与之相关联的所有资源。
public abstract void flush()/*[flʌʃ]清空*/
throws IOException
刷新此流的缓冲区。将该流缓冲区中的内容，传递给目标对象。
public void write(char[] cbuf)
throws IOException
将指定的字符数组，写入此流中。
public abstract void write(char[] cbuf,int off,int len)
throws IOException
将指定数组的子数组，写入此流中。
public void write(int c)
throws IOException
将单个字符写入此流中。只写入该参数的最低16位。
public void write(String str)
throws IOException
将指定的字符串，写入此流中。
public void write(String str,int off,int len)
throws IOException
将指定字符串的子串，写入此流中。
⑦OutputStreamWriter类
public class OutputStreamWriter
extends Writer
❶此流是字符流通向字节流的桥梁。它使用指定的字符集，将此流中的字符编码为字节数据。为了提高此流的执行效率，可以使用其对应的装饰类包装该流。
❷构造方法
public OutputStreamWriter(OutputStream out)
创建一个和指定字节输出流相关联的输出转换流，此流使用默认的字符集，编码该流中的字符。
public OutputStreamWriter(OutputStream out,Charset cs)
创建一个和指定字节输出流相关联的输出转换流，此流使用指定的字符集，编码该流中的字符。
public OutputStreamWriter(OutputStream out,CharsetEncodercse)
创建一个和指定字节输出流相关联的输出转换流，此流使用指定的字符集编码器，编码该流中的字符。
public OutputStreamWriter(OutputStream out,StringcharsetName)
创建一个和指定字节输出流相关联的输出转换流，此流使用指定名称的字符集，编码该流中的字符。
❸成员方法
public void close()
throws IOException
先刷新此流的缓冲区，再关闭它，并释放与之相关联的所有资源。
public void flush()
throws IOException
刷新此流的缓冲区。将其缓冲区中的内容，传递给目标对象。
pubic String getEncoding()
返回此流使用的字符集名称。如果该字符集有历史名称，则返回该名称；否则返回该字符集的规范化名称。
public void writer(char[] cbuf,int off,int length)
throws IOException
将指定字符数组的子数组，写入此流中。
public void writer(int c)
throws IOException
将指定的字符，写入此流中。只写入该参数的最低16位。
public void writer(String str,int off,int len)
将指定字符串的子串，写入此流中。
⑧FileWriter类
public class FileWriter
extends OutputStreamWriter
❶此流是输出转换流的固化简便形式，它固化了字符集为默认的字符集。并且可以直接操作文件，而不需要字节流的配合。
❷构造方法
public FileWriter(File file)
throws IOException
创建一个和指定路径文件相关联的，文件写入流。若有重名的文件，则将其覆盖。
public FileWriter(File file,boolean append)
throws IOException
创建一个和指定路径文件相关联的，文件写入流。若有重名的文件，当boolean型参数为true时，则将此流中的内容写入该文件的末尾处(续写)。
public FileWriter(FileDescriptor fd)/*[di'skriptə]描述符号*/
创建一个文件写入流，并与指定的FileDescriptor相关联。
public FileWriter(String fileName)
throws IOException
创建一个和指定名称文件相关联的，文件写入流。若有重名的文件，则将其覆盖。
public FileWriter(String fileName,boolean append)
throws IOException
创建一个和指定名称文件相关联的，文件写入流。若有重名的文件，当boolean型的参数为true时，则将此流中的内容写入该文件的末尾处(续写)。
❸文本换行
当输入的文本需要换行操作时，Windows中用的是\r\n，Linux中用的是\n。
⑨BufferedReader/*['bʌfəd]缓冲的*/类
public class BufferedReader
extends Reader
❶此流可以提高字符读取流的读取效率。
❷构造方法
public BufferedReader(Reader in)
创建一个和指定的字符读取流相关联，并使用默认大小缓冲区的，字符缓冲输入流。
public BufferedReader(Reader in,int size)
创建一个和指定的字符读取流相关联，并使用指定大小缓冲区的，字符缓冲输入流。
❸成员方法
public void close()
throws IOException
关闭此流，并释放与之关联的所有资源。此处关闭的是字符读取流。
public void mark(int readAheadLimit)
throws IOException
/*[ma:k]标记[ə'hed]前面的['limit]限定*/
标记流中的当前位置。
readAheadLimit：在仍保留该标记的情况下，对可读字符数量的限制。当限制值大于缓冲区大小时，会导致重新分配一个大于等于该限制值的缓冲区。
public boolean markSupported()
判断此流是否支持mark方法(此流一定支持)。
public int read()
throws IOException
读取此流中的单个字符，并返回其Unicode码的int值。如果已达到流的末尾，则返回-1。
public int read(char[] cbuf,int off,int length)
throws IOException
将此流中的数据读入指定字符数组的某一部分中，并返回读入的字符个数。如果已达到流的末尾，则返回-1。
public String readLine()
throws IOException
将一行文本读入此流中，并返回该文本内容的字符串表示形式，不包含任何行终止符。如果已达到流的末尾，则返回null。本方法通过行终止符(“\r\n”,“\n”)，判断一行文本的结束。
public boolean read()
throws IOException
判断此流是否已准备好被读取。返回false并不一定会阻塞下一次的读取。
public void reset()
throws IOException
将此流重置回最新标记处。
public long skip(long n)
throws IOException
跳过指定数量的字符，并返回实际跳过的字符数。
⑩BufferedWriter类
❶此流可以提高字符写入流的写入效率。
❷构造方法
public BufferedWriter(Writer out)
创建一个和指定字符输出流相关联，并使用默认大小缓冲区的，字符缓冲输出流。
public BufferedWriter(Writer out,int size)
创建一个和指定字符输出流相关联，并使用指定大小缓冲区的，字符缓冲输出流。
❸成员方法
public void close()
throws IOException
先刷新此流，再关闭它，并释放与之相关联的所有资源。
public void flush()
throws IOException
刷新此流的缓冲区。将其中的字符数据，传递给目标对象。
public void newLine()
throws IOException
写入一个行分隔符，此方法可以实现跨平台。(\r\n,\n)
public void write(char[] cbuf,int off,int length)
throws IOException
将指定字符数组中的子数组，写入此流中。
public void write(int c)
throws IOException
将单个字符写入此流中，只写入该参数的最低16位。
public void write(String s,int off,int length)
throws IOException
将指定字符串的子串，写入此流中。
⑪LineNumberReader类
public class LineNumberReader
extends BufferedReader
❶此流可以实现跟踪文本数据的行号，并对该行号进行其重新设置和获取。
❷构造方法
public LineNumberReader(Reader in)
创建一个和指定字符输入流相关联，并使用默认大小缓冲区的，可以跟踪行号的字符缓冲输入流。
public LineNumberReader(Reader in,int size)
创建一个和指定字符输入流相关联，并使用指定大小缓冲区的，可以跟踪行号的字符缓冲输入流。
❸成员方法
public int getLineNumber()
返回当前行的行号。
public void mark(int readAheadLimit)
throws IOException
标记此流中的当前位置。
public int read()
throws IOException
将单个字符读入此流中，并返回该字符Unicode码的int值，如果已达到流的末尾，则返回-1。
public int read(char[] cbuf,int off,int length)
throws IOException
将此流中的数据读入指定字符数组的某一部分中，并返回读入的字符个数。如果已达到流的末尾，则返回-1。
public String readLine()
throws IOException
将一行文本读入此流中，并返回该文本内容的字符串表示形式，不包含任何行终止符。如果已达到流的末尾，则返回null。本方法通过行终止符(“\r\n”,“\n”)，判断一行文本的结束。为了返回该行文本的行号，此方法内部设置了一个计数器。
public void reset()
throws IOException
将此流重置回最新标记处。
public void setLineNumber(int lineNumber)
设置当前行号(基准行号)。未设置时，当前行号为0。
public long skip(long n)
throws IOException
跳过指定数量的字符，并返回实际跳过的字符数量。
⑫InputStream类
public abstract class InputStream
extends Object
implements Closeable
成员方法
public int available()/*[ə'veiləbl]有效的*/
throws IOException
返回可以不受阻塞的，从此输入流中可以读取或跳过的估计字节数。如果已达到流的末尾，则返回0。
public void close()
throws IOException
关闭此流，并释放与其相关联的所有资源。
public void mark(int readlimit)
标记此流中的当前位置。此流的该方法不执行任何操作。
public boolean markSupported()
判断此流是否支持mark和reset方法。(此流不支持)
public abstract int read()
throws IOException
将一个字节读入此流中，并返回该字节的int值。通过int&255，可以取到该值。如果已达到流的末尾，则返回-1。
public int read(byte[] b)
throws IOException
将此流中的数据读入指定的字节数组中，并返回读入的字节个数。如果已达到流的末尾，则返回-1。
public int read(byte[] b,int off,int length)
throws IOException
将此流中的数据读入指定字节数组的某一部分中，并返回读入的字节个数。如果已达到流的末尾，则返回-1。
public void reset()
throws IOException
将此流重置回最新标记处。
public long skip()
throws IOException
跳过指定的字节数，并返回实际跳过的字节数。
⑬OutputStream类
public abstract class OutputStream
extends Object
implements Closeable,Flushable
成员方法
public void close()
throws IOException
先刷新此流，再关闭它，并释放与其相关联的所有资源。
public void flush()
throws IOException
刷新此流。将其缓冲区中的内容，传递给目标对象。
public void write(byte[] b)
throws IOException
将指定的字节数组，写入此流中。
public void write(byte[] b,int off,int length)
throws IOException
将指定字节数组的子数组，写入此流中。
public abstract void write(int b)
throws IOException
将指定的参数写入此流中。只写入该参数的最低8位。
⑭FileInputStream类
public class FileInputStream
extends InputStream
❶构造方法
public FileInputStream(File file)
throws FileNotFoundException
创建一个字节文件读取流，并指定读取源的路径。
public FileInputStream(FileDescriptor fdObj)/*[di'skriptə]描述符号*/
创建一个字节文件读取流，并指定读取源的FileDescriptor。
public FileInputStream(String name)
创建一个字节文件读取流，并指定读取源的文件名。
❷成员方法
public int available()/*[ə'veiləbl]有效的*/
throws IOException
返回可以不受阻塞的，从此输入流中可以读取或跳过的估计字节数。如果已达到流的末尾，则返回0。
public void close()
throws IOException
关闭此流，并释放与其相关联的所有资源。
public FileChannel getChannel()/*['tʃænl]通道*/
返回与此流相关的，文件通道对象。
public final FileDescriptor getFD()
throws IOException
返回与此流关联的，文件描述符对象。
public int read()
throws IOException
将一个字节读入此流中，并返回该字节的int值。通过int&255，可以取到该值。如果已达到流的末尾，则返回-1。
public int read(byte[] b)
throws IOException
将此流中的数据读入指定的字节数组中，并返回读入的字节数。如果已达到流的末尾，则返回-1。
public int read(byte[] b,int off,int length)
throws IOException
将此流中的数据读入指定数组的某一部分中，并返回读入的字节数。如果已达到流的末尾，则返回-1。
public long skip(long n)
throws IOException
跳过指定数量的字节，并返回实际跳过的字节数。
⑮FileOutputStream类
public class FileOutputStream
extends OutputStream
❶构造方法
public FileOutputStream(File file)
throws FileNotFoundExcepton
创建一个和指定路径文件相关联的，字节文件输出流。若有同名文件存在，将会被其覆盖。
public FileOutputStream(File file,boolean append)
throws FileNotFoundException
创建一个和指定路径文件相关联的，字节文件输出流。若有同名文件存在，当boolean型参数为true时，将会在该文件的末尾处续写。
public FileOutputStream(FileDescriptor fdObj)/*[di'skriptə]描述符号*/
创建一个字节文件输出流，并指定输出目的地的FileDescriptor。
public FileOutputStream(String name)
throws FileNotFoundException
创建一个和指定名称文件相关联的，字节文件输出流。若有同名文件存在，将会被其覆盖。
public FileOutputStream(String name,boolean append)
throws FileNotFoundException
创建一个和指定名称文件相关联的，字节文件输出流。若有同名文件存在，当boolean型参数为true时，将会在其末尾处续写。
❷成员方法
public void close()
throws IOException
先刷新此流，再关闭它，并释放与其相关联的所有资源。
public FileChannel getChannel()
返回与此流相关的文件通道对象。
public final FileDescriptor getFD()
throws IOException
返回与此流相关的文件描述符对象。
public void write(byte[] b)
throws IOException
将指定的字节数组，写入此流中。
public void write(byte[] b,int off,int length)
throws IOException
将指定字节数组的子数组，写入此流中。
public void write(int b)
将指定的参数写入此流中，只写入该参数的最低8位。
⑯BufferedInputStream类
public class BufferedInputStream
extends FilterInputStream
❶构造方法
public BufferedInputStream(InputStream in)
构造一个和指定字节输入流相关联，并使用默认大小缓冲区数组的，字节缓冲输入流。
public BufferedInputStream(InputStream in,int size)
构造一个和指定字节输入流相关联，并使用指定大小缓冲区数组的，字节缓冲输入流。
❷成员方法
public int available()/*[ə'veiləbl]有效的*/
throws IOException
返回可以不受阻塞的，从此流中读取或跳过的估计字节数。如果已达到流的末尾，则返回0。
public void close()
throws IOException
关闭此流，并释放与其相关联的所有资源。
public void mark(int readlimit)
在此流中标记当前的位置。
public boolean markSupported()
判断此流是否支持mark方法和reset方法。
public int read()
throws IOException
将一个字节读入此流中，并返回该字节的int值。通过int&255，可以取到该值。如果已达到流的末尾，则返回-1。
public int read(byte[] b,int off,int length)
throws IOException
将此流中的内容读入指定字节数组的某一位置中，并返回读入的字节数。如果已达到流的末尾，则返回-1。
public void reset()
throws IOException
将此流重置回最新标记处。
public long skip(long n)
throws IOException
跳过指定的字节数，并返回实际跳过的字节数量。
(17)BufferedOutputStream类
public class BufferedOutputStream
extends FilterOutputStream
❶构造方法
public BufferedOutputStream(OutputStream out)
创建一个和指定字节输出流相关联，并使用默认大小缓冲区的，字节缓冲输出流。
public BufferedOutputStream(OutputStream out,int size)
创建一个和指定字节输出流相关联，并使用指定大小缓冲区的，字节缓冲输出流。
❷成员方法
public void flush()
throws IOException
刷新此流的缓冲区。将其缓冲区中的字节，传递给底层的输出流。
public void write(byte[] b,int off,int length)
throws IOException
将指定字节数组的子数组，写入此流中。
public void write(int b)
throws IOException
将指定的字节写入此流中。只写入该参数的最低8位。
(18)Properties/*['prɔpətiz]性能参数*/类
public class Properties
extends Hashtable<Object,Object>
❶此集合是集合与IO相结合的集合容器，适用于操作以键-值对形式为存储内容的配置文件。被操作的文件需要有固定的格式，通常为键=值。
此列表中的每个键和值都是一个字符串。此列表没有泛型。
❷构造方法
public Properties()
构造一个无默认值的空属性列表。
public Properties(Properties defaults)
构造一个带有指定默认值的，空属性列表。
❸成员方法
public String getProperty(String key)
用指定的键，在此属性列表中搜索其对应的属性。返回该键的属性，若没有则返回null。
public String getProperty(String key,String defaultValue)
用指定的键，在此属性列表中搜索其对应的属性。返回该键的属性，若没有则返回第二个参数defaultValue。
public void list(PrintStream out)
将此属性列表，输出到指定的字节输出流(字节打印流)。
public void list(PrintWriter out)
将此属性列表，输出到指定的字符输出流(字符打印流)。
public void load(InputStream inStream)
throws IOException
从指定字节输入流中，读取与其相关联的文件内容(键-值对形式)。此方法返回后，指定流仍保持打开状态。
public void load(Reader reader)
throws IOException
按读取一行的方式，从指定字符输入流中，读取与其相关联的文件内容(键-值对形式)。此方法返回后，指定流仍保持打开状态。
public void loadFromXML(InputStream in)
throws IOException,InvalidPropertiesFormatException
/*[in'vælid]无效的['prɔpətiz]性能参数['fɔ:mæt]格式*/
从指定的字节输入流中，读取与其相关联的XML文件中的内容。此方法返回后，指定的流已关闭。
public Enumeration<?> propertyNames()
返回此属性列表中所有键的枚举。
public Object setProperty(String key,String value)
向此属性列表中设置新的键-值对，并返回旧键的值，若没有则返回null。此方法调用的是Hashtable中的put方法。此方法既可以实现添加的功能，也可以实现修改的功能。
public void store(OutputStream out,String comments)
throws IOException
/*[stɔ:]存储['kɔments]注释*/
以适合重新加载的格式，将此属性列表中的内容，写入指定的字节输出流。注释信息表示该文件内容的标题，可以为null。此方法同时会加载写入的时间。此方法返回后，指定流仍保持打开状态。
public void store(Writer writer,String comments)
throws IOException
以适合重新加载的格式，将此属性列表中的内容，写入指定的字符输出流。注释信息表示该文件内容的标题，可以为null。此方法返回后，指定流仍保持打开状态。
public void storeToXML(OutputStream out,String comment)
throws IOException
以适当的格式，导出一个表示此属性列表中的内容的XML文档。此方法调用的是storeToXML(out,comment,“UTF-8”)。此方法返回后，指定流仍保持打开状态。
public void storeToXML(OutputStream out,Stringcomment,String encoding)
throws IOException
以适当的格式，使用指定名称的字符集，导出一个表示此属性列表中的内容的XML文档。此方法返回后，指定流仍保持打开状态。
public Set<String> stringPropertyNames()
返回此属性列表中的键的set集合。
(19)PrintStream类
public class PrintStream
extends FilterOutputStream
implements Appendable,Closeable
❶此流可以将基本数据类型的数据原样打出。
❷构造方法
public PrintStream(File file)
throws FileNotFoundException
创建一个和指定路径文件相关联,并使用默认字符集的，字节打印流。此流不会自动刷新。若有旧的同名文件，将会被其覆盖。
public PrintStream(File file,String charsetName)
throws FileNotFoundException,UnsupportedEncodingException
创建一个和指定路径文件相关联,并使用指定名称字符集的，字节打印流。此流不会自动刷新。若有旧的同名文件，将会被其覆盖。
public PrintStream(OutputStream out)
创建一个和指定字节输出流相关联,并使用默认字符集的，字节打印流。此流不会自动刷新。
public PrintStream(OutputStream out,boolean autoFlush)
创建一个和指定字节输出流相关联,并使用默认字符集的，字节打印流。当boolean型参数为true时，此流可以自动刷新。
public PrintStream(OutputStream out,booleanautoFlush,String encoding)
创建一个和指定字节输出流相关联,并使用指定名称字符集的，字节打印流。当boolean型参数为true时，此流可以自动刷新。
public PrintStream(String fileName)
throws FileNotFoundException
创建一个和指定名称文件相关联，并使用默认字符集的，字节打印流。此流不会自动刷新。
public PrintStream(String fileName,String charsetName)
throws FileNotFoundException,UnsupportedEncodingException
创建一个和指定名称文件相关联，并使用指定名称字符集的，字节打印流。此流不会自动刷新。
❸成员方法
public PrintStream append(char c)
将指定的字符添加到此流中，并返回该流本身。
public PrintStream append(CharSequence csq)
将指定的字符序列添加到此流中，并返回该流本身。若指定的字符序列为null，则添加字符串“null”。
public PrintStream append(CharSequence csq,int start,intend)
将指定字符序列的子序列添加到此打印流中，并返回该流本身。若指定的字符序列为null，并且没有发生角标越界异常，则添加字符串“null”。
public boolean checkError()/*[tʃek]核对['erə]错误*/
刷新此流，并检查其错误状态。仅当此流遇到IOException并且不是InterruptedIOException，或者已调用setError时，返回true。
public void close()
先刷新此流，再关闭它，并释放与其相关联的所有资源。
public void flush()
刷新此流的缓冲区。将其流缓冲区中的字节数据，传递给底层输出流。
public PrintStream format(Locale l,Stringformat,Object... args)
使用指定格式字符串和参数，将格式化字符串写入此流中。
public PrintStream format(String format,Object... args)
使用指定格式字符串和参数，将格式化字符串写入此流中。
public void print(X x)
X：boolean,char,char[],double,float,int,long,Object,String
打印指定的参数。
public PrintStream printf(Locale l,Stringformat,Object... args)
使用指定格式字符串和参数，将格式化字符串写入此流中。
public PrintStream printf(String format,Object... args)
使用指定格式字符串和参数，将格式化字符串写入此流中。
public void println()
打印一个换行符。
public void println(X x)
X：boolean,char,char[],double,float,int,long,Object,String
打印指定的参数，并换行。
public void write(byte[] buf,int off,int length)
将指定字节数组的子数组，写入此流中。
public void write(int b)
将指定的参数写入此流中，只写入该参数的最低8位。
(20)PrintWriter类
public class PrintWriter
extends Writer
❶成员方法
public PrintWriter(File file)
throws FileNotFoundException
创建一个和指定路径文件相关联，并使用默认字符集的，字符打印流。此流不会自动刷新。
public PrintWriter(File file,String charsetName)
throws FileNotFoundException,UnsupportedEncodingException
创建一个和指定路径文件相关联，并使用指定名称字符集的，字符打印流。此流不会自动刷新。
public PrintWriter(OutputStream out)
创建一个和指定字节输出流相关联，并使用默认字符集的，字符打印流。此流不会自动刷新。
public PrintWriter(OutputStream out,boolean autoFlush)
创建一个和指定字节输出流相关联，并使用默认字符集的，字符打印流。当boolean型参数为true时，此流可以自动刷新。
public PrintWriter(String fileName)
throws FileNotFoundException
创建一个和指定名称文件相关联，并使用默认字符集的，字符打印流。此流不会自动刷新。
public PrintWriter(String fileName,String charsetName)
throws FileNotFoundException,UnsupportedEncodingException
创建一个和指定名称文件相关联，并使用指定名称字符集的，字符打印流。此流不会自动刷新。
public PrintWriter(Writer out)
创建一个和指定字符写入流相关联，并使用默认字符集的，字符打印流。此流不会自动刷新。
public PrintWriter(Writer out,boolean autoFlush)
创建一个和指定字符写入流相关联，并使用默认字符集的，字符打印流。当boolean型参数为true时，此流可以自动刷新。
❷成员方法
public PrintWriter append(char c)
将指定的字符添加到此流中，并返回该流本身。
public PrintWriter append(CharSequence csq)
将指定的字符序列添加到此流中，并返回该流本身。当参数为null时，则添加字符串“null”。
public PrintWriter append(CharSequence csq,int start,intend)
将指定字符序列的子序列添加到此流中，并返回该流本身。当参数为null，并且没有发生角标越界异常时，则添加字符串“null”。
public boolean checkError()
如果此流没有关闭，则刷新该流并检查其错误状态。如果此流在底层输出流上或在格式转换过程中发生错误，则返回true。
public void close()
先刷新此流，再关闭它，并释放与其相关联的所有资源。
public void flush()
刷新此流的缓冲区，将其缓冲区中的字符数据，传递给目标对象。
public PrintWriter format(Locale l,Stringformat,Object... args)
使用指定格式字符串和参数，将一个格式化字符串写入此writer中。
public PrintWriter format(String format,Object... args)
使用指定格式字符串和参数，将一个格式化字符串写入此writer中。
public void print(X x)
X：boolean,char,char[],double,float,int,long,Object,String
打印指定的参数。
public PrintWriter printf(Locale l,Stringformat,Object... args)
使用指定格式字符串和参数，将格式化的字符串写入此writer中。
public PrintWriter printf(Locale l,Stringformat,Object... args)
使用指定格式字符串和参数，将格式化的字符串写入此writer中。
public void println()
打印换行。
public void println(X x)
X：boolean,char,char[],double,float,int,long,Object,String
打印指定的参数，并换行。
public void writer(char[] buf)
将指定的字符数组，写入此流中。
public void write(char[] buf,int off,int length)
将指定字符数组的子数组，写入此流中。
public void write(int c)
将指定参数写入此流中，只写入该参数的最低16位。
public void write(String s)
将指定的字符串写入此流中。
public void write(String s,int off,int length)
将指定字符串的子串写入此流中。
(21)SequenceInputStream类
public class SequenceInputStream
extends InputStream
❶此流可以将多个输入流合并为一个输入流，方便于对文件的合并操作。
❷构造方法
public SequenceInputStream(Enumeration<? extendsInputStream> e)
构造一个序列流对象，按顺序读取指定枚举中所包含的输入流。
public SequenceInputStream(InputStream s1,InputStream s2)
构造一个序列流对象，按顺序读取两个参数，先读s1，再度s2。
❸成员方法
public int available()/*[ə'veiləbl]有效的*/
throws IOException
返回可以不受阻塞的，从当前底层输入流读取或跳过的字节数的估计值。
public void close()
throws IOException
先刷新此流，再关闭它，并释放与之相关联的所有资源。
public int read()
throws IOException
将一个字节读入此流中，并返回该字节的int值。通过int&255，可以取到该值。
public int read(byte[] b,int off,int length)
throws IOException
将此流中的字节数据，读入指定字节数组的某一部分中。并返回读入的字节数。如果已达到此流的末尾，则返回0。
❹枚举的构造方式
如果要使用枚举的构造方式，可以使用Vector集合存储流对象。但是Vector集合的效率比较低，这时可以使用Set集合来存储流对象，然后用迭代器取出其中的元素。再使用匿名内部类的方式，创建一个枚举对象，并覆盖其抽象的两个方法，可以使用用迭代器的方法来实现。
❺切割流
将一个文件切割为多个文件，可以通过设置计数器的方式来实现。首先创建一个读取流与该文件相关联；然后将读取到的内容通过输出流，写入到其它文件中。在输出的时候，通过对计数器的判断，可以创建多个输出流，从而实现切割的目的。
(22)ObjectInputStream类
public class ObjectInputStream
extends InputStream
implements ObjectInput,ObjectStreamConstains
❶此流是可以操作对象的字节输入流。用于反序列化文件中的对象信息，并将其读取出来。
❷构造方法
public ObjectInputStream(InputStream in)
throws IOException
创建一个和指定字节输入流相关联的，字节对象输入流。
❸成员方法(部分)
public final Object readObject()
throws IOException,ClassNotFoundException
将一个对象读入此流中，并返回它。
(23)ObjectOutputStream类
public class ObjectOutputStream
extends OutputStream
implements ObjectOutput,ObjectStreamConstains
❶此流是可以操作对象的字节输出流，能够将对象信息写入文件中，从而实现对象的持久化。被操作的对象必须是可序列化的，对象所属的类需要实现Serializable接口。
❷构造方法
public ObjectOutputStream(OutputStream out)
throws IOException
创建一个指定字节输出流相关联的，字节对象输出流。
❸成员方法(部分)
public finalvoid writeObject(Object obj)
throws IOException
将指定的对象，写入此流中。
(24)Serializable接口
public interface Serializable
❶通过实现此接口，可以实现序列化的功能。
❷没有方法的接口，一般被称为标记接口。只是用于给类做一个标记。
❸序列化运行时，通过使用一个serialVersionUID的版本号，与每一个可序列化的类相关联。该版本号在反序列化过程中，用于验证解析该对象的类是否与此对象相符。被序列化的类可以通过定义ANY-ACCESS-MODIFIER staticfinal long serialVersionUID，来显式定义本类的序列号。默认情况下，一个类的序列号，是根据其各个非静态成员变量，算出来的一个long型值。
显式定义序列号的好处是，当该类被改变之后，依然可以解析之前被创建的旧对象。
/*['siəriəl]序列号['və:ʃn]版本['ækses]访问['mɔdifaiə]修饰符*/
❹关键字transient
对象的序列化，只能够序列化对象的非静态成员变量(即堆内存中的数据)。如果其中的某些变量不需要被序列化，则可以用transient修饰。
❺对象被序列化之后，可以被存入文件的只是其被序列化的内容，非序列化的内容只能够存在于内存中。一般存储序列化对象的文件，以.object做后缀名。存储序列化对象的文件，没有打开的意义，都是一些乱码。
(25)PipedInputStream/*[paipt]管道的*/类
public class PipedInputStream
extends InputStream
❶管道流是IO与多线程的结合。管道输入流只能与管道输出流相连，两个流必须由两个线程分别操作，只有这样才能够实现管道连接的功能。
如果输入流中没有数据，输出流就要等待而不能写入数据，由单线程操作将会造成死锁。
一个管道输入流只能与一个管道输出流相关联，反之亦然。
管道流之间的连接，既可以由输入流来完成，也可以由输出流来完成。
❷成员方法
public PipedInputStream()
创建一个使用默认大小管道缓冲区的，尚未连接的字节管道输入流。在使用此流之前，必须将其连接到字节管道输出流。
public PipedInputStream(int pipeSize)/*[paip]管道*/
创建一个使用指定大小管道缓冲区的，尚未连接的字节管道输入流。在使用此流之前，必须将其连接到字节管道输出流。
public PipedInputStream(PipedOutputStream src)
throws IOException
创建一个使用默认大小管道缓冲区，并且和指定的字节管道输出流相关联的，字节管道输入流。
public PipedInputStream(PipedOutputStream src ,intpipeSize)
throws IOException
创建一个使用指定大小管道缓冲区，并且和指定的字节管道输出流相关联的，字节管道输入流。
❸成员方法
public int available()/*[ə'veiləbl]有效的*/
throws IOException
返回可以不受阻塞的，从此流中读取的字节数。
public void close()
throws IOException
关闭此流，并释放与其相关联的所有资源。
public void connect(PipedOutputStream src)/*[kə'nekt]连接*/
throws IOException
将此流与指定的字节管道输出流相关联。
public int read()
throws IOException
将一个字节读入此流中，并返回该字节的int值。如果已达到流的末尾，则返回-1。通过int&255可以取到此值。
public int read(byte[] b,int off,int length)
throws IOException
将此流中的字节数据，读入指定字节数组的某一部分中，并返回读入的字节数。如果已达到流的末尾，则返回-1。
(26)PipedOutputStream类
public class PipedOutputStream
extends OutputStream
❶管道流是IO与多线程的结合。管道输入流只能与管道输出流相连，两个流必须由两个线程分别操作，只有这样才能够实现管道连接的功能。
如果输入流中没有数据，输出流就要等待而不能写入数据，由单线程操作将会造成死锁。
一个管道输入流只能与一个管道输出流相关联，反之亦然。
管道流之间的连接，既可以由输入流来完成，也可以由输出流来完成。
❷构造方法
public PipedOutputStream()
创建一个尚未连接字节管道输入流的，字节管道输出流。
public PipedOutputStream(PipedInputStream snk)
throws IOException
创建一个和指定的字节管道输入流相关联的，字节管道输出流。
❸成员方法
public voidclose()
throws IOException
先刷新此流，再关闭它，并释放与其相关联的所有资源。
public void connect(PipedInputStream snk)/*[kə'nekt]连接*/
throws IOException
将此流与指定的字节管道输入流相关联。
public void flush()
throws IOException
刷新此流的缓冲区，将其中的字节数据，传递给目标对象。
public void write(byte[] b,int off,int length)
throws IOException
将指定数组的子数组，写入此流中。
public void write(int b)
将指定的参数写入此流中。只写入该参数的最低8位。
(27)RandomAccessFile/*['rædəm]随机['ækses]访问*/类
public class RandomAccessFile
extends Object
implements DataOutput,DataInput,Closeable
❶此类的实例可以实现，对文件的随机访问(读取和写入)。
该类的对象中，封装了一个大型的byte数组，并设置了一个文件指针。可以通过对指针的操作，完成对数据的读写。该数组的大小与文件等。
此类的原理：在内部封装了一个字节输入流和一个字节输出流。
❷多线程下载原理
将一个文件分成若干段，每一段由一个线程单独下载，并通过随机访问流写入指定的文件中，从而完成文件的下载操作。
❸构造方法
public RandomAccessFile(File file,String mode)
throws FileNotFoundException
构造一个和指定路径文件相关联，并指定访问模式的，文件随机访问流。
mode：访问模式。“r”只读；“rw”可读写，并可以创建不存在的文件；“rws”可读写，同步更新；“rwd”可读写，简化版同步更新。
public RandomAccessFile(String name,String mode)
throws FileNotFoundException
构造一个和指定名称文件相关联，并指定访问模式的，文件随机访问流。
❹成员方法
public void close()
throws IOException
关闭此流，并释放与其相关联的所有资源。
public final FileChannel getChannel()
获取与此流相关联的，文件通道对象。
public final FileDescriptor getFD()
throws IOException
返回与此流相关联的，不透明的文件描述符对象。
public long getFilePointer()
throws IOException
返回此文件中的当前偏移量(即文件指针的位置)。在该位置处可进行文件的写入或读取操作。
public long length()
throws IOException
返回与此流相关联的文件的长度，按字节为单位。
public int read()
throws IOException
将文件中的一个字节的数据读入此流中，并返回该字节数据的int值，如果已达到文件的末尾则返回-1。可以通过int&255获取到该字节数据的值。
public int read(byte[] b)
throws IOException
将此流中的数据，读入指定的字节数组中，并返回读入的字节数。如果已达到流的末尾，则返回-1。
public int read(byte[] b,int off,int length)
throws IOException
将此流中的数据，读入指定字节数组的某一部分中，并返回读入的字节数。如果已达到流的末尾，则返回-1。
public final boolean readBoolean()
throws IOException
从此流中读取一个字节数据。值0表示false，其它值表示true。如果已达到文件的末尾，则会发生EOFException(文件结束异常)。
public final X readX()
throws IOException
X：Byte,Char,Double,Float,Int,Long,Short
将一个基本数据类型字节数的数据读入此流中，并将其转换为基本数据类型，然后返回它。
public final void readFully(byte[] b)/*['fuli]完全的*/
throws IOException
将此流中的数据，读入指定的字节数组中。
public final void readFully(byte[] b,int off,int length)
throws IOException
将此流中的数据，读入指定字节数组的某一部分中。
public final int readUnsignedByte()/*[ʌn'saind]无符号的*/
throws IOException
将文件中的一个字节数据，以无符号的形式读入此流中，并返回其int值。
public final int readUnsignedShort()
throws IOException
将文件中的两个字节数据，以无符号的形式读入此流中，并返回其int值。
public final String readUTF()
throws IOException
从此流中读取一个字符串，并使用“UTF-8”修改版字符集解码，然后返回该字符串。
public void seek(long pos)/*[si:k]寻找*/
throws IOException
设置此流中的文件指针，从文件起始处开始的偏移量。文件指针的设置并不会改变文件的长度，只有在向文件中写入数据时，才会改变文件的长度。
public void setLength(long newLength)
throws IOException
设置此文件的长度。如果现有文件的长度大于设定的值，则该文件会被截短。
public int skipBytes(int n)
throws IOException
将文件指针跳过指定数量的字节数，并返回实际跳过的字节数。此方法不能跳过文件的结尾。如果n为负数，则不跳过任何字节。
public void write(byte[] b)
throws IOException
将指定的字节数组，写入此流中，并从当前指针处开始。
public void write(byte[] b,int off,int length)
throws IOException
将指定字节数组中的一部分数据，写入此流中，并从当前指针处开始。
public void write(int b)
throws IOException
将指定的参数写入此流中，并从当前指针处开始。只写入该参数的最低8位。
public final void writeBoolean(boolean v)
throws IOException
将指定的参数写入此流中，并从当前指针处开始。true为(byte)1，false为(byte)0。
public final void writeByte(int v)
throws IOException
将指定的参数写入此流中，并从当前指针处开始。只写入该参数的最低8位。
public final void writeBytes(String s)
throws IOException
将指定的字符串写入此流中，并从当前指针处开始。字符串中的每个字符，均按顺序写出，并丢弃其高8位。
public final void writeChar(int v)
throws IOException
按双字节值，将指定参数写入此流中。先写高字节，并从当前指针处开始。只写入该参数的最低16位。
public final void writeChars(String s)
throws IOException
将指定的字符串写入此流中，并从当前指针处开始。
public final void writeDouble(double v)
throws IOException
使用Double类中的doubleToLongBits方法，将该参数转换为一个long型值，然后将得到的long值写入此流中。先写高位字节，从当前指针处开始。
public final void writeFloat(float v)
throws IOException
使用Float类中的floatToIntBits方法，将指定的参数转换为一个int型值，然后将得到的int值写入此流中。先写高位字节。从当前指针处开始。
public final void writeInt(int v)
throws IOException
按四个字节，将指定的参数写入此流中，并从当前指针处开始。
public final void writeLong(long v)
throws IOException
按八个字节，将指定的参数写入此流中，并从当前指针处开始。
public final void writeShort(int v)
throws IOException
按两个字节，将指定的参数写入此流中，并从当前指针处开始。只写入该参数的最低16位。
public final void writeUTF(String str)
throws IOException
使用“UTF-8”修改版字符集，编码指定的字符串，将其写入此流中，并从当前指针处开始。此时的数据，只能用readUTF方法读取并解码。
(28)DataInputStream类
public class DataInputStream
extends FilterInputStream
implements DataInput
❶使用此类读取数据时，一定要和数据写入的顺序是一致的，否则将会发生数据错误。因为此类是按字节数来读取数据的，而基本数据类型的字节数是不一致的。
❷构造方法
public DataInputStream(InputStream in)
创建一个和指定字节输入流相关联的，基本数据类型输入流。
❸成员方法
public final int read(byte[] b)
throws IOException
将此流中的数据读入指定的字节数组中，并返回读入的字节数量。如果已达到流的末尾，则返回-1。
public final int read(byte[] b,int off,int length)
throws IOException
将此流中的数据读入指定字节数组的某一部分中，并返回读入的字节数量。如果已达到流的末尾，则返回-1。
public final X readX()
throws IOException
X：Boolean,Byte,Char,Double,Float,Int,Long,Short
将一定字节数的数据读入此流中，满足其所对应的基本数据类型的字节数。并返回该数值。
public final void readFully(byte[] b)/*['fuli]完全的*/
throws IOException
将此流中的数据,读入指定的字节数组中。
public final void readFully(byte[] b,int off,int length)
throws IOException
将此流中的数据,读入指定字节数组的某一部分中。
public final int readUnsignedByte()/*[ʌn'saind]无符号的*/
throws IOException
将一个字节的数据以无符号的形式读入此流中，并返回其int值。如果已达到流的末尾，则抛出EOFException。
public final int readUnsignedShort()
throws IOException
将两个字节的数据以无符号的形式读入此流中，并返回其int值。如果已达到流的末尾，则抛出EOFException。
public final String readUTF()
throws IOException
将一个字符串读入此流中，使用“UTF-8”修改版字符集解码，并返回其字符串表示形式。
public static final String readUTF(DataInput in)
throws IOException
在指定的数据输入流中，将一个字符串读入此流，使用“UTF-8”修改版字符集解码，并返回其字符串表示形式。
DataInput：一个接口，用于从二进制流中读取字节，并根据Java基本数据类型数据进行重构。同时还可以使用“UTF-8”修改版字符集，重构String。
public final int skipBytes(int n)
throws IOException
跳过指定的字节数，并返回实际跳过的字节数。
(29)DataOutputStream类
public class DataOutputStream
extends FilterOutputStream
implements DataOutput
❶构造方法
public DataOutputStream(OutputStream out)
构造一个和指定字节输出流相关联的，基本数据类型输出流。
❷成员方法
public void flush()
throws IOException
刷新此流，将其缓冲区中的字节数据，传递给目标对象。
public final int size()
返回计数器written的当前值，即到目前为止写入此流中的字节数。
public void write(byte[] b,int off,int length)
throws IOException
将指定字节数组中的子数组，写入此流中。
public void write(int b)
throws IOException
将指定的参数写入此流中。只写入该参数的最低8位。
public final void writeBoolean(boolean v)
throws IOException
将指定的参数写入此流中。true为(byte)1，false为(byte)0。
public final void writeByte(int v)
throws IOException
将指定的参数写入此流中。只写入该参数的最低8位。
public final void writeBytes(String s)
throws IOException
将指定的字符串写入此流中。只是按顺序写入每个字符的低8位。
public final void writeChar(int v)
throws IOException
将指定的参数写入此流中。只写入该参数的最低16位。
public final void writeChars(String s)
throws IOException
将指定的字符串，写入此流中。
public final void writeDouble(double v)
throws IOException
使用Double类中的doubleToLongBits方法，将指定的参数转换为一个long型值，然后将该值以八个字节的形式，写入此流中。先写高位字节。
public final void writeFloat(float v)
throws IOException
使用Float类中的floatToIntBits方法，将指定的参数转换为一个int型值，然后将该值以四个字节的形式，写入此流中。先写高位字节。
public final void writeInt(int v)
throws IOException
将指定的参数，以四个字节的形式写入此流中。先写高位字节。
public final void writeLong(long v)
throws IOException
将指定的参数，以八个字节的形式写入此流中。先写高位字节。
public final void writeShort(int v)
throws IOException
将指定的参数写入此流中。只写入该参数的最低16位。
public final void writeUTF(String str)
throws IOException
将指定的字符串，使用“UTF-8”修改版字符集进行编码，然后写入此流中。此时的数据，只能用readUTF方法读取。
(30)ByteArrayInputStream类
public class ByteArrayInputStream
extends InputStream
❶此流内部包含一个字节数组缓冲区。关闭此流无效。此流未调用底层资源。
此流的读取源即为其内部包含的字节缓冲区。
❷构造方法
public ByteArrayInputStream(byte[] buf)
构造一个使用指定字节数组缓冲区的，字节数组输入流。起始索引为0。
public ByteArrayInputStream(byte[] buf,int offset,intlength)
构造一个使用指定字节数组缓冲区的，字节数组输入流。起始索引为offset。
❸成员方法
pubic int available()/*[ə'veiləbl]有效的*/
返回可以从此流中读取或跳过的剩余字节数。
public void close()
throws IOException
关闭此流无效。关闭后继续调用其方法，并不会产生任何IOException。
public void mark(int readAheadLimit)
设置此流的当前标记位置。该方法对此类没有意义。
public boolean markSupported()/*[ʌnsə'pɔ:tid]不支持的*/
判断此类是否支持mark方法和reset方法。此类始终支持。
public int read()
将一个字节数据读入此流中，并返回其int值。如果已达到流的末尾，则返回-1。可以通过int&255来取出该值。
public int read(byte[] b,int off,int length)
将此流中的数据，读入指定字节数组的某一部分中，并返回读入的字节数。如果已达到流的末尾，则返回-1。
public void reset()
将此流重置回最新标记处。
public long skip(long n)
跳过指定数量的字节，并返回实际跳过的字节数。
(31)ByteArrayOutputStream类
public classByteArrayOutputStream
extends OutputStream
❶此类内部包含了一个字节数组，并且字节数组是可以自动增长的。关闭此流无效。
此流的目的地即为其所包含的字节数组。
❷构造方法
public ByteArrayOutputStream()
构造一个使用默认大小缓冲区的，字节数组输出流。
public ByteArrayOutputStream(int size)
构造一个使用指定大小缓冲区的，字节数组输出流。
❸成员方法
public void close()
throws IOException
关闭此流无效。关闭此流后调用其方法，不会发生任何IOException。
public void reset()
将此流字节数组中的所有内容丢弃(清空)。
public int size()
返回此流当前字节数组的大小。
public byte[] toByteArray()
返回一个新的字节数组，该数组具有此流当前字节数组的大小，并复制了其中的内容。
public String toString()
使用默认的字符集，将字节数组中的内容转换为字符串的形式，并返回它。
public String toString(String charsetName)
throws UnsupportedEncodingException
使用指定名称的字符集，将字节数组中的内容转换为字符串的形式，并返回它。
public void write(byte[] b,int off,int length)
将指定字节数组中的子数组，写入此流中。
public void write(int b)
将指定的参数写入此流中，只写入该参数的最低8位。
public void writeTo(OutputStream out)
throws IOException
将此流字节数组中的内容，全部写入指定的输出流中。
❹字节数组输入流的read方法表示查找，字节数组输出流的write方法表示修改。字节数组输入流和字节数组输出流的组合使用，实现了用流的思想来操作数组。
(32)CharArrayReader类
public class CharArrayReader
extends Reader
❶构造方法
public CharArrayReader(char[] buf)
构造一个和指定的字符数组相关联的，字符数组读取流。起始索引为0。
public CharArrayReader(char[] buf,int offset,int length)
构造一个和指定的字符数组相关联的，字符数组读取流。起始索引为offset。
❷成员方法
public void close()
关闭此流，并释放与之相关联的所有资源。关闭此流有效。
public void mark(int readAheadLimit)
throws IOException
标记此流的当前位置。
Public boolean markSupported()/*[ʌnsə'pɔ:tid]不支持的*/
判断此流是否支持mark方法。此流支持。
public int read()
throws IOException
将单个字符读入此流中，并返回该字符的int值。如果已达到流的末尾，则返回-1。可以通过int&255取出该值。
public int read(char[] b,int off,int length)
throws IOException
将此流中的数据，读入指定数组的指定位置，并返回读入的字符数。如已达到流的末尾，则返回-1。
public boolean ready()
throws IOException
判断此流是否已准备好被读取。返回false，并不一定会阻塞下一次的读取。
public void reset()
throws IOException
将此流重置回最新的标记处。
public long skip(long n)
throws IOException
跳过指定数量的字符，并返回实际跳过的字符数。如果n为负数，则不执行任何操作。
(33)CharArrayWriter类
public class CharArrayWriter
extends Writer
❶此流的缓冲区，可以随着写入数据而自动增长。此流关闭无效。
❷构造方法
public CharArrayWriter()
构造一个使用默认大小缓冲区的，字符数组写入流。
public CharArrayWriter(int initialSize)/*[i'niʃəl]初始的*/
构造一个使用指定大小缓冲区的，字符数组写入流。
❸成员方法
public CharArrayWriterappend(char c)
将指定的字符，写入此流中，并返回该流本身。
public CharArrayWriter append(CharSequence csq)
将指定的字符序列，写入此流中，并返回该流本身。如果参数为null，则写入字符串“null”。
public CharArrayWriter append(CharSequence csq,intstart,int end)
将指定字符序列的子序列，写入此流中，并返回该流本身。如果参数为null，并且没有发生角标越界异常，则写入字符串“null”。
public void close()
此流关闭无效。
public void flush()
刷新此流的缓冲区。
public void reset()
重置该流的缓冲区，以便再次使用它，而无需丢弃已分配的缓冲区。清空该缓冲区中的所有数据。
public int size()
返回此流缓冲区的当前大小。
public char[] toCharArray()
返回一个字符数组，其中复制了此流缓冲区中的所有内容。
public String toString()
返回一个字符串，其中复制了此流缓冲区中的所有内容。
public void write(char[] c,int off,int length)
将指定字符数组中的子数组，写入此流中。
public void write(int c)
将指定的参数，写入此流中。只写入该参数的最低16位。
public void write(String str,int off,int length)
将指定字符串的子串，写入此流中。
public void writeTo(Writer out)
throws IOException
将此流缓冲区中的内容，写入指定的字符输出流中。
(34)StringReader类
public class StringReader
extends Reader
❶构造方法
public StringReader(Strings)
构造一个和指定字符串相关联的，字符串读取流。
❷成员方法
publicvoid close()
关闭此流，并释放与其相关联的所有资源。此流关闭有效。
public void mark(int readAheadLimit)
throws IOException
/*[ma:k]标记[ə'hed]前面的['limit]限定*/
标记此流的当前位置。
public boolean markSupported()/*[ʌnsə'pɔ:tid]不支持的*/
判断此流是否支持mark方法。
public int read()
throws IOException
将单个字符读入此流中，并返回该字符的int值。如果已达到流的末尾，则返回-1。可以通过int&255获取该值。
public int read(char[] cbuf,int off,int length)
throws IOException
将此流中的数据，读入指定字符数组的某一部分中，并返回实际读入的字符数量。如果已达到流的末尾，则返回-1。
public boolean ready()
throws IOException
判断此流是否已准备好被读取。
public void reset()
throws IOException
将此流重置回最新标记处。
public long skip(long n)
throws IOException
跳过指定数量的字符，并返回实际跳过的字符数。如果n为负数，则向后跳。
(35)StringWriter类
public class StringWriter
extends Writer
❶此流关闭无效。
❷构造方法
publicStringWriter()
构造一个使用默认大小初始字符串缓冲区的，字符串写入流。
public StringWriter(int initialSize)
构造一个使用指定大小初始字符串缓冲区的，字符串写入流。
❸成员方法
public StringWriterappend(char c)
将指定的字符，写入此流中，并返回该流本身。
public StringWriter append(CharSequence csq)
将指定的字符序列，写入此流中，并返回该流本身。如果参数为null，则写入字符串“null”。
public StringWriter append(CharSequence csq,int start,intend)
将指定字符序列的子序列，写入此流中，并返回该流本身。如果参数序列为null，并且没有抛出角标越界异常，则写入字符串“null”。
public void close()
throws IOException
此流关闭无效。
public void flush()
刷新此流的缓冲区。
public StringBuffer getBuffer()
返回此流的字符串缓冲区。
public String toString()
返回一个字符串，其复制了此流缓冲区中的所有内容。
public void write(char[] cbuf,int off,int length)
将指定字符数组的子数组，写入此流中。
public void write(int c)
将指定的参数写入此流中。只写入该参数的最低16位。
publicvoid write(String str)
将指定的字符串，写入此流中。
public void write(String str,int off,int length)
将指定字符串的子串，写入此流中。
(36)编码表
❶可以对字节数据进行编码的只有转换流和打印流。
❷编码表的由来
计算机只能识别二进制数据，各个国家将本国的文字用数字来表示，并一一对应，从而形成了一张表，就是编码表。
❸常见的编码表
ASCII：美国标准信息交换码，用一个字节的7位表示。
ISO8859-1：欧洲码表(拉丁码表)，用一个字节的8为表示。
GB2312：中文编码表，用两个字节表示(6763个汉字和682个图形符号)。
GBK：中文编码表的升级版，用两个字节表示(21003个汉字)。
Unicode：国际标准码，融合了多种文字，都用两个字节表示。Java使用的就是该编码表。
UTF-8：万国码，用1~3个字节表示一个字符。
❹GBK和UTF-8是不兼容的，编码和解码必须使用同一个编码表。编码表的名称不区分大小写。
❺编码与解码的原理
编码：将字符数据转换为字节数据，字符串变成字节数组。
String -->byte[]：str.getBytes(charsetName)
解码：将字节数据转换为字符数据，字节数组变成字符串。
Byte[] -->String：new String(byte[],charsetName)
❻编码与解码的问题
对于编码而言，如果选错了字符集，导致编码错误，则字节数据本身就已经是错误的了，不可能再被正确解码。如果解码正确，只能说明其解码出错了。
对于解码而言，如果编码是正确的，而解码时用错了字符集，造成解码错误。这时，就会有两种情况。一是，该字符集也支持这种编码方式，但是规则不同，这时解码所得的数据就是错误的，反向编码后的数据也是错误的。二是，该字符集不支持这种编码方式，这时解码所得的数据是错误的，而反向编码后将会还原此数据，可以通过再次选择正确的字符集，进行重新解码。
新浪主页用GB2312，搜狐主页用GBK，央视网主页用UTF-8。
❼UTF-8字符集的格式
UTF-8字符集可以使用1至3个字节表示一个字符，其之所以可以区分字节数，是因为它为每一个字符的编码加了标识头。规则如下
用单个字节表示一个字符，字节开头为0。
用两个字节表示一个字符，第一个字节开头为110，第二个字节开头为10。
用三个字节表示一个字符，第一个字节开头为1110，后两个字节开头为10。
❽“联通”解码问题
当平台默认字符集为GBK时，在记事本中写入“联通”，关闭后该记事本使用默认的字符集对其进行编码。再次打开时，由于“联通”的字节表示，其开头的数据形式符合UTF-8的编码规则，记事本会按照UTF-8来解码该字节数据，这是就会形成乱码。
解决方法，在其前面加上其它汉字。---------------------------------------- JavaEE+云物联、期待与您交流！---------------------------------------------
8473
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
