java IO

IO

File

public class **File**extends Object implements Serializable, Comparable

概述

文件和目录路径名的抽象表示形式。

作用

文件系统可以实现对实际文件系统对象上的某些操作（比如，读、写、执行）进行限制。这些限制统称为访问权限。文件系统可以对一个对象设置多个访问权限。例如，一个设置可能适用于对象的所有者，另一个设置则可能适用于所有其他用户。对象上的访问权限可能导致此类的某些方法执行失败。

File 类的实例是不可变的；也就是说，一旦创建，File 对象表示的抽象路径名将永不改变。

注意：构造函数只是创建一个File实例，并没有以文件做读取等操作，因此路径即使是错误的，也可以创建实例不报错

常用方法

字段摘要
static String	pathSeparator 与系统有关的路径分隔符，为了方便，它被表示为一个字符串。
static char	pathSeparatorChar 与系统有关的路径分隔符。
static String	separator 与系统有关的默认名称分隔符，为了方便，它被表示为一个字符串。
static char	separatorChar 与系统有关的默认名称分隔符。

构造方法摘要
File(File parent, String child) 根据 parent 抽象路径名和 child 路径名字符串创建一个新 File 实例。
File(String pathname) 通过将给定路径名字符串转换为抽象路径名来创建一个新 File 实例。
File(String parent, String child) 根据 parent 路径名字符串和 child 路径名字符串创建一个新 File 实例。
File(URI uri) 通过将给定的 file: URI 转换为一个抽象路径名来创建一个新的 File 实例

方法摘要
boolean	canExecute() 测试应用程序是否可以执行此抽象路径名表示的文件。
boolean	canRead() 测试应用程序是否可以读取此抽象路径名表示的文件。
boolean	canWrite() 测试应用程序是否可以修改此抽象路径名表示的文件。
int	compareTo(File pathname) 按字母顺序比较两个抽象路径名。
boolean	createNewFile() 当且仅当不存在具有此抽象路径名指定名称的文件时，不可分地创建一个新的空文件。
static File	createTempFile(String prefix, String suffix) 在默认临时文件目录中创建一个空文件，使用给定前缀和后缀生成其名称。
static File	createTempFile(String prefix, String suffix, File directory) 在指定目录中创建一个新的空文件，使用给定的前缀和后缀字符串生成其名称。
boolean	delete() 删除此抽象路径名表示的文件或目录。
void	deleteOnExit() 在虚拟机终止时，请求删除此抽象路径名表示的文件或目录。
boolean	equals(Object obj) 测试此抽象路径名与给定对象是否相等。
boolean	exists() 测试此抽象路径名表示的文件或目录是否存在。
File	getAbsoluteFile() 返回此抽象路径名的绝对路径名形式。
String	getAbsolutePath() 返回此抽象路径名的绝对路径名字符串。
File	getCanonicalFile() 返回此抽象路径名的规范形式。
String	getCanonicalPath() 返回此抽象路径名的规范路径名字符串。
long	getFreeSpace() 返回此抽象路径名指定的分区中未分配的字节数。
String	getName() 返回由此抽象路径名表示的文件或目录的名称。
String	getParent() 返回此抽象路径名父目录的路径名字符串；如果此路径名没有指定父目录，则返回 null。
File	getParentFile() 返回此抽象路径名父目录的抽象路径名；如果此路径名没有指定父目录，则返回 null。
String	getPath() 将此抽象路径名转换为一个路径名字符串。
long	getTotalSpace() 返回此抽象路径名指定的分区大小。
long	getUsableSpace) 返回此抽象路径名指定的分区上可用于此虚拟机的字节数。
int	hashCode() 计算此抽象路径名的哈希码。
boolean	isAbsolute() 测试此抽象路径名是否为绝对路径名。
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	mkdir() 创建此抽象路径名指定的目录。
boolean	mkdirs() 创建此抽象路径名指定的目录，包括所有必需但不存在的父目录。
boolean	renameToFile dest) 重新命名此抽象路径名表示的文件。
boolean	setExecutable(boolean executable) 设置此抽象路径名所有者执行权限的一个便捷方法。
boolean	setExecutable(boolean executable, boolean ownerOnly) 设置此抽象路径名的所有者或所有用户的执行权限。
boolean	setLastModified(long time) 设置此抽象路径名指定的文件或目录的最后一次修改时间。
boolean	setReadable(boolean readable) 设置此抽象路径名所有者读权限的一个便捷方法。
boolean	setReadable(boolean readable, boolean ownerOnly) 设置此抽象路径名的所有者或所有用户的读权限。
boolean	setReadOnly() 标记此抽象路径名指定的文件或目录，从而只能对其进行读操作。
boolean	setWritable(boolean writable) 设置此抽象路径名所有者写权限的一个便捷方法。
boolean	setWritable(boolean writable, boolean ownerOnly) 设置此抽象路径名的所有者或所有用户的写权限。

FileFilter

public interface **FileFilter**

用于抽象路径名的过滤器。

方法摘要
boolean	accept(File pathname) 测试指定抽象路径名是否应该包含在某个路径名列表中。

FilenameFilter

public interface **FilenameFilter**

实现此接口的类实例可用于过滤器文件名。

方法摘要
boolean	accept(File dir, String name) 测试指定文件是否应该包含在某一文件列表中。

流

概述

通过数据流、序列化和文件系统提供系统输入和输出。

流的本质:数据传输，根据数据传输特性将流抽象为各种类，方便更直观的进行数据操作。

作用

为数据源和目的地建立一个输送通道

Java的IO模型设计非常优秀，它使用Decorator(装饰者)模式，按功能划分Stream，您可以动态装配这些Stream，以便获得您需要的功能。

• 装饰者模式

装饰器模式（Decorator Pattern）允许向一个现有的对象添加新的功能，同时又不改变其结构。这种类型的设计模式属于结构型模式，它是作为现有的类的一个包装。

这种模式创建了一个装饰类，用来包装原有的类，并在保持类方法签名完整性的前提下，提供了额外的功能。

介绍

**意图：**动态地给一个对象添加一些额外的职责。就增加功能来说，装饰器模式相比生成子类更为灵活。

**主要解决：**一般的，我们为了扩展一个类经常使用继承方式实现，由于继承为类引入静态特征，并且随着扩展功能的增多，子类会很膨胀。

**何时使用：**在不想增加很多子类的情况下扩展类。

**如何解决：**将具体功能职责划分，同时继承装饰者模式。

关键代码： 1、Component 类充当抽象角色，不应该具体实现。 2、修饰类引用和继承 Component 类，具体扩展类重写父类方法。

应用实例： 1、孙悟空有 72 变，当他变成"庙宇"后，他的根本还是一只猴子，但是他又有了庙宇的功能。 2、不论一幅画有没有画框都可以挂在墙上，但是通常都是有画框的，并且实际上是画框被挂在墙上。在挂在墙上之前，画可以被蒙上玻璃，装到框子里；这时画、玻璃和画框形成了一个物体。

**优点：**装饰类和被装饰类可以独立发展，不会相互耦合，装饰模式是继承的一个替代模式，装饰模式可以动态扩展一个实现类的功能。

**缺点：**多层装饰比较复杂。

使用场景： 1、扩展一个类的功能。 2、动态增加功能，动态撤销。

**注意事项：**可代替继承。

分类

• 按数据流的方向分为 输入流、输出流

  输入流：从别的地方(本地文件，网络上的资源等)获取资源 输入到 我们的程序中

  输出流：从我们的程序中 输出到 别的地方(本地文件)， 将一个字符串保存到本地文件中

• 按处理数据单位不同分为 字节流、字符流

  1字符 = 2字节 、 1字节(byte) = 8位(bit) 、 一个汉字占两个字节长度

字节流：每次读取(写出)一个字节，当传输的资源文件有中文时，就会出现乱码，

字符流：每次读取(写出)两个字节，有中文时，使用该流就可以正确传输显示中文。

• 按功能不同分为 节点流、处理流

节点流：以从或向一个特定的地方（节点）读写数据。

如FileInputStream

处理流：是对一个已存在的流的连接和封装，通过所封装的流的功能调用实现数据读写。

如BufferedReader。处理流的构造方法总是要带一个其他的流对象做参数。一个流对象经过其他流的多次包装，

字符流的由来： Java中字符是采用Unicode标准，一个字符是16位，即一个字符使用两个字节来表示。为此，JAVA中引入了处理字符的流。因为数据编码的不同，而有了对字符进行高效操作的流对象。本质其实就是基于字节流读取时，去查了指定的码表。

编码集

• ASCII：美国标准信息交换码。

  ASCII字符集每个字符用7位来表示，因此这个字符集中有128个字符，包括大小写拉丁字母、数字和标点符号。

• ISO8859-1：拉丁码表。欧洲码表 用一个字节的8位表示。

  每个字符用8位来表示。这个字符集包含用西欧各种语言编写文本所需的所有字符。

• GB2312：中国的中文编码表。

  每个汉字占据2个字节(高位和低位)，16个数据。GB2312是对ASCII的中文扩展，共包含7000多个汉字。是计算机发展到中国后发展起来的编码，检测高位和低位，如果同时大于0x7F，则认为是GB2312，否则认为是ASCII编码*。

• GBK：中国的中文编码表升级，融合了更多的中文文字符号。

  每个汉字占据***2个字节***，由于汉字的数量太大，GB2312不能满足需求。GBK包括了GB2312的所有内容， 同时增加了近20000个新的汉字（包括繁体）和符号 。只要求高位大于0x7F，低位可以小于0x7F，认为是中文。
  国家标准GB18030-2000《信息交换用汉字编码字符集基本集的补充》是我国继GB2312-1980和

  GB13000-1993之后最重要的汉字编码标准，包含多种我国少数民族文字，其中收入汉字70000余个。

• Unicode：国际标准码，融合了目前人类使用的所字符。为每个字符分配唯一的字符码。所有的文字都用两个字节来表示。

  不兼容ASCII码，即存储的时候，对ASCII码前面补0，导致存储的数据变大。

1. UTF-8：把Unicode转换成一种长度可变的字节编码，与熟悉的ASCII字符集对应的Unicode字符有着和ASCII一样的字节值， 国际标准组织(ISO)制定英文字符使用1个字节，沿用原来的ASCII码
   使用***1~4个字节***表示一个符号，中文存储使用3个字节（ascii码中的内容用1个字节保存\欧洲的字符
   用2个字节保存\东亚的字符用3个字节保存\特殊符号用４个字节）Unicode是内存编码表示方案（规范），而utf-8是如何保存和传输Unicode的方案（实现）
   优点：虽然内存汇总的数据都是Unicode，但当数据保存到磁盘或者用于网络传输时，使用utf-8会节省更多的流量和硬盘空间。
2. UTF-16：所有更为常用的字符归入一个16位代码单元，其他不常用的字符通过一对16位代码单元来存取。

Java除注释、标识符、字符、字符串内容外，几乎所有的输入元素都使用ASCII。对于这些除外的内容，Java支持Unicode字符，既可以用英文以外的语言来写注释，标识符和字符串。

编码和解码

• 编码 将字符转换为对应的二进制序列的过程叫做字符编码;

• 解码 将二进制序列转换为对应的字符的过程叫做字符解码.

常用类

InputStream

public abstract class **InputStream** extends Objectimplements Closeable

概述

此抽象类是表示字节输入流的所有类的超类。

常用方法

构造方法摘要
InputStream()`

方法摘要
int	available() 返回此输入流下一个方法调用可以不受阻塞地从此输入流读取（或跳过）的估计字节数。
void	close() 关闭此输入流并释放与该流关联的所有系统资源。
void	mark(int readlimit) 在此输入流中标记当前的位置。
boolean	markSupported() 测试此输入流是否支持 mark 和 reset 方法。
abstract int	read() 从输入流中读取数据的下一个字节。
int	read(byte[] b) 从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中。
int	read(byte[] b, int off, int len) 将输入流中最多 len 个数据字节读入 byte 数组。
void	reset() 将此流重新定位到最后一次对此输入流调用 mark 方法时的位置。
long	ski(long n) 跳过和丢弃此输入流中数据的 n 个字节。

常用子类

AudioInputStream

public class **AudioInputStream** extends InputStream

音频输入流是具有指定音频格式和长度的输入流。长度用示例帧表示，不用字节表示。提供几种方法，用于从流读取一定数量的字节，或未指定数量的字节。音频输入流跟踪所读取的最后一个字节。可以跳过任意数量的字节以到达稍后的读取位置。音频输入流可支持标记。设置标记时，会记住当前位置，以便可以稍后返回到该位置。

ByteArrayInputStream

public class **ByteArrayInputStream**extends InputStream

• 概述

ByteArrayInputStream 包含一个内部缓冲区，该缓冲区包含从流中读取的字节。内部计数器跟踪 read 方法要提供的下一个字节。

关闭 ByteArrayInputStream 无效。此类中的方法在关闭此流后仍可被调用，而不会产生任何 IOException。

• 常用方法

构造方法摘要
ByteArrayInputStream(byte[] buf) 创建一个 ByteArrayInputStream，使用 buf 作为其缓冲区数组。
ByteArrayInputStream(byte[] buf, int offset, int length) 创建 ByteArrayInputStream，使用 buf 作为其缓冲区数组。

FileInputStream fis = new FileInputStream(new File("ips.txt"));
        StringBuffer sb = new StringBuffer();
        byte[] buf = new byte[1024];
        int len = 0;
        while((len=fis.read(buf))!=-1) {
            sb.append(new String(buf, 0, len));
        }
        ByteArrayInputStream bais = new ByteArrayInputStream(sb.toString().getBytes());
        byte[] bbuf = new byte[1024];
        int blen = 0;
        while(((blen=bais.read(bbuf))!=-1)) {
            System.out.println(new String(bbuf, 0, blen));
        }

FileInputStream

public class **FileInputStream** extends InputStream

• 作用

FileInputStream 从文件系统中的某个文件中获得输入字节。哪些文件可用取决于主机环境。

FileInputStream 用于读取诸如图像数据之类的原始字节流。要读取字符流，请考虑使用 FileReader。

装饰者模式中处于装饰者，具体的装饰者都要继承它，所以在该类的子类下都是用来装饰别的流的，也就是处理类。

• 常用方法

构造方法摘要
FileInputStream(File file) 通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的 File 对象 file 指定。
FileInputStream(FileDescriptor fdObj) 通过使用文件描述符 fdObj 创建一个 FileInputStream，该文件描述符表示到文件系统中某个实际文件的现有连接。
FileInputStream(String name) 通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的路径名 name 指定。

一次读取多个字节
FileInputStream fis = new FileInputStream(new File("ips.txt"));
        byte[] buf = new byte[1024];
        int len = 0;
        while((len=fis.read(buf))!=-1)
        {
            System.out.println(new String(buf,0,len));
        }
        fis.close();

BufferedInputStream

public class **BufferedInputStream** extends FilterInputStream

• 概述

缓冲流，对处理流进行装饰，增强，内部会有一个缓存区，用来存放字节，每次都是将缓存区存满然后发送，而不是一个字节或两个字节这样发送。效率更高

• 常用方法

构造方法摘要
BufferedInputStream(InputStream in) 创建一个 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。
BufferedInputStream(InputStream in, int size) 创建具有指定缓冲区大小的 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。

BufferedInputStream bif = new BufferedInputStream(new FileInputStream(new File("ips.txt")));
        byte[] buf = new byte[1024];
        int len = 0;
        while((len=bif.read(buf))!=-1)
        {
            System.out.println(new String(buf,0,len));
        }
        bif.close();

FilterInputStream

public class **FilterInputStream**extends InputStream

• 概述

FilterInputStream` 包含其他一些输入流，它将这些流用作其基本数据源，它可以直接传输数据或提供一些额外的功能。 类本身只是简单地重写那些将所有请求传递给所包含输入流的 的所有方法。 的子类可进一步重写这些方法中的一些方法，并且还可以提供一些额外的方法和字段。

• 常用方法

构造方法摘要
protected	FilterInputStream(InputStream in) 将参数 in 分配给字段 this.in，以便记住它供以后使用，通过这种方式创建一个 FilterInputStream。

1. DataInputStream.数据输入流,以机器无关的方式读取Java的基本类型.
2. BufferedInputStream缓冲输入流,由于基础输入流一个字节一个字节读取,频繁与磁盘进行交互,造成读取速度较低.缓冲流的存在就是先将数据读取到缓冲流(内存中),然后一次性从内存中读取多个字符.提高读取的效率.
3. PushInputStream回退输入流,java中读取数据的方式是顺序读取,如果某个数据不需要读取,需要程序处理.PushBackInputStream就可以将某些不需要的数据回退到缓冲中.

DataInputStream

public class **DataInputStream** extends FilterInputStream implements DataInput

• 概述

  数据输入流允许应用程序以与机器无关方式从底层输入流中读取基本 Java 数据类型。应用程序可以使用数据输出流写入稍后由数据输入流读取的数据。

  DataInputStream 对于多线程访问不一定是安全的。 线程安全是可选的，它由此类方法的使用者负责。

• 常用方法

构造方法摘要
DataInputStream(InputStream in) 使用指定的底层 InputStream 创建一个 DataInputStream。

ObjectInputStream

public class **ObjectInputStream**extends InputStreamimplements ObjectInput, ObjectStreamConstants

• 概述

ObjectInputStream 对以前使用 ObjectOutputStream 写入的基本数据和对象进行反序列化。

ObjectOutputStream 和 ObjectInputStream 分别与 FileOutputStream 和 FileInputStream 一起使用时，可以为应用程序提供对对象图形的持久存储。ObjectInputStream 用于恢复那些以前序列化的对象。其他用途包括使用套接字流在主机之间传递对象，或者用于编组和解组远程通信系统中的实参和形参。

readObject 方法用于从流读取对象。应该使用 Java 的安全强制转换来获取所需的类型。在 Java 中，字符串和数组都是对象，所以在序列化期间将其视为对象。读取时，需要将其强制转换为期望的类型。

可以使用 DataInput 上的适当方法从流读取基本数据类型。

• 常用方法

构造方法摘要
protected	ObjectInputStream() 为完全重新实现 ObjectInputStream 的子类提供一种方式，让它不必分配仅由 ObjectInputStream 的实现使用的私有数据。
	ObjectInputStream(InputStream in) 创建从指定 InputStream 读取的 ObjectInputStream。

方法摘要
void	defaultReadObject() 从此流读取当前类的非静态和非瞬态字段。
protected boolean	enableResolveObject(boolean enable) 使流允许从该流读取的对象被替代。
boolean	readBoolean() 读取一个 boolean 值。
byte	readByte() 读取一个 8 位的字节。
char	readChar() 读取一个 16 位的 char 值。
protected ObjectStreamClass	readClassDescriptor() 从序列化流读取类描述符。
double	readDouble() 读取一个 64 位的 double 值。
ObjectInputStream.GetField	readFields() 按名称从流中读取持久字段并使其可用。
float	readFloat() 读取一个 32 位的 float 值。
void	readFully(byte[] buf) 读取字节，同时阻塞直至读取所有字节。
void	readFully(byte[] buf, int off, int len) 读取字节，同时阻塞直至读取所有字节。
int	readInt*() 读取一个 32 位的 int 值。
long	readLong() 读取一个 64 位的 long 值。
Object	readObject() 从 ObjectInputStream 读取对象。
protected Object	readObjectOverride() 此方法由 ObjectOutputStream 的受信任子类调用，这些子类使用受保护的无参数构造方法构造 ObjectOutputStream。
short	readShort() 读取一个 16 位的 short 值。
protected void	readStreamHeader() 提供的 readStreamHeader 方法允许子类读取并验证它们自己的流头部。
Object	readUnshared() 从 ObjectInputStream 读取“非共享”对象。
int	readUnsignedByte() 读取一个无符号的 8 位字节。
int	readUnsignedShort() 读取一个无符号的 16 位 short 值。
String	readUTF() 读取 UTF-8 修改版格式的 String。
void	registerValidation(ObjectInputValidation obj, int prio) 在返回图形前注册要验证的对象。
protected Class	resolveClass(ObjectStreamClass desc) 加载指定流类描述的本地等价类。
protected Object	resolveObject(Object obj) 在反序列化期间，此方法允许 ObjectInputStream 的受信任子类使用一个对象替代另一个。
protected Class	resolveProxyClass(String[] interfaces) 返回一个代理类，该类实现在代理类描述符中命名的接口；子类可以实现此方法，以便从流及动态代理类的描述符中读取自定义数据，允许它们使用接口和代理类的替换加载机制。

反序列化: 将二进制数据换回原对象

1. 序列化和反序列化实现了的对象序列化，但是可以发现，操作时是将整个对象的所有属性序列化，那么

   transient关键字可以将某些内容不需要保存，就可以通过transient关键字来定义

   private transient string title；

   此时title属性无法被序列化，

2. 静态方法不能序列化和反序列化

 ObjectInputStream ois = new ObjectInputStream(new FileInputStream(new File("object.text")));
        Object o = ois.readObject();
        Student stu = (Student) o;

PipedInputStream

public class **PipedInputStream** extends InputStream

管道输入流应该连接到管道输出流；管道输入流提供要写入管道输出流的所有数据字节。通常，数据由某个线程从 PipedInputStream 对象读取，并由其他线程将其写入到相应的 PipedOutputStream。不建议对这两个对象尝试使用单个线程，因为这样可能死锁线程。管道输入流包含一个缓冲区，可在缓冲区限定的范围内将读操作和写操作分离开。如果向连接管道输出流提供数据字节的线程不再存在，则认为该管道已损坏。

构造方法摘要
PipedInputStream() 创建尚未连接的 PipedInputStream。
PipedInputStream(int pipeSize) 创建一个尚未连接的 PipedInputStream，并对管道缓冲区使用指定的管道大小。
PipedInputStream(PipedOutputStream src) 创建 PipedInputStream，使其连接到管道输出流 src。
PipedInputStream(PipedOutputStream src, int pipeSize) 创建一个 PipedInputStream，使其连接到管道输出流 src，并对管道缓冲区使用指定的管道大小。

方法摘要
void	connect(PipedOutputStream src) 使此管道输入流连接到管道输出流 src。
int	read()` 读取此管道输入流中的下一个数据字节。
int	read(byte[] b, int off, int len) 将最多 len 个数据字节从此管道输入流读入 byte 数组。
protected void	receive(int b) 接收数据字节。

SequenceInputStream

public class **SequenceInputStream**extends InputStream

SequenceInputStream 表示其他输入流的逻辑串联。它从输入流的有序集合开始，并从第一个输入流开始读取，直到到达文件末尾，接着从第二个输入流读取，依次类推，直到到达包含的最后一个输入流的文件末尾为止。

StringBufferInputStream

已过时。 此类未能正确地将字符转换为字节。从 JDK 1.1 开始，从字符串创建流的首选方法是通过 StringReader 类进行创建。

outputStream

public abstract class **OutputStream** extends Objectimplements Closeable, Flushable

概述

此抽象类是表示输出字节流的所有类的超类。输出流接受输出字节并将这些字节发送到某个接收器。

需要定义 OutputStream 子类的应用程序必须始终提供至少一种可写入一个输出字节的方法。

常用方法

构造方法摘要
OutputStream()

void	close() 关闭此输出流并释放与此流有关的所有系统资源。
void	flush]() 刷新此输出流并强制写出所有缓冲的输出字节。
void	write(byte[] b) 将 b.length 个字节从指定的 byte 数组写入此输出流。
void	write(byte[] b, int off, int len) 将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流。
abstract void	*write(int b) 将指定的字节写入此输出流。

常用子类

FilterOutputStream

public class **FileOutputStream** extends OutputStream

• 概述

文件输出流是用于将数据写入 File 或 FileDescriptor 的输出流。文件是否可用或能否可以被创建取决于基础平台。特别是某些平台一次只允许一个 FileOutputStream（或其他文件写入对象）打开文件进行写入。在这种情况下，如果所涉及的文件已经打开，则此类中的构造方法将失败。

FileOutputStream 用于写入诸如图像数据之类的原始字节的流。要写入字符流，请考虑使用 FileWriter。

• 常用方法

构造方法摘要
FileOutputStream(File file) 创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
FileOutputStream(File file, boolean append) 创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
FileOutputStream(FileDescriptor fdObj) 创建一个向指定文件描述符处写入数据的输出文件流，该文件描述符表示一个到文件系统中的某个实际文件的现有连接。
FileOutputStream(String name) 创建一个向具有指定名称的文件中写入数据的输出文件流。
FileOutputStream(String name, boolean append) 创建一个向具有指定 name 的文件中写入数据的输出文件流。

       FileOutputStream fos = new FileOutputStream(new File("ops.txt"));// 默认是关闭“追加模式”
        fos.write("你好".getBytes());
        fos.close();


        FileOutputStream fos = new FileOutputStream(new File("ops.txt"), true); //打开“追加模式”
        // 向“文件中”写入"0123456789"+换行符
        fos.write("你好".getBytes());
        fos.write("\r\n".getBytes());
        fos.flush();
        fos.close();

注意文件写入是否覆盖及换行

FilterOutputStream

public class **FilterOutputStream**extends OutputStream

此类是过滤输出流的所有类的超类。这些流位于已存在的输出流（基础 输出流）之上，它们将已存在的输出流作为其基本数据接收器，但可能直接传输数据或提供一些额外的功能。

FilterOutputStream 类本身只是简单地重写那些将所有请求传递给所包含输出流的 OutputStream 的所有方法。FilterOutputStream 的子类可进一步地重写这些方法中的一些方法，并且还可以提供一些额外的方法和字段

BufferedOutputStream

DataOutputStream

PrintStream

BufferedOutputStream

public class **BufferedOutputStream**extends FilterOutputStream

• 概述

  该类实现缓冲的输出流。通过设置这种输出流，应用程序就可以将各个字节写入底层输出流中，而不必针对每次字节写入调用底层系统

• 常用方法

构造方法摘要
BufferedOutputStreamOutputStream out) 创建一个新的缓冲输出流，以将数据写入指定的底层输出流。
BufferedOutputStream(OutputStream out, int size) 创建一个新的缓冲输出流，以将具有指定缓冲区大小的数据写入指定的底层输出流。

BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(new File("ops.txt")));// 默认是关闭“追加模式”)
        bos.write("你好".getBytes());
        bos.flush();
        bos.close();

DataOutputStream

public class **DataOutputStream**extends FilterOutputStreamimplements DataOutput

• 概述

数据输出流允许应用程序以适当方式将基本 Java 数据类型写入输出流中。然后，应用程序可以使用数据输入流将数据读入。

• 常用方法

构造方法摘要
DataOutputStream(OutputStream out) 创建一个新的数据输出流，将数据写入指定基础输出流。

方法摘要
void	writeBoolean(boolean v) 将一个 boolean 值以 1-byte 值形式写入基础输出流。
void	writeByte(int v) 将一个 byte 值以 1-byte 值形式写出到基础输出流中。
void	writeBytes(String s) 将字符串按字节顺序写出到基础输出流中。
void	writeChar(int v) 将一个 char 值以 2-byte 值形式写入基础输出流中，先写入高字节。
void	writeChars(String s) 将字符串按字符顺序写入基础输出流。
void	writeDouble(double v) 使用 Double 类中的 doubleToLongBits 方法将 double 参数转换为一个 long 值，然后将该 long 值以 8-byte 值形式写入基础输出流中，先写入高字节。
void	writeFloat(float v) 使用 Float 类中的 floatToIntBits 方法将 float 参数转换为一个 int 值，然后将该 int 值以 4-byte 值形式写入基础输出流中，先写入高字节。
void	writeInt(int v) 将一个 int 值以 4-byte 值形式写入基础输出流中，先写入高字节。
void	writeLong(long v) 将一个 long 值以 8-byte 值形式写入基础输出流中，先写入高字节。
void	*writeShort(int v) 将一个 short 值以 2-byte 值形式写入基础输出流中，先写入高字节。
void	writeUTF(String str) 以与机器无关方式使用 UTF-8 修改版编码将一个字符串写入基础输出流。

 DataOutputStream dos = new DataOutputStream(new FileOutputStream(new File("ops.txt")));// 默认是关闭“追加模式”)
        dos.write("你好".getBytes());
        dos.flush();
        dos.close();

PrinStream

public class **PrintStream** extends FilterOutputStream implements Appendable, Closeable

• 概述

PrintStream 为其他输出流添加了功能，使它们能够方便地打印各种数据值表示形式。它还提供其他两项功能。与其他输出流不同，PrintStream 永远不会抛出 IOException；而是，异常情况仅设置可通过 checkError 方法测试的内部标志。另外，为了自动刷新，可以创建一个 PrintStream；这意味着可在写入 byte 数组之后自动调用 flush 方法，可调用其中一个 println 方法，或写入一个换行符或字节 ('\n')。

PrintStream 打印的所有字符都使用平台的默认字符编码转换为字节。在需要写入字符而不是写入字节的情况下，应该使用 PrintWriter 类。

• 常用方法

构造方法摘要
PrintStream(File file) 创建具有指定文件且不带自动行刷新的新打印流。
PrintStream(File file, String csn) 创建具有指定文件名称和字符集且不带自动行刷新的新打印流。
PrintStream(OutputStream out) 创建新的打印流。
PrintStream(OutputStream out, boolean autoFlush) 创建新的打印流。
PrintStream(OutputStream out, boolean autoFlush, String encoding) 创建新的打印流。
PrintStream(String fileName) 创建具有指定文件名称且不带自动行刷新的新打印流。
PrintStream(String fileName, String csn) 创建具有指定文件名称和字符集且不带自动行刷新的新打印流。

void	println() 通过写入行分隔符字符串终止当前行。
void	println(boolean x) 打印 boolean 值，然后终止行。
void	println(char x) 打印字符，然后终止该行。
void	println(char[] x) 打印字符数组，然后终止该行。
void	println(double x) 打印 double，然后终止该行。
void	println(float x) 打印 float，然后终止该行。
void	println(int x) 打印整数，然后终止该行。
void	println(long x) 打印 long，然后终止该行。
void	println(Object x) 打印 Object，然后终止该行。
void	println(String x) 打印 String，然后终止该行。

PrintStream ps = new PrintStream(new FileOutputStream(new File("ops.txt")));// 默认是关闭“追加模式”)
        ps.println("你好");
        ps.flush();
        ps.close();

ByteArrayOutputStream

public class **ByteArrayOutputStream**extends OutputStream

• 概述

此类实现了一个输出流，其中的数据被写入一个 byte 数组。缓冲区会随着数据的不断写入而自动增长。可使用 toByteArray() 和 toString() 获取数据。

关闭 ByteArrayOutputStream 无效。此类中的方法在关闭此流后仍可被调用，而不会产生任何 IOException。

• 常用方法

构造方法摘要
ByteArrayOutputStream() 创建一个新的 byte 数组输出流。
ByteArrayOutputStream(int size) 创建一个新的 byte 数组输出流，它具有指定大小的缓冲区容量（以字节为单位）。

void	writeTo(OutputStream out) 将此 byte 数组输出流的全部内容写入到指定的输出流参数中，这与使用 out.write(buf, 0, count) 调用该输出流的 write 方法效果一样。

ByteArrayOutputStream baos = new ByteArrayOutputStream();
        FileOutputStream fos = new FileOutputStream(new File("ops.txt"));// 默认是关闭“追加模式”
        baos.write("年后".getBytes());
        baos.writeTo(fos);
        fos.flush();
        fos.close();

ObjectOutputStream

public class **ObjectOutputStream**extends OutputStreamimplements ObjectOutput, ObjectStreamConstants

• 概述

ObjectOutputStream 将 Java 对象的基本数据类型和图形写入 OutputStream。可以使用 ObjectInputStream 读取（重构）对象。通过在流中使用文件可以实现对象的持久存储。如果流是网络套接字流，则可以在另一台主机上或另一个进程中重构对象。

只能将支持 java.io.Serializable 接口的对象写入流中。每个 serializable 对象的类都被编码，编码内容包括类名和类签名、对象的字段值和数组值，以及从初始对象中引用的其他所有对象的闭包。

writeObject 方法用于将对象写入流中。所有对象（包括 String 和数组）都可以通过 writeObject 写入。可将多个对象或基元写入流中。必须使用与写入对象时相同的类型和顺序从相应 ObjectInputstream 中读回对象。

还可以使用 DataOutput 中的适当方法将基本数据类型写入流中。还可以使用 writeUTF 方法写入字符串。

对象的默认序列化机制写入的内容是：对象的类，类签名，以及非瞬态和非静态字段的值。其他对象的引用（瞬态和静态字段除外）也会导致写入那些对象。可使用引用共享机制对单个对象的多个引用进行编码，这样即可将对象的图形恢复为最初写入它们时的形状。

• 常用方法

构造方法摘要
protected	ObjectOutputStream() 为完全重新实现 ObjectOutputStream 的子类提供一种方法，让它不必分配仅由 ObjectOutputStream 的实现使用的私有数据。
	ObjectOutputStream(OutputStream out) 创建写入指定 OutputStream 的 ObjectOutputStream。

void	defaultWriteObject 将当前类的非静态和非瞬态字段写入此流。
protected void	drain() 排空 ObjectOutputStream 中的所有已缓冲数据。
protected boolean	enableReplaceObject(boolean enable) 允许流对流中的对象进行替换。
void	flush() 刷新该流的缓冲。
ObjectOutputStream.PutField	putFields() 获取用于缓冲写入流中的持久存储字段的对象。
protected Object	replaceObject(Object obj) 在序列化期间，此方法允许 ObjectOutputStream 的受信任子类使用一个对象替代另一个对象。
void	reset() 重置将丢弃已写入流中的所有对象的状态。

void	writeBoolean(boolean val) 写入一个 boolean 值。
void	writeByte(int val) 写入一个 8 位字节。
void	writeBytes(String str) 以字节序列形式写入一个 String。
void	writeChar(int val) 写入一个 16 位的 char 值。
void	writeChars(String str) 以 char 序列形式写入一个 String。
protected void	writeClassDescriptor(ObjectStreamClass desc) 将指定的类描述符写入 ObjectOutputStream。
void	writeDouble(double val) 写入一个 64 位的 double 值。
void	writeFields() 将已缓冲的字段写入流中。
void	writeFloat(float val) 写入一个 32 位的 float 值。
void	writeInt(int val) 写入一个 32 位的 int 值。
void	writeLong(long val) 写入一个 64 位的 long 值。
void	writeObject(Object obj) 将指定的对象写入 ObjectOutputStream。
protected void	writeObjectOverride(Object obj) 子类用于重写默认 writeObject 方法的方法。
void	writeShort(int val) 写入一个 16 位的 short 值。
protected void	writeStreamHeader() 提供 writeStreamHeader 方法，这样子类可以将其自身的头部添加或预加到流中。
void	writeUnshared(Object obj) 将“未共享”对象写入 ObjectOutputStream。
void	writeUTF(String str) 以 UTF-8 修改版格式写入此 String 的基本数据。

将保存在内存中的对象数据转化为二进制数据流进行传输，任何对象都可以序列化

ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(new File("object.text"),true));
        oos.writeObject(new Student("张三","123456"));
        oos.writeObject(new Student("李四","123456"));
        oos.writeObject(new Student("王五","123456"));
        oos.flush();
        oos.close();
向文件追加数据时应考虑数据文件头部问题

PipedOutputStream

public class **PipedOutputStream**extends OutputStream

可以将管道输出流连接到管道输入流来创建通信管道。管道输出流是管道的发送端。通常，数据由某个线程写入 PipedOutputStream 对象，并由其他线程从连接的 PipedInputStream 读取。不建议对这两个对象尝试使用单个线程，因为这样可能会造成该线程死锁。如果某个线程正从连接的管道输入流中读取数据字节，但该线程不再处于活动状态，则该管道被视为处于 毁坏 状态。

构造方法摘要
PipedOutputStream()` 创建尚未连接到管道输入流的管道输出流。
PipedOutputStream(PipedInputStream snk) 创建连接到指定管道输入流的管道输出流。

void	connect(PipedInputStream snk) 将此管道输出流连接到接收者

Reader

public abstract class **Reader** extends Objectimplements Readable, Closeable

概述

用于读取字符流的抽象类。子类必须实现的方法只有 read(char[], int, int) 和 close()。但是，多数子类将重写此处定义的一些方法，以提供更高的效率和/或其他功能。

常用方法

构造方法摘要
protected	Reader() 创建一个新的字符流 reader，其重要部分将同步其自身的 reader。
protected	Reader(Object lock) 创建一个新的字符流 reader，其重要部分将同步给定的对象。

方法摘要
abstract void	close() 关闭该流并释放与之关联的所有资源。
void	mark(int readAheadLimit) 标记流中的当前位置。
boolean	markSupported*() 判断此流是否支持 mark() 操作。
int	read() 读取单个字符。
int	read(char[] cbuf) 将字符读入数组。
abstract int	read(char[] cbuf, int off, int len) 将字符读入数组的某一部分。
int	readCharBuffer target) 试图将字符读入指定的字符缓冲区。
boolean	ready() 判断是否准备读取此流。
void	reset() 重置该流。
long	skip(long n) 跳过字符。

常用子类

BufferedReader

public class **BufferedReader**extends Reader

• 概述

从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。

可以指定缓冲区的大小，或者可使用默认的大小。大多数情况下，默认值就足够大了。

通常，Reader 所作的每个读取请求都会导致对底层字符或字节流进行相应的读取请求。因此，建议用 BufferedReader 包装所有其 read() 操作可能开销很高的 Reader（如 FileReader 和 InputStreamReader）。

• 常用方法

构造方法摘要
BufferedReader(Reader in) 创建一个使用默认大小输入缓冲区的缓冲字符输入流。
BufferedReader(Reader in, int sz) 创建一个使用指定大小输入缓冲区的缓冲字符输入流。

String	readLine() 读取一个文本行。

读取一个文本行。通过下列字符之一即可认为某行已终止：换行 (’\n’)、回车 (’\r’) 或回车后直接跟着换行。

返回：
包含该行内容的字符串，不包含任何行终止符，如果已到达流末尾，则返回 null

 BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(new File("ips.txt"))));
        String line = null;
        while ((line = br.readLine()) != null){
            System.out.println(line);
        }

CharArrayReader

public class **CharArrayReader**extends Reader

此类实现一个可用作字符输入流的字符缓冲区。

构造方法摘要
CharArrayReader(char[] buf) 根据指定的 char 数组创建一个 CharArrayReader。
CharArrayReader(char[] buf, int offset, int length) 根据指定的 char 数组创建一个 CharArrayReader。

InputStreamReader isr =  new InputStreamReader(new FileInputStream(new File("ips.txt")));
        StringBuffer sb = new StringBuffer();
        char[] chars = new char[1024];
        int len = 0;
        while ((len = isr.read(chars))!= -1){
            sb.append(new String(chars,0,len));
        }
        String str = sb.toString();
        char[] chars1 = new char[str.length()];
        for (int i=0;i<str.length();i++){
            chars1[i] = str.charAt(i);
        }
        CharArrayReader car = new CharArrayReader(chars1);
        char[] chars2 = new char[1024];
        int len2 = 0;
        while ((len2 = car.read(chars2))!= -1){
            System.out.println(new String(chars2,0,len2));
        }

FilterReader

public abstract class **FilterReader**extends Reader

用于读取已过滤的字符流的抽象类。抽象类 FilterReader 自身提供了一些将所有请求传递给所包含的流的默认方法。FilterReader 的子类应重写这些方法中的一些方法，并且还可以提供一些额外的方法和字段。

InputStreamReader

public class **InputStreamReader** extends Reader

• 概述

InputStreamReader 是字节流通向字符流的桥梁：它使用指定的 charset 读取字节并将其解码为字符。它使用的字符集可以由名称指定或显式给定，或者可以接受平台默认的字符集。

每次调用 InputStreamReader 中的一个 read() 方法都会导致从底层输入流读取一个或多个字节。要启用从字节到字符的有效转换，可以提前从底层流读取更多的字节，使其超过满足当前读取操作所需的字节。

• 常用方法

  构造方法摘要
  InputStreamReader(InputStream in) 创建一个使用默认字符集的 InputStreamReader。
  InputStreamReader(InputStream in, Charset cs) 创建使用给定字符集的 InputStreamReader。
  InputStreamReader(InputStream in, CharsetDecoder dec) 创建使用给定字符集解码器的 InputStreamReader。
  InputStreamReader(InputStream in, String charsetName) 创建使用指定字符集的 InputStreamReader。

String	getEncoding() 返回此流使用的字符编码的名称。

 InputStreamReader isr =  new InputStreamReader(new FileInputStream(new File("ips.txt")));
        char[] chars = new char[1024];
        int len = 0;
        while ((len = isr.read(chars))!= -1){
            System.out.println(new String(chars,0,len));
        }

PipedReader

public class **PipedReader**extends Reader

传送的字符输入流。

StringReader

public class **StringReader**extends Reader

其源为一个字符串的字符流。

构造方法摘要
StringReader(String s) 创建一个新字符串 reader。

Writer

public abstract class **Writer** extends Objectimplements Appendable, Closeable, Flushable

概述

写入字符流的抽象类。子类必须实现的方法仅有 write(char[], int, int)、flush() 和 close()。但是，多数子类将重写此处定义的一些方法，以提供更高的效率和/或其他功能。

常用方法

构造方法摘要
protected	Writer() 创建一个新的字符流 writer，其关键部分将同步 writer 自身。
protected	Writer(Object lock) 创建一个新的字符流 writer，其关键部分将同步给定的对象。

Writer	append(char c) 将指定字符添加到此 writer。
Writer	append(CharSequence csq) 将指定字符序列添加到此 writer。
Writer	append(CharSequence csq, int start, int end) 将指定字符序列的子序列添加到此 writer.Appendable。
abstract void	close() 关闭此流，但要先刷新它。
abstract void	flush() 刷新该流的缓冲。
void	write(char[] cbuf) 写入字符数组。
abstract void	write(char[], int, int))**(char[] cbuf, int off, int len) 写入字符数组的某一部分。
void	write(int c) 写入单个字符。
void	write(String str) 写入字符串。
void	write(String str, int off, int len) 写入字符串的某一部分。

常用子类

BufferedWriter

public class **BufferedWriter**extends Writer

• 概述

将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。

可以指定缓冲区的大小，或者接受默认的大小。在大多数情况下，默认值就足够大了。

该类提供了 newLine() 方法，它使用平台自己的行分隔符概念，此概念由系统属性 line.separator 定义。并非所有平台都使用新行符 (’\n’) 来终止各行。因此调用此方法来终止每个输出行要优于直接写入新行符。

通常 Writer 将其输出立即发送到底层字符或字节流。除非要求提示输出，否则建议用 BufferedWriter 包装所有其 write() 操作可能开销很高的 Writer（如 FileWriters 和 OutputStreamWriters）。

• 常用方法

构造方法摘要
BufferedWriter(Writer out) 创建一个使用默认大小输出缓冲区的缓冲字符输出流。
BufferedWriter(Writer out, int sz) 创建一个使用给定大小输出缓冲区的新缓冲字符输出流。

void	newLine() 写入一个行分隔符。

BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(new File("ops.txt"))));
        bw.write("你好");
        bw.newLine();
        bw.flush();
        bw.close();

CharArrayWriter

public class **CharArrayWriter**extends Writer

此类实现一个可用作 Writer 的字符缓冲区。缓冲区会随向流中写入数据而自动增长。可使用 toCharArray() 和 toString() 获取数据。

注：在此类上调用 close() 无效，并且在关闭该流后可以调用此类中的各个方法，而不会产生任何 IOException

构造方法摘要
CharArrayWriter*() 创建一个新的 CharArrayWriter。
CharArrayWriter(int initialSize) 创建一个具有指定初始大小的新 CharArrayWriter。

void	writeTo(Writer out) 将缓冲区的内容写入另一个字符流。

OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(new File("ops.txt")));
        CharArrayWriter car = new CharArrayWriter();
        car.write("你好");
        car.writeTo(osw);
        osw.flush();
        osw.close();

FilterWriter

public abstract class **FilterWriter**extends Writer

用于写入已过滤的字符流的抽象类。抽象类 FilterWriter 自身提供了一些将所有请求传递给所包含的流的默认方法。FilterWriter 的子类应重写这些方法中的一些方法，并且还可以提供一些额外的方法和字段。

OutputStreamWriter

public class **OutputStreamWriter** extends Writer

• 概述

每次调用 write() 方法都会导致在给定字符（或字符集）上调用编码转换器。在写入底层输出流之前，得到的这些字节将在缓冲区中累积。可以指定此缓冲区的大小，不过，默认的缓冲区对多数用途来说已足够大。注意，传递给 write() 方法的字符没有缓冲。

• 常用方法

构造方法摘要
OutputStreamWriter(OutputStream out)` 创建使用默认字符编码的 OutputStreamWriter。
OutputStreamWriter(OutputStream out, Charset cs) 创建使用给定字符集的 OutputStreamWriter。
OutputStreamWriter(OutputStream out, CharsetEncoder enc) 创建使用给定字符集编码器的 OutputStreamWriter。
OutputStreamWriter(OutputStream out, String charsetName) 创建使用指定字符集的 OutputStreamWriter。

String	getEncoding() 返回此流使用的字符编码的名称。

注意 flush()与字符编码问题

 OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(new File("ops.txt"),true));
        osw.write("你好");
        osw.write("\r\n");
        osw.flush();
        osw.close();

PipedWriter

• public class **PipedWriter**extends Writer

传送的字符输出流。

PrintWriter

public class **PrintWriter**extends Writer

• 概述

向文本输出流打印对象的格式化表示形式。此类实现在 PrintStream 中的所有 print 方法。它不包含用于写入原始字节的方法，对于这些字节，程序应该使用未编码的字节流进行写入。

• 常用方法

构造方法摘要
PrintWriter(File file) 使用指定文件创建不具有自动行刷新的新 PrintWriter。
PrintWriter(File file, String csn) 创建具有指定文件和字符集且不带自动刷行新的新 PrintWriter。
PrintWriter(OutputStream out) 根据现有的 OutputStream 创建不带自动行刷新的新 PrintWriter。
PrintWriter(OutputStream out, boolean autoFlush) 通过现有的 OutputStream 创建新的 PrintWriter。
PrintWriter(String fileName) 创建具有指定文件名称且不带自动行刷新的新 PrintWriter。
PrintWriter(String fileName, String csn) 创建具有指定文件名称和字符集且不带自动行刷新的新 PrintWriter。
PrintWriter(Writer out) 创建不带自动行刷新的新 PrintWriter。
PrintWriter(Writer out, boolean autoFlush) 创建新 PrintWriter。

void	println() 通过写入行分隔符字符串终止当前行。
void	println(boolean x) 打印 boolean 值，然后终止该行。
void	println(char x) 打印字符，然后终止该行。
void	println(char[] x) 打印字符数组，然后终止该行。
void	println(double x) 打印双精度浮点数，然后终止该行。
void	println(float x) 打印浮点数，然后终止该行。
void	println(int x) 打印整数，然后终止该行。
void	println(long x) 打印 long 整数，然后终止该行。
void	println(Object x) 打印 Object，然后终止该行。
void	println(String x) 打印 String，然后终止该行。

PrintWriter pw = new PrintWriter(new OutputStreamWriter(new FileOutputStream(new File("ops.txt"))));
        pw.println("你好");
        pw.println("你好");
        pw.close();

StringWriter

public class **StringWriter**extends Writer

一个字符流，可以用其回收在字符串缓冲区中的输出来构造字符串。

关闭 StringWriter 无效。此类中的方法在关闭该流后仍可被调用，而不会产生任何 IOException。

构造方法摘要
StringWriter() 使用默认初始字符串缓冲区大小创建一个新字符串 writer。
StringWriter(int initialSize) 使用指定初始字符串缓冲区大小创建一个新字符串 writer。

字节流和字符流的区别（重点）

• 字符流和字节流的使用范围：字节流一般用来处理图像，视频，以及PPT，Word类型的文件。字符流一般用于处理纯文本类型的文件，如TXT文件等，字节流可以用来处理纯文本文件，但是字符流不能用于处理图像视频等非文本类型的文件。
• 转换流的作用，文本文件在硬盘中以字节流的形式存储时，通过InputStreamReader读取后转化为字符流给程序处理，程序处理的字符流通过OutputStreamWriter转换为字节流保存。
• 节流没有缓冲区，是直接输出的，而字符流是输出到缓冲区的。因此在输出时，字节流不调用colse()方法时，信息已经输出了，而字符流只有在调用close()方法关闭缓冲区时，信息才输出。要想字符流在未关闭时输出信息，则需要手动调用flush()方法。

RandomAccessFile

public class **RandomAccessFile**extends Objectimplements DataOutput, DataInput, Closeable

概述

此类的实例支持对随机访问文件的读取和写入。随机访问文件的行为类似存储在文件系统中的一个大型 byte 数组。存在指向该隐含数组的光标或索引，称为文件指针；输入操作从文件指针开始读取字节，并随着对字节的读取而前移此文件指针。如果随机访问文件以读取/写入模式创建，则输出操作也可用；输出操作从文件指针开始写入字节，并随着对字节的写入而前移此文件指针。写入隐含数组的当前末尾之后的输出操作导致该数组扩展。该文件指针可以通过 getFilePointer 方法读取，并通过 seek 方法设置。

与OutputStearm,Writer等输出流不同的是，RandomAccessFile类允许自由定位文件记录指针，所以RandomAccessFile可以不从文件开始的地方进行输出，所以RandomAccessFile可以向已存在的文件后追加内容。

常用方法

RandomAccessFile(File file, String mode) 创建从中读取和向其中写入（可选）的随机访问文件流，该文件由 File 参数指定。
RandomAccessFile(String name, String mode) 创建从中读取和向其中写入（可选）的随机访问文件流，该文件具有指定名称。

方法摘要
void	close() 关闭此随机访问文件流并释放与该流关联的所有系统资源。
FileChannel	getChannel() 返回与此文件关联的唯一 FileChannel 对象。
FileDescriptor	getFD() 返回与此流关联的不透明文件描述符对象。
long	getFilePointer() 返回此文件中的当前偏移量。
long	length() 返回此文件的长度。
int	read() 从此文件中读取一个数据字节。
int	read(byte[] b) 将最多 b.length 个数据字节从此文件读入 byte 数组。
int	read(byte[] b, int off, int len) 将最多 len 个数据字节从此文件读入 byte 数组。
boolean	**[readBoolean](../../java/io/RandomAccessFile.html#readBoolean())**() 从此文件读取一个 boolean。
byte	readByte() 从此文件读取一个有符号的八位值。
char	readChar() 从此文件读取一个字符。
double	readDouble() 从此文件读取一个 double。
float	readFloat() 从此文件读取一个 float。
void	readFully(byte[] b) 将 b.length 个字节从此文件读入 byte 数组，并从当前文件指针开始。
void	readFullybyte[], int, int))**(byte[] b, int off, int len) 将正好 len 个字节从此文件读入 byte 数组，并从当前文件指针开始。
int	readInt() 从此文件读取一个有符号的 32 位整数。
String	readLine() 从此文件读取文本的下一行。
long	readLong() 从此文件读取一个有符号的 64 位整数。
short	readShort() 从此文件读取一个有符号的 16 位数。
int	readUnsignedByte() 从此文件读取一个无符号的八位数。
int	readUnsignedShort() 从此文件读取一个无符号的 16 位数。
String	readUTF() 从此文件读取一个字符串。
void	seek(long pos) 设置到此文件开头测量到的文件指针偏移量，在该位置发生下一个读取或写入操作。
void	setLength(long newLength) 设置此文件的长度。
int	skipBytes(int n) 尝试跳过输入的 n 个字节以丢弃跳过的字节。
void	write(byte[] b) 将 b.length 个字节从指定 byte 数组写入到此文件，并从当前文件指针开始。
void	write(byte[] b, int off, int len) 将 len 个字节从指定 byte 数组写入到此文件，并从偏移量 off 处开始。
void	write(int b) 向此文件写入指定的字节。
void	writeBoolean(boolean v) 按单字节值将 boolean 写入该文件。
void	writeByte(int v) 按单字节值将 byte 写入该文件。
void	writeBytes(String s) 按字节序列将该字符串写入该文件。
void	writeChar(int v) 按双字节值将 char 写入该文件，先写高字节。
void	writeChars(String s) 按字符序列将一个字符串写入该文件。
void	writeDouble(double v) 使用 Double 类中的 doubleToLongBits 方法将双精度参数转换为一个 long，然后按八字节数量将该 long 值写入该文件，先定高字节。
void	writeFloat(float v) 使用 Float 类中的 floatToIntBits 方法将浮点参数转换为一个 int，然后按四字节数量将该 int 值写入该文件，先写高字节。
void	writeInt(int v) 按四个字节将 int 写入该文件，先写高字节。
void	writeLong*(long v) 按八个字节将 long 写入该文件，先写高字节。
void	writeShort(int v) 按两个字节将 short 写入该文件，先写高字节。
void	writeUTF(String str) 使用 modified UTF-8 编码以与机器无关的方式将一个字符串写入该文件。

RandomAccessFile以字节方式读写文件，众所周知，计算机以二进制形式存储文件（包括视频，音频，文字等等），RandomAccessFile是以低八位一个字节读写，更准确的操作二进制文件，可以这么说，运用RandomAccessFile文件就可以任意的读取二进制文件了。

将 `len` 个字节从指定 byte  数组写入到此文件，并从偏移量 `off` 处开始。 |

| void | write(int b) 向此文件写入指定的字节。 |
| void | writeBoolean(boolean v) 按单字节值将 boolean 写入该文件。 |
| void | writeByte(int v) 按单字节值将 byte 写入该文件。 |
| void | writeBytes(String s) 按字节序列将该字符串写入该文件。 |
| void | writeChar(int v) 按双字节值将 char 写入该文件，先写高字节。 |
| void | writeChars(String s) 按字符序列将一个字符串写入该文件。 |
| void | writeDouble(double v) 使用 Double 类中的 doubleToLongBits 方法将双精度参数转换为一个 long，然后按八字节数量将该 long 值写入该文件，先定高字节。 |
| void | writeFloat(float v) 使用 Float 类中的 floatToIntBits 方法将浮点参数转换为一个 int，然后按四字节数量将该 int 值写入该文件，先写高字节。 |
| void | writeInt(int v) 按四个字节将 int 写入该文件，先写高字节。 |
| void | writeLong*(long v) 按八个字节将 long 写入该文件，先写高字节。 |
| void | writeShort(int v) 按两个字节将 short 写入该文件，先写高字节。 |
| void | writeUTF(String str) 使用 modified UTF-8 编码以与机器无关的方式将一个字符串写入该文件。 |

RandomAccessFile以字节方式读写文件，众所周知，计算机以二进制形式存储文件（包括视频，音频，文字等等），RandomAccessFile是以低八位一个字节读写，更准确的操作二进制文件，可以这么说，运用RandomAccessFile文件就可以任意的读取二进制文件了。