java-API之字节流的读取与写入
字节流的读取与写入
字节流的读取
InputStream
InputStream类是抽象类，是表示字节输入流的所有类的超类。
public abstract class InputStream{} // InputStream类是抽象类
public class FileInputStream extends InputStream{} // InputStream类是FileInputStreamextends的父类/超类
public class FilterInputStream extends InputStream{}
public class BufferedInputStream extends FilterInputStream{} // InputStream类是BufferedInputStreamextends 的父类/超类
InputStream中的常用方法
- abstract int read() 从输入流中读取数据的下一个字节。
- int read(byte[] b) 从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中。
- int read(byte[] b, int off, int len) 将输入流中最多 len 个数据字节读入 byte 数组。
- void close() 关闭此输入流并释放与该流关联的所有系统资源。
FileInputStream 子类
创建对象的方法
- FileInputStream(File file) 通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的 File 对象 file 指定。
- FileInputStream(String name) 通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的路径名 name 指定。
InputStream in = new FileInputStream( new File( "F:\\ioTest\\1.txt" ) );
InputStream in = new FileInputStream( "F:\\ioTest\\1.txt" );
高效的BufferedInputStream子类
BufferedInputStream 之所以高效，其根本原因在于创建 BufferedInputStream 时，会创建一个内部缓冲区数组。在读取或跳过流中的字节时，可根据需要从包含的输入流再次填充该内部缓冲区，一次填充多个字节。
private static int DEFAULT_BUFFER_SIZE = 8192;
/**
* The internal buffer array where the data is stored. When necessary,
* it may be replaced by another array of
* a different size.
*/
protected volatile byte buf[]; // 源码中的缓存数组 大小默认8kb = 8 * 1024
创建对象的方式：
- BufferedInputStream(InputStream in) 创建一个 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。
InputStream in = new BufferedInputStream(new FileInputStream( new File( "F:\\ioTest\\1.txt" ));
InputStream in = new BufferedInputStream(new FileInputStream( "F:\\ioTest\\1.txt" );
字节流读取的测试案例
// 注：该案例需要导入包，及处理异常，请自行处理
// 1.创建字节读取对象
// InputStream in = new FileInputStream("F:\\ioTest\\1.txt");
InputStream in = new BufferedInputStream(new FileInputStream("F:\\ioTest\\1.txt")); // 效率较高
// 2.开始读取数据
int data = 0;
while((data = in.read()) != -1) {
System.out.println(data);
}
// 3.释放资源
in.close();
字符流的写出
OutputStream类
OutputStream类是抽象类，表示输出字节流的所有类的超类/父类。
public abstract class OutputStream{} // OutputStream类 是 抽象类
public class FileOutputStream extends OutputStream{} // OutputStream类 是FileOutputStream类 的父类/超类
public class FilterOutputStream extends OutputStream{}
public class BufferedOutputStream extends FilterOutputStream {} // OutputStream类 是 BufferedOutputStream类 的父类/超类
常用方法：
- 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) 将指定的字节写入此输出流。
FileOutputStream子类
创建对象的方式：
- FileOutputStream(File file) 创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
- FileOutputStream(File file, boolean append) 创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
- FileOutputStream(String name) 创建一个向具有指定名称的文件中写入数据的输出文件流。
- FileOutputStream(String name, boolean append) 创建一个向具有指定 name 的文件中写入数据的输出文件流。
OutputSteam out1 = new FileOutputStream( new File( "F:\\ioTest\\1.txt" ) ); //写入数据 覆盖原来的数据
OutputSteam out2 = new FileOutputStream( new File( "F:\\ioTest\\1.txt" ), true ); //写入数据 追加数据
OutputSteam out3 = new FileOutputStream( "F:\\ioTest\\1.txt" ); //写入数据 覆盖原来的数据
OutputSteam out4 = new FileOutputStream( "F:\\ioTest\\1.txt", true ); //写入数据 追加数据
高效BufferedOutputStream子类
BufferedOutputStream之所以高效，其根本原因在于创建 BufferedOutputStream时，会创建一个内部缓冲区数组。当缓存数组满了后，可以一次性写入多个字节。
/**
* The internal buffer where data is stored.
*/
protected byte buf[]; // 源码中的缓存数组 大小默认8kb = 8 * 1024
创建对象
- public BufferedOutputStream(OutputStream out) 创建一个新的缓冲输出流，以将数据写入指定的底层输出流。
OutputStream out = new BufferedOutputStream( new FileStream( new File("F:\\ioTest\\1.txt") ) );
OutputStream out2 = new BufferedOutputStream( new FileStream( "F:\\ioTest\\1.txt" ) );
字节流写入的案例
try {
// 1、创建对象
OutputStream out = new FileOutputStream("F:\\ioTest\\1.txt",true); // 有第二个boolean参数，追加数据
// OutputStream out2 = new FileOutputStream(new File("F:\\ioTest\\1.txt")); //没有第二个boolean参数，会覆盖原来的数据
// 2、写出数据
for (int i = 65; i < 91; i++) { // A-Z
out.write(i);
}
out.close(); //关闭资源
// 3、释放数据
out.close();
} catch (IOException e) {
e.printStackTrace();
}
