注意：使用IO操作属于资源操作，一定要记得关闭。
OutputStream是IO包（java.io）中字节输出流中最大的父类
定义如下：
public abstract class OutputStream implements Closeable, Flushable
此类是一个抽象类，想要使用此类的话，必须首先通过子类实例化对象来操作此类。
使用实例：
public static void outputStreamDemo(String path) {
// 创建File类出来
File file = new File(path);
// 使用FileOutputStream创建实例，文件如果不存在可以自动创建出来
try {
/**
* 一个流实例反复的进行写操作，数据会追加在目标文件内容的后面
* 如果对一个存在内容的文件写操作，会将原内容进行覆盖
* 要实现内容的追加，通过构造函数FileOutputStream（File file，boolean append）
* append为true表示数据是追加的
*/
FileOutputStream outputStream = new FileOutputStream(file, true);
// 进行写操作
/**
* void write(int b)
* 将指定的字节写入输出流
* 参数int b 只使用了b的低八位（一个比特位），b的高24位被忽略
* 可能抛出io异常
*/
outputStream.write(97);
// outputStream.write((int) 'a');
/**
* void write(byte b[])
* 将l.length个字节从指定的byte数组写入到输出流
* 可能抛出io
*/
byte[] bytes = {'t', 'u'};
outputStream.write(bytes);
/**
* void write(byte[] b, int off, int len)
* 将指定byte数组中从偏移量off开始的len个字节写入此输出流
* b-数据。
* off -数据中的初始偏移量。
* len -要写入的字节数。
* 如果b为null,则抛出Null PointerException。
* 如果off 为负，或len为负，或者off+len 大于数组b的长度，则抛出IndexOutOfBoundsException
*/
outputStream.write(bytes, 1, bytes.length - 1);
/**
* void flush()
* 刷新此输出流并强制写出所有缓冲的输出字节
*/
outputStream.flush();
// 关闭资源
outputStream.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
定义：
public abstract class InputStream implements Closeable
此类是一个抽象类，想要使用此类的话，必须首先通过子类实例化对象来操作此类。
使用实例：
public static void inputStreamDemo(String path) {
// 创建FileInputStream实例
try {
FileInputStream inputStream = new FileInputStream(path);
// 进行读操作
/**
* int read()
* 从输入流中读取一个字节
* 只占低八位（一个比特位）
* 返回的是一个数据字节，如果读取到结尾处返回-1
* 可能抛出io
*/
int read = inputStream.read();
System.out.println((char) read); // 97 a
/**
* int read(byte[] b)
* 从输入流中读取一定数量的字节，并将其存储在缓冲区数组b中
* 参数: b -存储读入数据的缓冲区。
* 返回:读入缓冲区的总字节数;如果到达流末尾，则返回-1。
* 抛出: IOException
* NullPointerException -如果b为null。
* 上面的只读取一个字节的方法不能读取中文
*/
byte[] bytes = new byte[100];
int read1 = inputStream.read(bytes);
System.out.println(new String(bytes, 0, read1));
/**
* 大文件内容的读取
* 循环读数据
*/
int num = 0;
while ((num = inputStream.read(bytes)) != -1) {
System.out.println(new String(bytes, 0, num));
}
/**
* int read(byte[] b, int off, int len)
* 将输入流的数据写入到数组b中，off指定写入b的起始位置，len表示可写入的长度
* 返回值表示实际读取数据的长度，读取到结束处返回-1
* io异常，index异常
*/
int read2 = inputStream.read(bytes, 1, 23);
System.out.println(new String(bytes, 0, read2));
/**
* long skip(long n)
* 跳过和丢弃此输入流中数据的n个字节
* 参数:n - 要跳过的字节数。
* 返回:跳过的实际字节数。
*/
inputStream.skip(234);
/**
* int available()
* 读取实际的文件内容长度
*/
inputStream.available();
/**
* boolean markSupported()
* 测试此输入流是否支持mark和reset方法
* 用这两种方法可以重复读取数据
*/
inputStream.markSupported();
/**
* void mark(int readlimit)
* 输入流中标记当前的位置
*/
inputStream.mark(122);
/**
* void mark(int readlimit)
* 此流重新定位到最后一次对此输入流调用mark方法时的位置|
*/
inputStream.reset();
// 关闭资源
inputStream.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
程序中，一个字符需要两个字节来处理，Java提供了Reader、Writer两个专门操作字符流的类。
定义如下：
public abstract class Writer implements Appendable, Closeable, Flushable
此类是一个抽象类，想要使用此类的话，必须首先通过子类实例化对象来操作此类。
使用：
public static void writer(String path) {
// 创建FileWriter实例
try {
FileWriter writer = new FileWriter(path, true);
// 进行字符流的读取
/**
* void write(int c)
* 写入单个字符。要写入的字符包含在给定整数值的16个低位中，16高位被忽略。
* 参数: c - 指定要写入字符的int。
* 抛出: IOException
*/
writer.write('a');
/**
* void write(char[] cbuf)
* 写入字符数组。
* 参数: cbuf - 要写入的字符数组
* 抛出: IOException - 如果发生I/0错误
*/
char[] chars = {'t', 'u', 'l', 'u', 'n'};
writer.write(chars);
/**
* void write(char[] cbuf, int off, int len)
* 写入字符数组的某一部分。
* 参数: cbuf - 字符数组 off - 开始写入字符处的偏移量 len - 要写入的字符数
* 抛出: IOException - 如果发生I/O 错误
*/
writer.write(chars, 0, chars.length);
/**
* void write(String str)
* 写入字符串
* 参数:str - 要写入的字符串
* 抛出:IOException - 如果发生I/O错误
*/
writer.write("hello");
writer.write("abcacb", 0, 4);
/**
* Writer append(CharSequence csq)
* 将指定字符序列添加到此writer.
* 参数: csq - 要添加的字符串序列。
*/
writer.append("A").append("B").append("C");
StringBuffer stringBuffer = new StringBuffer();
StringBuilder stringBuilder = new StringBuilder();
// writer.append(stringBuffer);
// writer.append(stringBuilder);
writer.append("HELLO",0,4);
// writer.flush();
// 关闭资源 close包含了flush
writer.close();
} catch (IOException e) {
e.printStackTrace();
}
}
定义：
public abstract class Reader implements Readable, Closeable
使用如下：
public static void reader(String path) {
// 创建FileReader实例
try {
FileReader fileReader = new FileReader(new File(path));
// 读取字符输入流
/**
* int read()
* 读取单个字符。在字符可用、发生I/O 错误或者已到达流的末尾前，此方法一直阻塞。
* 返回:作为整数读取的字符，范围在0到65535 之间(16个比特位,两个字节)，如果已到达流的末尾，则返回-1
* 抛出: IOException -如果发生I/O错误
*/
int read = fileReader.read();
System.out.println((char)read);
/**
* int read(char[] cbuf)
* 将字符读入数组
* 参数: cbuf -目标缓冲区
* 返回:读取的字符数，如果已到达流的末尾，则返回-1
* 抛出: IOException一如果发生I/O 错误|
*/
char[] chars = new char[100];
int read1 = fileReader.read(chars);
System.out.println(new String(chars,0,read1));
/**
* int read(char[] cbuf, int offset, int length)
* 将字符读入数组的某一部分
* 参数: cbuf -目标缓冲区off -开始存储字符处的偏移量len -要读取的最多字符数
* 返回:读取的字符数，小如果已到达流的末尾，则返回-1
* 抛出: IOException一如果发生I/O错误
*/
int read = fileReader.read(chars, 0, 100);
System.out.println(new String(chars,0,read));
/**
* 大文件的读取：通过循环
*/
// 关闭资源
fileReader.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}