文件字符输入、文件字符出流，缓冲流（缓冲字节输入、缓冲字节输出、缓冲字符输入、缓冲字符输出）

IO流

字符流

FileReader文件字符输入流

把内容从磁盘中“读”到内存中去

常用的API：

1、创建文件字符输入流与源文件接通
2、定义一个字符数组每次读多个字符
3、把每次读取的字符数组内容，转换成字符串并输出

//目标：掌握文件字符输入流读取字节字符内容到程序中来
//1、创建文件字符输入流与源文件接通
Reader fr = new FileReader("day03-file-io\\\\src\\\\lll02");

//2、定义一个字符数组每次读多个字符
char[] chs = new char[1024];
int len = 0;
while((len = fr.read(chs)) != –1){
//3、把每次读取的字符数组内容，转换成字符串并输出
String str = new String(chs,0,len);
System.out.print(str);//文本内容自带换行，不需要额外写
}

小结

FileWriter文件字符输出流

把内容从内存中“写”到磁盘中去

1、覆盖管道：每次编译覆盖原来的数据
2、追加管道：不会删除原来的信息
3、刷新的作用是通知缓冲区把其中未传输的信息尽快同步传输（刷新缓冲区，将缓冲区的数据全部写出去），且刷新后流可以继续使用
4、对于文件的复制使用字节流，对于读文档使用字符流

package com.itheima.demo8writer;

import java.io.FileWriter;
import java.io.Writer;

public class FileWriterDemo1 {
public static void main(String[] args) {
//目标：掌握文件字符输出流的使用，写字符出去的流
//1、创建文件字符输出流与目标文件接通
try(
//Writer fw = new FileWriter("day03-file-io\\\\src\\\\lll02");//覆盖管道
Writer fw = new FileWriter("day03-file-io\\\\src\\\\lll02",true) //追加管道：不会删除原来的信息
){
//2、写一个字符串
fw.write("hello world");
fw.write("\\r\\n");
//写一个字符
fw.write('a');
fw.write("\\r\\n");
//指定字符串长 度
fw.write("hello world",0,5);
fw.write("\\r\\n");
//指定字符数组
char[] chs = {'a','b','c'};
fw.write(chs);
fw.write("\\r\\n");
//指定字符数组长度
char[] chs2 = {'a','b','c'};
fw.write(chs2,0,2);
fw.write("\\r\\n");

fw.flush();//刷新缓冲区，将缓冲区的数据全部写出去
//刷新后，流可以继续使用
fw.close();//关闭流
fw.write("关闭流，关闭包含了刷新，关闭后不能继续使用");
//写一个
} catch (Exception e) {
e.printStackTrace();
}
}
}

缓冲流

用缓冲流在外包装一层之前的低级的流，只是外加一层，整体结构与不变

缓冲字节流

每一列都满足继承关系

缓冲区与内存之间的传输时间可以忽略不计

package com.itheima.demo09bufferredinputstream;

import java.io.*;

public class CopyDemo1 {
public static void main(String[] args) throws Exception {
//目标：掌握缓冲字节流的使用
//源文件：D:\\照片\\yy.png
//目标文件：C:\\照片\\yy.png（复制过去的时候必须带文件名,无法自动生成文件名）

copyFile("D:\\\\照片\\\\yy.png","C:\\\\照片\\\\yy.png");
}

//复制文件
public static void copyFile(String srcPath,String destPath) throws Exception{
try (
//这里只能放置资源对象，用完后，最终会自动调用其close方法关闭
//1、创建一个文件字节输入流管道与源文件接通
FileInputStream fis = new FileInputStream(srcPath);
//把低级的字节输入流包装成高级的缓冲字节输入流
InputStream bis = new BufferedInputStream(fis);
//2、创建一个文件字节输出流管道与目标文件接通
FileOutputStream fos = new FileOutputStream(destPath);
//把低级的字节输出流包装成高级的缓冲字节输出流
OutputStream bos = new BufferedOutputStream(fos);
)
{
//3、定义一个字节数组，用于存取数据
byte[] buffer = new byte[1024];
int len;
while ((len = bis.read(buffer)) != –1) {
//4、把读取到的数据，写入到输出流中,一桶（1024个字节）一桶写
bos.write(buffer, 0, len);
}
System.out.println("复制完毕");
} catch (IOException e) {
e.printStackTrace();
}
}
}

缓冲字节流小结

缓冲字符流

缓冲字符输入流

使用循环改进，来按照行读取数据.也是目前读取文本最好的方案，性能好，不乱码，可以按照行读取

多态定义：
1、只能调用父类中定义的方法，或者子类重写的方法
2、无法直接访问子类独有的方法

package com.itheima.demo10buddered;

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.Reader;

public class BufferReaderDemo1 {
public static void main(String[] args) {
//目标：搞清楚字符输入流读取字符内容，性能提升了，多了按照行读取文本的能力
try (
//1、创建字符输入流对象，与源文件接通
Reader fr = new FileReader("day03-file-io\\\\src\\\\lll02");
//创建缓冲字符输入流包装低级的字符输入流（注意多态定义无法直接访问子类独有的方法，所有这里不使用多态定义）
BufferedReader br = new BufferedReader(fr);
) {
// //2、定义一个字符数组，每次读取多个字符
// char[] chs = new char[1024];
// int len;
// while ((len = br.read(chs)) != -1) {
// //3、把读取到的多个字符，转换成字符串，并输出
// String str = new String(chs, 0, len);
// System.out.print(str);
// }

System.out.println(br.readLine());//每次读一行数据返回，若读不到数据返回null

//使用循环改进，来按照行读取数据.也是目前读取文本最好的方案，性能好，不乱码，可以按照行读取
//1、定义一个字符串对象用于记住每次读取的一行数据
String line;
while ((line = br.readLine()) != null) {
System.out.println(line);
}

} catch (Exception e) {
e.printStackTrace();
}
}
}

缓冲字符输出流

package com.itheima.demo1bufferredWriter;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.Writer;

public class FileWriterDemo1 {
public static void main(String[] args) {
//目标：掌握缓冲文件字符输出流的使用，性能好，多了换行功能
try(
//1、创建文件字符输出流与目标文件接通
//Writer fw = new FileWriter("day03-file-io\\\\src\\\\lll02");//覆盖管道
Writer fw = new FileWriter("day03-file-io\\\\src\\\\lll02",true); //追加管道：不会删除原来的信息
//2、创建一个缓冲字符输出流对象，把字符输出流对象作为构造器参数传递给缓冲字符输出流对象
BufferedWriter bw = new BufferedWriter(fw);//用子类独有功能不能用多态
){
//2、写一个字符串
bw.write("hello world");
bw.newLine();//新换行方式
//写一个字符
bw.write('a');
bw.write("\\r\\n");//旧换行方式
//指定字符串长 度
bw.write("hello world",0,5);
bw.write("\\r\\n");
//指定字符数组
char[] chs = {'a','b','c'};
bw.write(chs);
bw.write("\\r\\n");
//指定字符数组长度
char[] chs2 = {'a','b','c'};
bw.write(chs2,0,2);
bw.write("\\r\\n");

bw.flush();//刷新缓冲区，将缓冲区的数据全部写出去
//刷新后，流可以继续使用
bw.close();//关闭流
bw.write("关闭流，关闭包含了刷新，关闭后不能继续使用");
//写一个
} catch (Exception e) {
e.printStackTrace();
}
}
}

缓冲字符输出流小结