文件
计算机上的文件
不论是可执行文件、图片文件、视频文件、Word文件、压缩文件、txt文件，实际上都是二进制：由许多的 0 和 1 组成
我们看到的 视频、图片 都是由程序去解析这些 0 和 1 所呈现出来的
文件可以大致分为 文本文件 与 二进制文件
文本文件
虽然他们在底层都是以二进制的 0 和 1 存储的，但是文本文件的每个字节都是计算机可以直接打印出来的字符，例如 字符 a，数字 12 等
例如在一个 txt 文本文件中写入一个字符 a
这就涉及到计算机中种类繁多的编码格式了
那么 a 在 txt 文件中存放的就是 a 的编码值，可以使用工具查看 a 的进制数据
61 表示 a 编码值的 十六进制形式，a 的 utf8 编码值为 97，而 97 的十六进制就是 61
可以看出文本文件存放的数据字节单独拿出来都是可以由计算机直接进行打印的字符，可以使用普通的文本编辑器直接打开
区别在于编码格式
二进制文件
与文本文件不同，二进制文件的字节不一定就是计算机能直接解析打印的字符，如 pdf 文件，如果使用文本编辑器的方式直接打开就会出现一堆乱码
因为计算机无法直接进行打印，它的某一个字节可能表示 颜色、字体等
二进制文件的字节表示的含义是不一定的，这种文件需要特定的程序进行处理才能有友好的展示
程序读取文件也就是读取文件的二进制数据，许多的 0 和 1 就像水流一样被读取到内存中，所以文件的处理也被称为 流
将文件的二进制流读取进来，经过处理，可以再写出到文件中
java 二进制读写流
java 中以二进制读写流的方式主要有
- InputStream/OutputStream：这是基类，它们是抽象类
- FileInputStream/FileOutputStream：输入源和输出目标是文件的流
- ByteArrayInputStream/ByteArrayOutputStream：输入源和输出目标是字节数组的流
- DataInputStream/DataOutputStream：装饰类，按基本类型和字符串读写流
- BufferedInputStream/BufferedOutputStream：装饰类，对输入输出流提供缓冲功能
抽象类 InputStream/OutputStream
二进制读写流的基本类，其中定义了读写的基本方法
InputStream 的基本方法
// 默认读取流中一个字节，当读取到结尾时，返回 -1
public abstract int read() throws IOException;
// 按照字节数组大小读取字节
public int read(byte b[]) throws IOException {
return read(b, 0, b.length);
}
// 读取的第一个字节放入b[off]，最多读取len个字节
public int read(byte b[], int off, int len) throws IOException {
Objects.checkFromIndexSize(off, len, b.length);
if (len == 0) {
return 0;
}
int c = read();
if (c == -1) {
return -1;
}
b[off] = (byte)c;
int i = 1;
try {
for (; i < len ; i++) {
c = read();
if (c == -1) {
break;
}
b[off + i] = (byte)c;
}
} catch (IOException ee) {
}
return i;
}
// 关闭字节流，释放资源
public void close() throws IOException {}
OutputStream 的基本方法
// 向流中写入一个字节，参数为 int
// java 中 int 占 4 个字节，但是此方法只会用到低8位的一个字节
public abstract void write(int b) throws IOException;
// 以字节数组方式向流中写入字节
public void write(byte b[]) throws IOException {
write(b, 0, b.length);
}
//第一个写入的字节是b[off]，写入个数为len
public void write(byte b[], int off, int len) throws IOException {
Objects.checkFromIndexSize(off, len, b.length);
// len == 0 condition implicitly handled by loop bounds
for (int i = 0 ; i < len ; i++) {
write(b[off + i]);
}
}
FileInputStream/FileOutputStream
文件输入/输出流
它们的输入源和输出目标为文件
FileOutputStream
FileOutputStream 几个主要的构造方法
// 传入文件路径字符串或者直接传入文件 File 对象
// 布尔类型参数 append 表示在文件后追加还是覆盖
// true 表示追加 false 表示覆盖
public FileOutputStream(String name) throws FileNotFoundException {
this(name != null ? new File(name) : null, false);
}
public FileOutputStream(String name, boolean append) throws FileNotFoundException
{
this(name != null ? new File(name) : null, append);
}
public FileOutputStream(File file) throws FileNotFoundException {
this(file, false);
}
public FileOutputStream(File file, boolean append) throws FileNotFoundException
{
String name = (file != null ? file.getPath() : null);
SecurityManager security = System.getSecurityManager();
if (security != null) {
security.checkWrite(name);
}
if (name == null) {
throw new NullPointerException();
}
if (file.isInvalid()) {
throw new FileNotFoundException("Invalid file path");
}
this.fd = new FileDescriptor();
fd.attach(this);
this.path = name;
open(name, append);
altFinalizer = getFinalizer(this);
if (altFinalizer == null) {
FileCleanable.register(fd); // open sets the fd, register the cleanup
}
}
实践
OutputStream outputStream = null;
try {
outputStream = new FileOutputStream("D:\\hello.txt");
String data = "hello yang";
byte b[] = data.getBytes(Charset.forName("UTF-8"));
outputStream.write(b);
} catch (IOException e) {
e.printStackTrace();
}finally {
try {
outputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
上面代码创建了一个文件输出流，文件路径为 D:\hello.txt，然后定义了一个字符串，获取字符串的字节数组，将其写入到这个输出流，最终将数据输出到文件中
值得注意的是，获取字符串字节数组时所使用的 Charset.forName(“UTF-8”)
它表示使用 UTF-8 编码格式获取字符串的字节
由于字符串的具体编码格式与操作系统的编码格式有关系
而不同编码格式的字符可能占用的字节并不相同
所以在这里规定了获取 UTF-8 编码的字节数
FileInputStream
FileInputStream 的几个主要构造方法
// 传入一个 文件路径 或者 File 对象，从对应文件中读取输入流
public FileInputStream(String name) throws FileNotFoundException {
this(name != null ? new File(name) : null);
}
public FileInputStream(File file) throws FileNotFoundException {
String name = (file != null ? file.getPath() : null);
SecurityManager security = System.getSecurityManager();
if (security != null) {
security.checkRead(name);
}
if (name == null) {
throw new NullPointerException();
}
if (file.isInvalid()) {
throw new FileNotFoundException("Invalid file path");
}
fd = new FileDescriptor();
fd.attach(this);
path = name;
open(name);
altFinalizer = getFinalizer(this);
if (altFinalizer == null) {
FileCleanable.register(fd); // open set the fd, register the cleanup
}
}
实践
前面通过输出流将字符串 hello yang 写入到了 txt 文件中
这一步通过 FileInputStream 读取此文件
InputStream inputStream = null;
try {
inputStream = new FileInputStream("D:\\hello.txt");
byte[] bytes = new byte[1024];
int readBytes = 0 ;
readBytes = inputStream.read(bytes);
System.out.println(new String(bytes,0,readBytes,Charset.forName("UTF-8")));
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
inputStream.close();
} catch (Exception e) {
e.printStackTrace();
}
}
上面的代码将 hello.txt 文件的字节读取存放到字节数组 bytes 中，并返回实际读取的字节数，然后将 从 bytes[0] 开始、readBytes 长度的字节转换为 String，最终输出
此种方式存在一个问题
hello.txt 文件中实际存放的数据 hello yang 只占用了 10 个字节，所以将其所有字节读取存放到大小为 1024 的字节数组是没有问题的
但是如果读取的文件大小超过数组大小或者读取文件的时候并不知道文件的实际大小，就无法一次性将文件的所有字节读入
该如何去做呢？这种情况下就需要使用循环
InputStream inputStream = null;
try {
inputStream = new FileInputStream("D:\\hello.txt");
byte[] bytes = new byte[1];
int readBytes = 0 ;
StringBuffer str = new StringBuffer();
while ( (readBytes = inputStream.read(bytes)) != -1){
System.out.println("读取了"+readBytes+"个字节 数据为:"+new String(bytes,0,readBytes,Charset.forName("UTF-8")));
str.append( new StringBuffer( new String(bytes,0,readBytes,Charset.forName("UTF-8")) ) );
}
System.out.println(str);
// hello yang
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
inputStream.close();
} catch (Exception e) {
e.printStackTrace();
}
}
上述代码定义了小于 hello.txt 字节大小的长度为 1 的字节数组，每次从文件中读取一个字节，使用 StringBuffer 进行拼接，最终输出数据
尽管使用这种方式做到了 不需要知道文件的实际字节数也能获得文件中的字符串，但是如果文件中的字节并不是单纯的表示字符
而表示的是其他类型，这样去截断读取字节是不严谨的
ByteArrayInputStream/ByteArrayOutputStream
字节数组输入/输出流
它们的输入源和输出目标为字节数组
ByteArrayOutputStream
ByteArrayOutputStream 的主要构造方法
ByteArrayOutputStream 的输出目标是一个字节数组
这个数组的长度会根据实际的读取字节进行动态扩展
// 无参构造默认内部的字节数组大小为 32
// 有参构造则可以指定数组的初始大小
public ByteArrayOutputStream() {
this(32);
}
public ByteArrayOutputStream(int size) {
if (size < 0) {
throw new IllegalArgumentException("Negative initial size: "
+ size);
}
buf = new byte[size];
}
ByteArrayOutputStream 还有一些主要方法
例如直接将字节数组转换为指定的编码格式字符串
将字节写入到另一个输出流
// 返回字节数组
public synchronized byte[] toByteArray() {
return Arrays.copyOf(buf, count);
}
// 将字节数组转换为字符串，使用系统默认编码
public synchronized String toString() {
return new String(buf, 0, count);
}
// 将字节数组转换为字符串，可以指定编码
public synchronized String toString(String charsetName)
throws UnsupportedEncodingException
{
return new String(buf, 0, count, charsetName);
}
// 获取数组大小
public synchronized int size() {
return count;
}
// 重置数组大小为 0
public synchronized void reset() {
count = 0;
}
// 将字节写入到另一个输出流
public synchronized void writeTo(OutputStream out) throws IOException {
out.write(buf, 0, count);
}
上一步的问题使用 ByteArrOutputStream 的方式就很好解决
InputStream inputStream = null;
ByteArrayOutputStream byteArrayOutputStream = null;
try {
inputStream = new FileInputStream("D:\\hello.txt");
byte[] bytes = new byte[1];
int readBytes = 0 ;
byteArrayOutputStream = new ByteArrayOutputStream();
while ( (readBytes = inputStream.read(bytes)) != -1){
byteArrayOutputStream.write(bytes,0,readBytes);
}
System.out.println(byteArrayOutputStream.toString("UTF-8"));
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
inputStream.close();
} catch (Exception e) {
e.printStackTrace();
}
}
上述的代码同样定义了一个小于文件字节大小的字节数组，循环读取，并把每次读取到的字节写入到 byteArrOutputStream，由于 ByteArrOutputStream 内部数组是动态扩容的，我们不需要关心文件实际字节是多大，循环结束时，ByteArrOutputStream 中的字节数组就是文件的所有字节，这时直接可以使用 toString() 方法将其转换为字符串
就算文件中并不是所有的字节都表示字符，但是已经拿到所有的字节数组，做相应的处理也就没有问题
ByteArrayInputStream
ByteArrayInputStream 主要构造方法
// 将字节数组包装成为一个输入流
public ByteArrayInputStream(byte buf[]) {
this.buf = buf;
this.pos = 0;
this.count = buf.length;
}
// 将字节数组包装成为一个输入流 从 byte[offset] 开始，length 个长度
public ByteArrayInputStream(byte buf[], int offset, int length) {
this.buf = buf;
this.pos = offset;
this.count = Math.min(offset + length, buf.length);
this.mark = offset;
}
为什么要将字节数组包装成输入流呢？
在我们使用输入流读取文件时，最终读取到的就是字节，既然已经有了字节数组，为什么还要将字节数组转换为输入流呢？
有很多代码是以InputStream/OutputSteam为参数构建的，它们构成了一个协作体系，将byte数组转换为InputStream可以方便地参与这种体系，复用代码
DataInputStream/DataOutputStream
前面的几个 输入/输出 流都只能以字节为单位读取
java 还提供了以基本数据类型为单位的 输出/输出 流 DataInputStream/DataOutputStream
它们都属于 装饰类，这里就涉及到设计模式中的 装饰器 模式了
DataOutputStream
DataOutputStream 构造方法
// 传入一个已有的输出流，DataOutputStream 的主要方法会被传入的输出流代理
public DataOutputStream(OutputStream out) {
super(out);
}
DataOutputStream 的几个主要方法
// 写入一个布尔类型的值，如果为 true 写入 1，反之 写入 0
public final void writeBoolean(boolean v) throws IOException {
out.write(v ? 1 : 0);
incCount(1);
}
// 写入4个字节，最高位字节先写入，最低位最后写入
public final void writeByte(int v) throws IOException {
out.write(v);
incCount(1);
}
// 将字符串的UTF-8编码字节写入
public final void writeUTF(String str) throws IOException {
writeUTF(str, this);
}
评论区