Java学习笔记——学习IO流
输入 input ：输入到java程序
输出 output ：java程序输出
分类：
按照传输内容分：字节流、字符流
按照传输方向分：输入流、输出流
字节流
主要是传输字节（byte）数据，例如：音视频、图片等二进制文件
输入字节流
InputStream 是 字节输入流的所有类的超类。是抽象类
FIleInputStream 是 字节输入流的常用类
构造方法：
- FileInputStream(String name) ：通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的路径名 name 指定。
- FileInputStream(File file) ：通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的 File 对象 file 指定。
演示：
public void testConstructor() throws FileNotFoundException{
//构造方法1 : 传入String类型的文件路径
FileInputStream fis1 = new FileInputStream("E:/A/B2/a.txt");
//构造方法2 ：传入File类型的文件对象参数
FileInputStream fis2 = new FileInputStream(new File("E:/A/B2/a.txt"));
}
常用方法：
public int read([byte[] b[, int off, int len]]) throws IOException ：
- 无参数时，从此输入流中读取一个数据字节。
- 有参数b时，从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中。
- 有全部参数时，从此输入流中将最多 len 个字节的数据读入一个 byte 数组中。b - 存储读取数据的缓冲区；off - 目标数组 b 中的起始偏移量；len - 读取的最大字节数。
读取字节：
演示：
//读取一个字节
public void testInput() throws IOException {
FileInputStream fis1 = new FileInputStream("E:/A/B2/a.txt");
//读取一个字节
int b1 = fis1.read();
System.out.println((char)b1);
//读取一个字节
int b2 = fis1.read();
System.out.println((char)b2);
//读取一个字节
int b3 = fis1.read();
System.out.println((char)b3);
}
public void testInputPlus() throws IOException {
FileInputStream fis1 = new FileInputStream("E:/A/B2/a.txt");
try{
while((int b = fis1.read()) != -1){
System.out.print((char)b);
}
}finally{
fis1.close();//关流
}
}
//读取字节数组
public void testInputArray() throws IOException {
FileInputStream fis1 = new FileInputStream("E:/A/B2/a.txt");
//定义一个数组，长度是文件字节大小，如果长度小于字节大小时，每次读入数组长度
byte[] arr = new byte[10];
try{
//int num = fis1.read(byte[] b);num是字节的个数
while((int b = fis1.read(arr)) != -1){
System.out.print("读入的字节个数为：" + b);
}
System.out.println(Array.toString(arr));
}finally{
fis1.close();//关流
}
}
public void testInputArrayPlus() throws IOException {
FileInputStream fis1 = new FileInputStream("E:/A/B2/a.txt");
byte[] arr = new byte[3];
try{
while((int b = fis1.read(arr,0,arr.length)) != -1){
System.out.print("读入的字节个数为：" + b);
}
System.out.println(Array.toString(arr));
}finally{
fis1.close();//关流
}
}
public void testAvailable() throws IOException {
FileInputStream fis1 = new FileInputStream("E:/A/B2/a.txt");
int available = fis1 .available();//返回文件字节数
System.out.println(available);
}
输出字节流
OutputStream 输出字节流,抽象类.
常用实现类 FileOutputStream 字节输出流.
构造方法：
- FileOutputStream(File file) ：创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
- FileOutputStream(File file, boolean append) ：创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
- FileOutputStream(String name) ：创建一个向具有指定名称的文件中写入数据的输出文件流。
- FileOutputStream(String name, boolean append) ：创建一个向具有指定 name 的文件中写入数据的输出文件流。
注意：
- OutputStream 创建对象时，如果没有该文件，会创建一个新的，然后再写入
- 如果构造方法不传第二个参数时，默认就是false，即不和该文件原来的内容拼接，会将原来的内容覆盖
- 如果构造方法指定append为true，会和该文件原来的内容拼接
public void testConstructor() throws FileNotFoundException{
//构造方法1
FileOutputStream fos1 = new FileOutputStream("E:/A/B2/a.txt",true);
//构造方法2
FileOutputStream fos2 = new FileOutputStream((new File("E:/A/B2/a.txt"));
}
常用方法：
public void write(int b || [byte[] b[, int off, int len]]) throws IOException ：
- 参数是“int b”时，将指定字节写入此文件输出流。
- 参数是“byte[] b”时，将 b.length 个字节从指定 byte 数组写入此文件输出流中。
- 参数是“byte[] b, int off, int len”时，将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此文件输出流。
public void addDate() throws Exception{
FileOutputStream fos1 = new FileOutputStream("E:/A/B2/a.txt");
//输出一个字节
fos1.write(97);
fos1.close();
}
public void addArray() throws Exception{
FileOutputStream fos1 = new FileOutputStream("E:/A/B2/a.txt",true);
byte[] bytes = {66,67,68,69,70};
//输出一个数组内容的数据
fos1.write(bytes);
fos1.close();
}
public void addArrayPlus() throws Exception{
FileOutputStream fos1 = new FileOutputStream("E:/A/B2/a.txt",true);
byte[] bytes = {71,72,73,74,75};
//输出一个数组内容的数据
/**
*参数1 bytes 存储数据的数组
*参数2 偏移量 从数组的那个下标开始
*参数3 长度 读取数据的个数
*/
fos1.write(bytes,1,3);
fos1.close();
}
缓冲字节输入流（BufferedInputStream）
在创建 BufferedInputStream 时，会创建一个内部缓冲区数组
public BufferedInputStream(InputStream in, int size) ：创建具有指定缓冲区大小的 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。创建一个长度为 size 的内部缓冲区数组并将其存储在 buf 中。 可以不指定size，默认为8K。
public void test1() throws Exception{
FileInputStream fis = new FileInputStream("E:/A/B2/a.txt");
BufferedInputStream bis = new BufferedInputStream(fis);
while((int b = bis.read())!=-1){
System.out.println(b);
}
bis.close();
}
缓冲字节输出流（BufferedOutputStream）
public BufferedOutputStream(OutputStream out, int size) ：创建一个新的缓冲输出流，以将具有指定缓冲区大小的数据写入指定的底层输出流。
public void flush() throws IOException ：刷新此缓冲的输出流。这迫使所有缓冲的输出字节被写出到底层输出流中。可以不指定size，默认为8K。
public void test1() throws Exception{
FileOutputStream fos = new FileOutputStream("E:/A/B2/a.txt");
BufferedOutputStream bos = new BufferedOutputStream(fis);
while((int b = bos.read())!=-1){
System.out.println(b);
}
fos.close();
bos.close();
}
字符流
输入字符流
Reader抽象类，FileReader实现类
构造方法：
- public FileReader(File file) throws FileNotFoundException ：在给定从中读取数据的 File 的情况下创建一个新 FileReader。
- public FileReader(String fileName) throws FileNotFoundException ：在给定从中读取数据的文件名的情况下创建一个新 FileReader。
常用方法：
public abstract int read(char[] cbuf, int off, int len) throws IOException ：
- 无参数时，读取单个字符。。
- 有参数char[] cbuf时，将字符读入数组。
- 有全部参数时，将字符读入数组的某一部分。在某个输入可用、发生 I/O 错误或者到达流的末尾前，此方法一直阻塞。cbuf - 目标缓冲区；off - 开始存储字符处的偏移量；len - 要读取的最多字符数。
public void testRead() throws Exception{
//输入字符流
FileReader fr = new FileReader("E:/A/B2/a.txt");
//读一个字符，返回值是int
int read = fr.read();
System.out.println(read);
//连续多次，一次读取一个字符
int b = 0;
while((b = fr.read())!=-1){
System.out.println((char)b);
}
fr.close();
}
public void testReadPlus() throws Exception{
//输入字符流
FileReader fr = new FileReader("E:/A/B2/a.txt");
//一次读取字符数组长度的字符
char[] chars = new char[];
int b = 0;
while((b = fr.read(chars))!=-1){
System.out.println(chars);
}
fr.close();
}
输出字符流
Writer抽象类，FileWriter实现类
构造方法：
- public FileWriter(File file[, boolean append]) throws IOException ：根据给定的 File 对象构造一个 FileWriter 对象。如果第二个参数为 true，则将字节写入文件末尾处，而不是写入文件开始处。第二个参数可以不写，默认为false。
- public FileWriter(String fileName, boolean append) throws IOException ：根据给定的文件名以及指示是否附加写入数据的 boolean 值来构造 FileWriter 对象。如果第二个参数为 true，则将字节写入文件末尾处，而不是写入文件开始处。第二个参数可以不写，默认为false。
public void testWrite() throws Exception{
//创建输出字符流
FileWriter fw = new FileWriter("E:/A/B2/aa.txt");
//输出单个字符
fw.write('我');
char[] chars = new char[]{'你','好','j','a','v','a'};
//输出字符数组
fw.write(chars);
//输出字符串
fw.write("你好，java！");
//输出字符数组中指定内容
fw.write(chars,2,4);
//输出字符串中指定内容
fw.write("你好，java！",2,6);
}
缓冲字符输入流（BufferedReader）
public BufferedReader(Reader in, int sz) ：创建一个使用指定大小输入缓冲区的缓冲字符输入流。可以不指定sz，默认为8K。
public String readLine() throws IOException ：读取一个文本行。通过下列字符之一即可认为某行已终止：换行 (’\n’)、回车 (’\r’) 或回车后直接跟着换行。返回：包含该行内容的字符串，不包含任何行终止符，如果已到达流末尾，则返回 null
public static void main(String[] args) throws IOException {
FileReader fr = new FileReader("C:\\A\\B\\d.txt");
BufferedReader br = new BufferedReader(fr);
int b = 0;
// 从缓冲区中一次读取一个 输出
// while((b = br.read()) != -1) {
// System.out.println((char)b);
// }
// fr.close();
// 从缓冲区中一次读一行 输出,不会读取换行符
String s = null;
while((s = br.readLine()) != null) {
System.out.println(s);
}
fr.close();
}
缓冲字符输出流（BufferedWreader）
public BufferedReader(Reader in, int sz) ：创建一个使用指定大小输入缓冲区的缓冲字符输入流。可以不指定sz，默认为8K。
public static void main(String[] args) throws IOException {
/**
* 使用缓冲字符流 进行 文本复制
*/
// 创建 缓冲输入字符流
FileReader fr = new FileReader("C:\\A\\B\\d.txt");
BufferedReader br = new BufferedReader(fr);
// 创建 缓冲输出字符流
FileWriter fw = new FileWriter("C:\\A\\B\\d_copy.txt");
BufferedWriter bw = new BufferedWriter(fw);
// int b = 0;
// // 从缓冲区读一个字符,会读取 换行符
// while((b = br.read()) != -1) {
// bw.write(b);
// }
String s = null;
// 从缓冲区读一行.没有读取换行符
while((s = br.readLine()) != null) {
// 写一行
bw.write(s);
// 换行
bw.newLine();
}
bw.close();
br.close();
}