【JavaEE】文件操作(二):流对象的文件内容操作、文件基础(二):数字&码表&缓冲区

|---------------|------------------------------------------------------------------------------------------------------------------------------------------------------------|
| 2/8/16 => 10 | ： |
| 10 => 2/816 | 十进制的首次被除数与接下来的商 / 进制 直到商为0 的余数取完反连 |
| 16 <=> 2 | 1个十六进制数 = 4个二进制数 = 4个bit位（16 = 2^4） |
| 8 <=> 2 | 1个八进制数 = 3个二进制数 = 3个bit位（8 = 2^3） |
[之间转化]

2.1.1二进制

数字的二进制01形式是计算机读写计量的操作实体

2.2类型

数字类型	关键字	内存占用	范围
字节型	byte	1 字节	-128 ~ 127
短整型	short	2 字节	-32768 ~ 32767
整型	int	4 字节	-2^31 ~ (2^31) - 1
长整型	long	8 字节	-2^63 ~ (2^63) - 1
单精度浮点数	float	4 字节	-3.4×10³⁸ ~ 3.4×10³⁸（有效位数 6~7 位）
双精度浮点数	double	8 字节	-1.8×10³⁰⁸ ~ +1.8×10³⁰⁸（有效位数 15~17 位）
[基本类型]

非数字类型	关键字	内存占用	范围
字符型	char	2 字节	0 ~ 65535
布尔型	boolean	没有明确规定(1字节)	true 和 false

2.2.1符号子类型

Java的数字类型不再割分有无符号 的子类型，数字类型全部都是无符号的

数字类型有无符号的差别 在它们的二进制形式中玲琳体现出来：

2.2.1.1有符号数

有符号数的首位是符号位，byte的有符号类型的8位的二进制形式 - 1个bit符号位、7个bit数值位：

min：++1++0000000 = -128
max：++0++1111111 = +127

-127的原码:11111111, 补码:10000001

-127 - 1 = -128的补码:10000000, 原码:++1++0000000 -> 形式-0但意义值是-128

0的原码:++0++0000000 -> 0已经用+0表示了

可以表示十进制下**-128~127**的256个数：负数128个 + 零1个 + 正数127个 = 2^7 + 1 + 2^7-1 = 2^7 * 2 = 2^8 = 256个数

2.2.1.2无符号数

无符号数的全位是数值位，byte的无符号类型的8位的二进制形式 - 8个bit数值位：

min：00000000 = 0
max：11111111 = 255

可以表示十进制下0~255的256个数：零1个 + 正数256个 = 1 + 2^8-1 = 2^8 = 256个数

3.码表

码表由 数字互键字符 的两个字段组成：

数字	字符
同一个数的++二进制01形式++是计算机读写计量的操作实体	++常在表间关联++
[码表]

4.缓冲区

缓冲区是 内存里的 临时存储区域，本质是 用空间换时间

4.1作用

缓冲区 攒存开一次****内存<->外设 通道 去交互的更多数据：

写 存数据在缓冲区每次向外通道多写
读 存数据在缓冲区每次向内通道多读

减少了内外交互数据去开通道的总次 带来的 外设响应的时间开销 、系统调用的cpu内核-用户态的切换开销

4.2实现

4.2.1内存变量

内存中手动创建缓冲区变量 攒存交互

4.2.2缓冲区流对象

传流对象参向下构造 创建扩展的自带缓冲区流对象

java 复制代码

BufferedStream bufferedstream = new BufferedStream(stream);

二、文件操作(二):流对象的文件内容操作

知识连接：文件操作(一):文件系统操作

1.打开文件

创建流对象打开文件 读写操作 流储在文件描述符表的内容流

1.1字节流

文件内容以字节单位地流；不参照码表：直接读写二进制字节

1.1.1输入流new ++File++InputStream(file)
java 复制代码
InputStream inputStream = new FileInputStream(file);
流对象 直接读取 在文件描述符表 的 文件流出 的字节流

1.1.1.1read():int
java 复制代码
int data = inputStream.read();
读取****一个整字节 的8个二进制01数

等价成 1个0~256在int范围的十进制数 返回

等到 读取完字节/读取到内容流末尾/抛出异常 结束

1.1.1.2read(byte[] b, int off, int len):int
java 复制代码
byte[] b = new byte[1024];
int n = inputStream.read(b,0,1024);
读取 指定个整字节 的二进制01数放在外面的字节数组的指定部分

返回 实际读整的字节个数

等到读取完字节/读取到内容流末尾/抛出异常结束

操作文件指针端 不能自选位置

1.1.1.3read(byte b[]):int
java 复制代码
byte[] data = new byte[1024];
int n = inputStream.read(data);//从字节数组偏移量0位置开始放 读取的数组长度个的字节
读取 字节数组长度个整字节 的二进制01数放在外面的全部字节数组

返回 实际读整的字节个数

等到读取完字节/读取到内容流末尾/抛出异常结束

方法出值

方法内部可用 引用外存 或 return返回 出值

1.1.2输出流new ++File++OutputStream(file, boolean)
java 复制代码
OutputStream outputStream = new FileOutputStream(file, boolean);
流对象 直接写入 在文件描述符表 的 文件流入 的字节流

1.1.2.1write(int b):void
java 复制代码
outputStream.write(97);
写入整体等价用1个0~256在int范围的十进制数表示的 一个整字节8个二进制01数

1.1.2.2write(byte[] b, int off, int len):void
java 复制代码
byte[] bytes = {97,98,99};
outputStream.write(bytes,0,3);
写入 字节数组的指定部分的整字节的二进制01数

1.1.2.3write(byte[] b):void
java 复制代码
byte[] bytes = {97,98,99};
outputStream.write(bytes);//从字节数组偏移量0位置开始取 写入的数组长度个的字节
写入 全部字节数组的整字节的二进制01数
写文件

文件不存在
文件不存在打开会创建文件全新写（创建文件后清空与追加结果都是全新写）

文件存在
2.1清空写
文件存在打开会清空内容空白写：
java 复制代码
OutputStream outputStream = new FileOutputStream(file/*, false*/);
Writer writer = new FileWriter(file/*, false*/);
2.2追加写
文件存在打开会追加内容往后写：
java 复制代码
OutputStream outputStream = new FileOutputStream(file, true);
Writer writer = new FileWriter(file,true);

1.2字符流

文件内容以字符单位地流；参照码表 ：读字符的字节 -> 再取字节的字符、写字符的字节 -> 再入字节的字符

码表的参照

FileReader/FileWriter 默认参照 系统编码 ：

java 复制代码

// 文件test.txt是UTF-8编码，系统默认编码是GBK编码

try (FileReader fr = new FileReader("test.txt")) {
    char[] chars = new char[1024];
    int len = fr.read(chars); //1.默认使用GBK码表读UTF8文件的字节、默认使用GBK码表取字节对应字符 -> 读乱码
    String content = new String(chars, 0, len);
    System.out.println(content);
}
try (FileWriter fw = new FileWriter("test.txt")) {
    String content = "Hello World";
    fw.write(content); //2.默认使用GBK码表写UTF8文件的字节、默认使用GBK码表入字节对应字符 -> 写乱码
    System.out.println("FileWriter写入完成（默认GBK编码）");
}

InputStreamReader/OutputStreamWriter 手动参照 指定编码 ：

java 复制代码

try (FileInputStream fis = new FileInputStream("test.txt");
     InputStreamReader isr = new InputStreamReader(fis, StandardCharsets.UTF_8)) { //3.指定使用UTF8码表
    char[] chars = new char[1024];
    int len = isr.read(chars); //正确读字符
    String content = new String(chars, 0, len);
    System.out.println(content);
}
try (FileOutputStream fos = new FileOutputStream("test.txt");
     OutputStreamWriter osw = new OutputStreamWriter(fos, StandardCharsets.UTF_8)) { //4.指定使用UTF8码表
    osw.write("Hello World"); //正确写字符
}

1.2.1输入流new ++File++Reader(file)
java 复制代码
Reader reader = new FileReader(file);
流对象 参照码表读取 在文件描述符表 的 文件流出 的字符流

1.2.1.1read():int
java 复制代码
int data = reader.read();
参照码表 读****一个字符的字节量 二进制01数

等价成1个0~256在int范围的十进制数返回 ---> 参照码表 取****数字对应的字符

等到读取完字符/读取到字节流末尾/发生IO错误结束

1.2.1.2read(char[] cbuf, int off, int len):int
java 复制代码
char[] cbuf = new char[1024];
int n = reader.read(cbuf,0,1024);
参照码表 读****指定个字符的字节量 二进制01数 ---> 参照码表 取****数字对应的字符 存出放到****字符数组的指定部分

返回 实际读取的字符个数

等到读取完字符/读取到字节流末尾/发生IO错误结束

1.2.1.3read(char[] cbuf):int
java 复制代码
char[] cbuf = new char[1024];
int n = reader.read(cbuf); //从字符数组偏移量0位置开始放 读取的数组长度个的字符
参照码表 读****字符数组长度个字符的字节量 二进制01数 ---> 参照码表 取****数字对应的字符 存出放到****全部字符数组

返回 实际读取的字符个数

等到读取完字符/读取到字节流末尾/发生IO错误结束

1.2.1.4read(CharBuffer target):int

存放的CharBuffer是 char[]的封装

1.2.2输出流new ++File++Writer(file, boolean)
java 复制代码
Writer writer = new FileWriter(file, true);
流对象 参照码表写入 在文件描述符表 的 文件流入 的字符流

1.2.2.1write(int b):void
java 复制代码
writer.write(97);
写整体等价用1个0~256在int范围的十进制数表示的 一个整字节 8个二进制01数 ---> 参照码表入 数字对应的字符

1.2.2.2write(char[] cbuf, int off, int len):void
java 复制代码
char[] cbuf = new char[3]; cbuf[0] = 'a'; cbuf[1] = 'b'; cbuf[2] = 'c';
writer.write(cbuf,0,3);
参照码表写 字符数组的指定部分的每个字符对应数字 二进制01数 ---> 参照码表入 每个数字对应的字符

1.2.2.3write(char[] cbuf):void
java 复制代码
char[] cbuf = new char[3]; cbuf[0] = 'a'; cbuf[1] = 'b'; cbuf[2] = 'c';
writer.write(cbuf); //从字符数组偏移量0位置开始取 写入的数组长度个的字符
参照码表写 全部字符数组的每个字符对应数字 二进制01数；参照码表入 每个数字对应的字符

1.2.2.4write(String str, int off, int len):void
java 复制代码
String str = "abc";
writer.write(str,0,3);
写入的String****等价于char[]

1.2.2.5write(String str):void
java 复制代码
String str = "abc";
writer.write(str);
写入的String等价于 char[]

2.关闭文件

java 复制代码

stream.close();

调用流对象关闭文件 回收销毁 ++存储内容流的文件描述符表++

2.1文件泄露

打开文件 使用资源结束 后，不关闭回收 文件就在泄露文件资源

2.1.1危害

文件资源 无用地占据着在外：

泄减了 供使用的内部资源
露增了 无故修改资源的权限

内存自动回收

Java的内存不需要手动回收 ，JVM封装 好了 自动管理内存回收的GC，++不会发生内存泄露的情况++

2.2绑定关闭

文件有去打开 就必执关闭 的 捆绑执行写法：

2.2.1try{new}finally{close}

java 复制代码

InputStream inputStream = null;
try {
    inputStream = new FileInputStream("./test.txt");
    throw new IOException();
    return;
} finally {
    inputStream.close();
}

2.2.2try(new){}

java 复制代码

try (InputStream inputStream = new FileInputStream("./test.txt")) {
    throw new IOException();
    return;
} finally {
    inputStream.close();
}

try()里面创建实现Closeable接口 的流对象的实例，**出代码块{}**后 JVM会调用Closeable接口变量的close方法转型执行关闭

点个关注再走呗（＾＿＾）☆