IO流
IO流
-
什么是IO流？
存储和读取数据的解决方案I：input
O：output
流：像水流一样传输数据
-
IO流的作用？
用于读写数据（本地文件，网络）
-
IO流按照流向可以分类哪两种流？
输出流：程序 -> 文件
输入流：文件 -> 程序
-
IO流按照操作文件的类型可以分类哪两种流？
字节流：可以操作所有类型的文件
字符流：只能操作纯文本文件
-
什么是纯文本文件？
用windows系统自带的记事本打开并且能读懂的文件
txt文件，md文件，xml文件，lrc文件等
(word, excel不是纯文本文件)
字节流
FileOutputStream
-
字节输出流FileOutputStream：操作本地文件的字节输出流，可以把程序中的数据写到本地文件中
书写步骤：- 创建字节输出流对象
- 写数据
- 创建资源
例子：写出一段文字到本地文件中。（暂时不写中文）
public static void main(String[] args) throws IOException { /* * 演示：字节输出流FileOutputStream * 实现需求：写出一段文字到本地文件中。（暂时不写中文） * * 实现步骤： * 创建对象 * 写出数据 * 释放资源 * */ //1.创建对象 //写出 输出流 OutputStream //本地文件 File // 注：FileOutputStream 要抛出异常IOException FileOutputStream fos = new FileOutputStream("myio\\a.txt"); //2.写出数据 fos.write(97); //a //3.释放资源 fos.close(); } -
字节输出流的细节：
- 创建字节输出流对象
细节1：参数是字符串表示的路径或者是File对象都是可以的
细节2：如果文件不存在会创建一个新的文件，但是要保证父级路径是存在的。
细节3：如果文件已经存在，则会清空文件 - 写数据
细节：write方法的参数是整数，但是实际上写到本地文件中的是整数在ASCII上对应的字符
如果真的要写数字，就要把每个数字位看成字符，写数字的ASCII码
‘9’：57
‘7’：55 - 释放资源
每次使用完流之后都要释放资源，否则建立连接的通道不会关闭，占用内存
- 创建字节输出流对象
-
FileOutputStream写数据的3种方式：
（注意第三种方式的参数可能和你想的不一样，第二个参数是起始索引，第三个参数是长度）public static void main(String[] args) throws IOException { /* void write(int b) 一次写一个字节数据 void write(byte[] b) 一次写一个字节数组数据 void write(byte[] b, int off, int len) 一次写一个字节数组的部分数据 参数一： 数组 参数二： 起始索引 0 参数三： 个数 3 */ //1.创建对象 FileOutputStream fos = new FileOutputStream("myio\\a.txt"); //2.写出数据 //fos.write(97); // a //fos.write(98); // b byte[] bytes = { 97, 98, 99, 100, 101}; /* fos.write(bytes);*/ fos.write(bytes,1,2);// b c //3.释放资源 fos.close(); } -
两个问题：如何换行？如何续写？
-
换行写：
再次写出一个换行符就可以了windows： \r\n Linux: \n Mac: \r- 细节
在windows操作系统当中，java对回车换行进行了优化。
虽然完整的是\r\n，但是我们写其中一个\r或者\n，
java也可以实现换行，因为java在底层会补全。 - 建议：
不要省略，还是写全了。
- 细节
-
续写：
如果想要续写，打开续写开关即可
开关位置：创建对象的第二个参数
默认false：表示关闭续写，此时创建对象会清空文件
手动传递true：表示打开续写，此时创建对象不会清空文件
public static void main(String[] args) throws IOException { /* 换行写： 再次写出一个换行符就可以了 windows： \r\n Linux: \n Mac: \r 细节： 在windows操作系统当中，java对回车换行进行了优化。 虽然完整的是\r\n，但是我们写其中一个\r或者\n， java也可以实现换行，因为java在底层会补全。 建议： 不要省略，还是写全了。 续写： 如果想要续写，打开续写开关即可 开关位置：创建对象的第二个参数 默认false：表示关闭续写，此时创建对象会清空文件 手动传递true：表示打开续写，此时创建对象不会清空文件 */ //1.创建对象 FileOutputStream fos = new FileOutputStream("myio\\a.txt",true); //2.写出数据 String str = "kankelaoyezuishuai"; byte[] bytes1 = str.getBytes(); fos.write(bytes1); //再次写出一个换行符就可以了 String wrap = "\r\n"; byte[] bytes2 = wrap.getBytes(); fos.write(bytes2); String str2 = "666"; byte[] bytes3 = str2.getBytes(); fos.write(bytes3); //3.释放资源 fos.close(); } -
FileInputStream
- 字节输出流FileInputStream：操作本地文件的字节输入流，可以把本地文件中的数据读到程序中
书写步骤：- 创建字节输出流对象
- 细节：如果文件不存在，直接报错
- 读数据
- 细节1：一次读一个字节，读出来的数据是在ASCII上对应的数字，如果想显示原内容，可以用(char)强转
- 细节2：读到文件末尾了，read方法返回-1.
- 创建资源
- 每次使用完流必须释放资源
- 创建字节输出流对象
例子：读文本中的数据
public static void main(String[] args) throws IOException {
/*
* 演示：字节输入流FileInputStream
* 实现需求：读取文件中的数据。（暂时不写中文）
*
* 实现步骤：
* 创建对象
* 读取数据
* 释放资源
* */
//1.创建对象
FileInputStream fis = new FileInputStream("myio\\a.txt");
//2.读取数据
int b1 = fis.read();
System.out.println((char)b1);
int b2 = fis.read();
System.out.println((char)b2);
int b3 = fis.read();
System.out.println((char)b3);
int b4 = fis.read();
System.out.println((char)b4);
int b5 = fis.read();
System.out.println((char)b5);
int b6 = fis.read();
System.out.println(b6);//-1
//3.释放资源
fis.close();
}
-
FileInputStream循环读取
public static void main(String[] args) throws IOException { /* 字节输入流循环读取 */ //1.创建对象 FileInputStream fis = new FileInputStream("myio\\a.txt"); //2.循环读取 int b; while ((b = fis.read()) != -1) { System.out.println((char) b); } //3.释放资源 fis.close(); }问题：不定义变量b可不可以？
/* * read :表示读取数据，而且是读取一个数据就移动一次指针 * * */ FileInputStream fis = new FileInputStream("myio\\a.txt"); //2.循环读取 while ((fis.read()) != -1) { System.out.println(fis.read());//98 100 -1 } //3.释放资源 fis.close();答：不可以。因为 read读取数据，读取一个数据就移动一次指针，因此调用两次fis.read()后指针移动了两次，不能完整输出数据
-
文件拷贝
细节：先打开的后关闭
（以下代码边读边写，一个字节一个字节读写，效率太低，只能拷贝小文件）public static void main(String[] args) throws IOException { /* * 练习： * 文件拷贝 * 把D:\itheima\movie.mp4拷贝到当前模块下。 * * 注意： * 选择一个比较小的文件，不要太大。大文件拷贝我们下一个视频会说。 * * * * 课堂练习： * 要求统计一下拷贝时间，单位毫秒 * */ long start = System.currentTimeMillis(); //1.创建对象 FileInputStream fis = new FileInputStream("D:\\itheima\\movie.mp4"); FileOutputStream fos = new FileOutputStream("myio\\copy.mp4"); //2.拷贝 //核心思想：边读边写 int b; while((b = fis.read()) != -1){ fos.write(b); } //3.释放资源 //规则：先开的最后关闭 fos.close(); fis.close(); long end = System.currentTimeMillis(); System.out.println(end - start); }解决方式： public int read(byte[] buffer) 一次读一个字节数组数据，返回值是读取的字节长度
如果读到最后不够字节数组的长度了，那么只会读取剩下的字节，返回的是剩下的字节长度。此时数组里面还存在上次读取的字节，这样最后一次就会多拷贝出来一些东西。因此用String str1 = new String(bytes,0,len1)、fos.write(bytes, 0, len)确保最后一次读取的是正确的字节数。public static void main(String[] args) throws IOException { /* public int read(byte[] buffer) 一次读一个字节数组数据 */ //1.创建对象 FileInputStream fis = new FileInputStream("myio\\a.txt"); //2.读取数据 byte[] bytes = new byte[2]; //一次读取多个字节数据，具体读多少，跟数组的长度有关 //返回值：本次读取到了多少个字节数据 int len1 = fis.read(bytes); System.out.println(len1);//2 String str1 = new String(bytes,0,len1); System.out.println(str1); int len2 = fis.read(bytes); System.out.println(len2);//2 String str2 = new String(bytes,0,len2); System.out.println(str2); int len3 = fis.read(bytes); System.out.println(len3);// 1 String str3 = new String(bytes,0,len3); System.out.println(str3);// ed //3.释放资源 fis.close(); }拷贝大文件：
public static void main(String[] args) throws IOException { /* * 练习： * 文件拷贝 * 把D:\itheima\movie.mp4 (16.8 MB) 拷贝到当前模块下。 * * */ long start = System.currentTimeMillis(); //1.创建对象 FileInputStream fis = new FileInputStream("D:\\itheima\\movie.mp4"); FileOutputStream fos = new FileOutputStream("myio\\copy.mp4"); //2.拷贝 int len; byte[] bytes = new byte[1024 * 1024 * 5]; while((len = fis.read(bytes)) != -1){ fos.write(bytes,0,len); } //3.释放资源 fos.close(); fis.close(); long end = System.currentTimeMillis(); System.out.println(end - start); } -
IO流try…catch异常处理注意事项（了解）：释放资源语句要放在finally里确保一定会被执行。
无论try里有没有异常，finally里的代码一定会被执行，除非虚拟机停止
public static void main(String[] args) {
/*
* 利用try...catch...finally捕获拷贝文件中代码出现的异常
*/
//1.创建对象
FileInputStream fis = null;
FileOutputStream fos = null;
try {
fis = new FileInputStream("D:\\itheima\\movie.mp4");
fos = new FileOutputStream("myio\\copy.mp4");
//2.拷贝
int len;
byte[] bytes = new byte[1024 * 1024 * 5];
while((len = fis.read(bytes)) != -1){
fos.write(bytes,0,len);
}
} catch (IOException e) {
//e.printStackTrace();
} finally {
//3.释放资源
if(fos != null){
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
//如果创建fis/fos的路径不存在时就不会创建字节流，这样fis和fos就还是null
//如果不加以判断就会出现空指针异常的错误，所以要加个非空判断
if(fis != null){
try {
//fis.close()也会有异常出现，所以在finally里又嵌套了一个try catch捕获异常
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
上述代码的简化：AutoCloseable，不需要写finally，自动释放
JDK7：实现了AutoCloseable的类才能在try()中创建对象
JDK9：JDK7不好阅读，所以把创建流对象放外面了
public static void main(String[] args) {
/*
*
* JDK7:IO流中捕获异常的写法
*
* try后面的小括号中写创建对象的代码，
* 注意：只有实现了AutoCloseable接口的类，才能在小括号中创建对象。
* try(){
*
* }catch(){
*
* }
*
* */
try (FileInputStream fis = new FileInputStream("D:\\itheima\\movie.mp4");
FileOutputStream fos = new FileOutputStream("myio\\copy.mp4")) {
//2.拷贝
int len;
byte[] bytes = new byte[1024 * 1024 * 5];
while ((len = fis.read(bytes)) != -1) {
fos.write(bytes, 0, len);
}
} catch (IOException e) {
e.printStackTrace();
}
}
字符集
计算机存储规则：任意数据都是以二进制形式存储的
字节：计算机中最小的存储单位，1字节（byte）=8比特（bit）
存储英文一个字节就够了(ASCII码只有128个)
ASCII码存储规则
咱汉字怎么存？
1、GB2312字符集，1980年发布，1981年5月1日实施的简体中文汉字编码国家标准。收录7445个图形字符，其中包括6763个简体汉字
2、BIG5字符集：台湾地区繁体中文标准字符集，共收录13053个中文字，1984年实施。
3、GBK字符集，2000年3月17日发布，收录21003个汉字。
包含国家标准GB13000-1中的全部中日韩汉字，和BIG5编码中的所有汉字。
windows系统默认使用的就是GBK。系统显示：ANSI
4、Unicode字符集：国际标准字符集，它将世界各种语言的每个字符定义一个唯一的编码，以满足跨语言、跨平台的文本信息转换。
简体中文版Windows用GBK字符集。GBK字符集完全兼容ASCII字符集。
GBK存储规则
制定上述规则的原因：
规则1：2个字节是2^16=65535，能容纳所有汉字。一个字节不够用，三个字节浪费，两个字节刚刚好。
规则2：最高位是1还是0用于区分中文还是英文。
如：下面三个字节很容易看出来是一个一个汉字和一个英文
10111010 10111010 01100001
总结：
1．在计算机中，任意数据都是以二进制的形式来存储的
2．计算机中最小的存储单元是一个字节
3．ASCII字符集中,一个英文占一个字节
4．简体中文版Windows,默认使用GBK字符集
5． GBK字符集完全兼容ASCII字符集
一个英文占一个字节，二进制第一位是0
一个中文占两个字节，二进制高位字节的第一位是1
1990年，国际组织研发了Unicode编码来同一各国编码。
- Unicode编码
UTF-16：16个bit（2字节）存储（浪费空间）
UTF-32：32个bit（4字节）存储（浪费空间）
UTF-8：1~4个字节保存。不同的语言用不同字节数保存。在UTF-8编码中，英文占1个字节，中文占3个字节。中文第一个字节的首位是1，英文是0。
问：1、UTF-8是一个字符集吗？
不是，UTF-8是Unicode字符集的一种编码方式。
2、以下Unicode字符集UTF-8编码规则，有几个中文几个英文？
01001010 01100001 01110110 01100001 4个英文
01001010 01001010 11100110 11001000 11100001 2个英文1个中文
乱码
- 乱码出现的原因：
读取数据时未读完整个汉字
编码和解码时的方式不统一
- 如何避免乱码：
不要用字节流读取文本文件
编码解码时使用同一个码表，同一个编码方式
拷贝为什么不出现乱码：拷贝时目的地的编码方式和数据源的编码方式是一样的，同时读取字节也是完整的，所以不会乱码。
编解码
编码方法：
| String类中的方法 | 说明 |
|---|---|
| public byte[] getBytes() | 使用默认方式进行编码 |
| public byte[] getBytes(String charseName) | 使用指定方式进行编码 |
解码方法：
| String类中的方法 | 说明 |
|---|---|
| String (byte[] bytes) | 使用默认方式进行解码 |
| String (byte[] bytes, String charseName) | 使用指定方式进行解码 |
public static void main(String[] args) throws IOException {
//编码
String str1 = "ai你呀";
byte[] bytes1 = str1.getBytes(); //IDEA默认编码方式是UTF-8
System.out.println(Arrays.toString(bytes1));//问：byte1的长度是多少？
byte[] bytes2 = str1.getBytes("GBK");
System.out.println(Arrays.toString(bytes2)); //问：byte2的长度是多少？
//解码
String str2 = new String(bytes1);
System.out.println(str2);
String str3 = new String(bytes2, "GBK"); //这里如果编解码方式不一样的话就会产生乱码
System.out.println(str3);
}
问题：上述代码中的bytes1 和bytes2的数组长度分别是多少？
字符流
字符流底层就是字节流：字符流=字节流+字符集
特点：
输入流：一次读一个字节，遇到中文时，一读多个字节
输出流：底层会把数据按照指定的编码方式进行编码，变成字节再写到文件中
使用场景：对于纯文本进行读写操作。
FileReader
-
操作步骤
1、创建字符输入流对象
2、读取数据
细节1：按字节进行读取，遇到中文，一次读多个字节，读取后解码，返回一个整数
细节2：读到文件末尾了，read方法返回-13、释放资源（也叫关流）
空参read：
字符流的底层也是字节流，默认也是一个字节一个字节的读取的。
如果遇到中文就会一次读取多个，GBK一次读两个字节，UTF-8一次读三个字节
//read（）细节：
//1.read():默认也是一个字节一个字节的读取的,如果遇到中文就会一次读取多个
//2.在读取之后，方法的底层还会进行解码并转成十进制。
// 最终把这个十进制作为返回值
// 这个十进制的数据也表示在字符集上的数字
// 英文：文件里面二进制数据 0110 0001
// read方法进行读取，解码并转成十进制97
// 中文：文件里面的二进制数据 11100110 10110001 10001001
// read方法进行读取，解码并转成十进制27721
// 我想看到中文汉字，就是把这些十进制数据，再进行强转就可以了
public static void main(String[] args) throws IOException {
/*
第一步：创建对象
public FileReader(File file) 创建字符输入流关联本地文件
public FileReader(String pathname) 创建字符输入流关联本地文件
第二步：读取数据
public int read() 读取数据，读到末尾返回-1
public int read(char[] buffer) 读取多个数据，读到末尾返回-1
第三步：释放资源
public void close() 释放资源/关流
*/
//1.创建对象并关联本地文件
FileReader fr = new FileReader("myio\\a.txt");
//2.读取数据 read()
//字符流的底层也是字节流，默认也是一个字节一个字节的读取的。
//如果遇到中文就会一次读取多个，GBK一次读两个字节，UTF-8一次读三个字节
//read（）细节：
//1.read():默认也是一个字节一个字节的读取的,如果遇到中文就会一次读取多个
//2.在读取之后，方法的底层还会进行解码并转成十进制。
// 最终把这个十进制作为返回值
// 这个十进制的数据也表示在字符集上的数字
// 英文：文件里面二进制数据 0110 0001
// read方法进行读取，解码并转成十进制97
// 中文：文件里面的二进制数据 11100110 10110001 10001001
// read方法进行读取，解码并转成十进制27721
// 我想看到中文汉字，就是把这些十进制数据，再进行强转就可以了
int ch;
while((ch = fr.read()) != -1){
System.out.print((char)ch);
}
//3.释放资源
fr.close();
}
带参read()
与空参read不同，带参read(chars)读取数据，解码，强转三步合并了，把强转之后的字符放到数组当中
public static void main(String[] args) throws IOException {
/*
第一步：创建对象
public FileReader(File file) 创建字符输入流关联本地文件
public FileReader(String pathname) 创建字符输入流关联本地文件
第二步：读取数据
public int read() 读取数据，读到末尾返回-1
public int read(char[] buffer) 读取多个数据，读到末尾返回-1
第三步：释放资源
public void close() 释放资源/关流
*/
//1.创建对象
FileReader fr = new FileReader("myio\\a.txt");
//2.读取数据
char[] chars = new char[2];
int len;
//read(chars)：读取数据，解码，强转三步合并了，把强转之后的字符放到数组当中
//空参的read + 强转类型转换
while((len = fr.read(chars)) != -1){
//把数组中的数据变成字符串再进行打印
System.out.print(new String(chars,0,len));
}
//3.释放资源
fr.close();
}
FileWriter
构造方法
成员方法
-
步骤
1.创建字符输出流对象细节1：参数是字符表示的路径或者File对象都是可以的
细节2：如果文件不存在会创建一个新的文件，但是要保证父级路径是存在的
细节3：如果文件已经存在，则会清空文件，如果不想清空可以打开续写开关
2.写数据
细节：如果write方法的参数是整数，但是实际上写到本地文件中的是整数在字符集上对应的字符
3.释放资源
细节：每次使用完流之后都要释放资源
public static void main(String[] args) throws IOException {
/*
第一步：创建对象
public FileWriter(File file) 创建字符输出流关联本地文件
public FileWriter(String pathname) 创建字符输出流关联本地文件
public FileWriter(File file, boolean append) 创建字符输出流关联本地文件，续写
public FileWriter(String pathname, boolean append) 创建字符输出流关联本地文件，续写
第二步：读取数据
void write(int c) 写出一个字符
void write(String str) 写出一个字符串
void write(String str, int off, int len) 写出一个字符串的一部分
void write(char[] cbuf) 写出一个字符数组
void write(char[] cbuf, int off, int len) 写出字符数组的一部分
第三步：释放资源
public void close() 释放资源/关流
'我' 25105
*/
FileWriter fw = new FileWriter("myio\\a.txt",true);
//fw.write(25105);
//fw.write("你好威啊???");
char[] chars = {
'a','b','c','我'};
fw.write(chars);
fw.close();
}
字符流底层原理
FileReader原理
输入流：
-
创建字符输入流对象
底层：关联文件，并创建缓冲区（长度为8192的字节数组）
-
读取数据
底层：
-
1 判断缓冲区中是否有数据可以读取
-
2 缓冲区没有数据：就从文件中获取数据，装到缓冲区中，每次尽可能装满缓冲区，如果文件中也没有数据了，返回 -1
-
3 缓冲区有数据：就从缓冲区中读取。
空参的read方法：一次读取一个字节，遇到中文一次读多个字节，把字节解码并转成十进制返回
有参的read方法：把读取字节，解码，强转三步合并了，强转之后的字符放到数组中
缓冲区：没读取数据时缓冲区内全为0
读取第一个数据后缓冲区装满数据
-
问题1：如果文件大于8192个字节怎么读取？（文件中有8192个a和1个bcd）
读数据先装满8192字节
8192字节都读完后，再读第8193个数据时，再把剩余数据都装到缓冲区
问题2：先读一个之后再写，之后再继续读会怎么样？（见下列代码）
由于写会把文件清空，所以无法读取文件中的内容，但是由于读取一个之后会把8192字节的数据放入缓冲区中，所以再读时并不是从文件中读，而是从缓冲区中读，所以会读到缓冲区中的8192个字节的内容。
public static void main(String[] args) throws IOException {
FileReader fr = new FileReader("myio\\b.txt");
fr.read();//会把文件中的数据放到缓冲区当中
//清空文件
FileWriter fw = new FileWriter("myio\\b.txt");
//请问，如果我再次使用fr进行读取
//会读取到数据吗？
//会把缓冲区中的数据全部读取完毕
//正确答案：
//但是只能读取缓冲区中的数据，文件中剩余的数据无法再次读取
int ch;
while((ch = fr.read()) != -1){
System.out.println((char)ch);
}
fw.close();
fr.close();
}
FileWriter原理
内存中存在缓冲区，以下3种情况会将缓冲区中的数据送入目的地：
1、装满了（写到第8193个字节才会把前8192个字节保存到本地）
2、手动刷新flush：无论缓冲区有多少数据，用flush方法可以直接保存到本地
3、释放资源 close()
flush()和close()
flush()：将缓冲区中的数据刷新到本地文件中。刷新之后，还可以继续往文件中写出数据
close()：释放资源/关流。断开通道，无法再往文件中写出数据
FileWriter的缓冲区：
如果你在写FileWriter时忘写了close，就会发现文件里什么也没有或者写的数据不全，因为都写在缓冲区里了，缓冲区里的数据不到8192时只有写关流close()才会把缓冲区里的数据保存到本地中。
代码示例：
public static void main(String[] args) throws IOException {
FileWriter fw = new FileWriter("myio\\a.txt");
fw.write("我的同学各个都很厉害");
fw.write("说话声音很好听");
fw.flush();
fw.write("都是人才");
fw.write("超爱这里哟");
fw.close();
fw.write("B站");
}
-
字节流和字符流的使用场景
-
字节流：拷贝任意型的文件
-
字符流：
读纯文本文件中的数据
往纯文本文件中写出数据
-
练习
1、拷贝文件夹
public static void main(String[] args) throws IOException {
//拷贝一个文件夹，考虑子文件夹
//1.创建对象表示数据源
File src = new File("D:\\aaa\\src");
//2.创建对象表示目的地
File dest = new File("D:\\aaa\\dest");
//3.调用方法开始拷贝
copydir(src,dest);
}
/*
* 作用：拷贝文件夹
* 参数一：数据源
* 参数二：目的地
*
* */
private static void copydir(File src, File dest) throws IOException {
dest.mkdirs();
//递归
//1.进入数据源
File[] files = src.listFiles();
//2.遍历数组
for (File file : files) {
if(file.isFile()){
//3.判断文件，拷贝
FileInputStream fis = new FileInputStream(file);
FileOutputStream fos = new FileOutputStream(new File(dest,file.getName()));
byte[] bytes = new byte[1024];
int len;
while((len = fis.read(bytes)) != -1){
fos.write(bytes,0,len);
}
fos.close();
fis.close();
}else {
//4.判断文件夹，递归
copydir(file, new File(dest,file.getName()));
}
}
}
2、文件加密解密
为了保证文件的安全性，就需要对原始文件进行加密存储，再使用的时候再对其进行解密处理。
加密原理：对原始文件中的每一个字节数据进行更改，然后将更改以后的数据存储到新的文件中。
解密原理：读取加密之后的文件，按照加密的规则反向操作，变成原始文件。
public static void main(String[] args) throws IOException {
File f1 = new File("D:\\AppData\\Local\\Java\\JAVA-Code\\IdeaProjects\\untitled2\\a.txt");
File f2 = new File("D:\\AppData\\Local\\Java\\JAVA-Code\\IdeaProjects\\untitled2\\a_en.txt");
File f3 = new File("D:\\AppData\\Local\\Java\\JAVA-Code\\IdeaProjects\\untitled2\\a_de.txt");
Encoder(f1, f2);
Decoder(f2, f3);
}
//加密
public static void Encoder(File src, File dest) throws IOException {
dest.createNewFile();
FileInputStream fis = new FileInputStream(src);
FileOutputStream fos = new FileOutputStream(dest);
int len;
while((len = fis.read()) != -1){
fos.write(len + 1);
}
fos.close();
fis.close();
}
//解密
public static void Decoder(File src, File dest) throws IOException {
dest.createNewFile();
FileInputStream fis = new FileInputStream(src);
FileOutputStream fos = new FileOutputStream(dest);
int len;
while((len = fis.read()) != -1){
fos.write(len - 1);
}
fos.close();
fis.close();
}
3、文本文件中有以下的数据：2-1-9-4-7-8
将文件中的数据进行排序，变成以下的数据：1-2-4-7-8-9
方法一：常规方法
public static void main(String[] args) throws IOException {
//1.读取数据
FileReader fr = new FileReader("myio\\a.txt");
StringBuilder sb = new StringBuilder();
int ch;
while((ch = fr.read()) != -1){
sb.append((char)ch);
}
fr.close();
System.out.println(sb);
//2.排序
String str = sb.toString();
String[] arrStr = str.split("-");//2-1-9-4-7-8
ArrayList<Integer> list = new ArrayList<>();
for (String s : arrStr) {
int i = Integer.parseInt(s);
list.add(i);
}
Collections.sort(list);
System.out.println(list);
//3.写出
FileWriter fw = new FileWriter("myio\\a.txt");
for (int i = 0; i < list.size(); i++) {
if(i == list.size() - 1){
fw.write(list.get(i) + "");
}else{
fw.write(list.get(i) + "-");
}
}
fw.close();
}
常规方法不止一种，比如我写的：
public static void mysort(File f) throws IOException {
FileInputStream fis = new FileInputStream(f);
List<Character> b = new ArrayList<>();
int len;
while((len = fis.read()) != -1){
if(len >= 48 && len <= 58) {
System.out.println((char)len);
b.add((char)len);
}
}
fis.close();
Collections.sort(b);
StringJoiner sj = new StringJoiner("-", "", "");
for (Character c : b) {
sj.add(c.toString());
}
String s = sj.toString();
FileOutputStream fos = new FileOutputStream(f);
fos.write(s.getBytes());
fos.close();
}
方法二：用Stream流+方法引用（注意复习！下列代码看不懂赶紧去复习）
public static void main(String[] args) throws IOException {
//1.读取数据
FileReader fr = new FileReader("myio\\a.txt");
StringBuilder sb = new StringBuilder();
int ch;
while((ch = fr.read()) != -1){
sb.append((char)ch);
}
fr.close();
System.out.println(sb);
//2.排序
Integer[] arr = Arrays.stream(sb.toString()
.split("-"))
.map(Integer::parseInt)
.sorted()
.toArray(Integer[]::new);
//3.写出
FileWriter fw = new FileWriter("myio\\a.txt");
String s = Arrays.toString(arr).replace(", ","-");
String result = s.substring(1, s.length() - 1);
fw.write(result);
fw.close();
}
注意事项：
这种类型的题文本里不要轻易加换行，因为换行其实是\r\n，会被读到，需要注意。
关联的文件不是IDEA里的文件时文件可能会有隐含的bom头，记录一些文件信息（比如文件的字符编码），记录在文本文档的最前面。此时可以将其另存为UTF-8编码方式，就不再会有bom头。
如果是在IDEA中的文件默认是没有bom头的，如下图
缓冲流
缓冲流是把1基本流做了一个封装，额外又添加了一些功能的高级流
字节缓冲流
原理：底层自带了长度为8192的缓冲区提高性能
用字节缓冲流拷贝文件（一次读写一个字节数组）
//创建缓冲流对象
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:\\AppData\\Local\\Java\\JAVA-Code\\IdeaProjects\\untitled2\\a.txt"));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("D:\\AppData\\Local\\Java\\JAVA-Code\\IdeaProjects\\untitled2\\copy.txt"));
//循环读取并写到目的地
int len;
while((len = bis.read()) != -1) {
bos.write(len);
}
//关流
bos.close();
bis.close();
问题1：缓冲区在哪？
BufferedOutputStream 的构造方法，红框中的变量就是缓冲区。
问题2：为什么关流时只需要关缓冲流，不需要关基本流？
因为在关闭缓冲流的源码中已经包含关闭基本流了。
用字节缓冲流拷贝文件（一次读写多个字节数组）
public static void main(String[] args) throws IOException {
//创建缓冲流对象
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:\\AppData\\Local\\Java\\JAVA-Code\\IdeaProjects\\untitled2\\a.txt"));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("D:\\AppData\\Local\\Java\\JAVA-Code\\IdeaProjects\\untitled2\\copy.txt"));
//循环读取并写到目的地
int len;
byte[] bytes = new byte[1024];
while((len = bis.read(bytes)) != -1) {
bos.write(bytes, 0, len);
}
//关流
bos.close();
bis.close();
}
字节缓冲流读写原理
基本输入流一次性读取8192字节的数据放到缓冲区中，中间变量b在缓冲区之间不断一个一个把左缓冲区的数据移动到右缓冲区中（内存里的倒手非常快，几乎不消耗时间），当右边缓冲区填满了，就会用基本输出流自动写到目的地。当变量b在缓冲区中读不到数据了，继续重新循环，直到文件末尾为止。
注：左边的缓冲区和右边的缓冲区不是一个缓冲区，一个是输入流缓冲区，一个是输出流缓冲区。
如果定义的是数组bytes，移动速度更快。
