java IO流(文件)

一IO流

1.1 概念

        流是一组有顺序的，有起点和终点的字节集合，是对数据传输的总称或抽象。即数据在两设备间的传输称为流，流的本质是数据传输，根据数据传输特性将流抽象为各种类，方便更直观的进行数据操作。

I : input 输入 (输入 : 就是把数据输入到内存中)

O : output 输出  (输出 : 就是把内存中的数据写出到外面)

1.2 分类

1 按处理数据类型的不同，分为字节流和字符流

2 按数据流向的不同，分为输入流和输出流。(入和出是相对于内存来讲的) 

3 按功能不同，分为节点流和处理流  

        节点流:直接操作数据源

        处理流:对其他流进行处理

1.3 四大抽象类

InputStream : 字节输入

OutputStream : 字节输出

Reader : 字符输入

Writer : 字符输出

1.3.1 InputStream

常用方法: 

方法	描述
void close()	关闭此输入流并释放与该流关联的所有系统资源
abstract int read()	从输入流读取下一个数据字节
int read(byte[] b)	从输入流中读取一定数量的字节并将其存储在缓冲区数组b中
int read(byte[] b, int off, int len)	将输入流中最多len个数据字节读入字节数组

        read : 读取文件中的数据,一次读取一个字节,返回值是读取的字节的值(返回int类型),如果读取到文件末尾(读完了)返回-1

       

代码1:

package day01.com;

import java.io.FileInputStream;
import java.io.FileNotFoundException;

public class IO_01_FileInputStream_01 {
		public static void main(String[] args) throws Exception {
			// 要读取文件,必须要找到它
			// 如何找? 两种方式 : 绝对路径 和 相对路径
			// 绝对路径 : 能够找到这个文件的全路径
			// 相对路径 : 相对当前文件所在位置去找其他文件 , ./ 表示当前目录, ../ 表示上级目录, ../../ 表示上上级目录, ../../../...
	// FileInputStream fis = new FileInputStream("D:/test/a.txt");
	// eclipse中 ./ 找到的是当前项目
	String file="./src/day01/com/IO_01_FileInputStream_01.java";
	FileInputStream fis=new FileInputStream(file);
	//read:读取文件中的数据,一次读取一个字节返回值是读取的字节的值(返回int类型),如果读取到文件末尾(读完了),返回-1;
	int i1=fis.read();
	System.out.println((char)i1);
		}
}

         read 的方法重载,可以传递一个字节数组,为了提高读取效率
 read方法默认一次读取一个字节,如果传递了字节数组,则把字节数组一次性读满,再回来,然后下次去在读满,一直到读完
read(btye[]): 一次读取一个数组,返回当前次读取到的个数,如果到达文件末尾,返回-1代 

码 2 :

public class IO_03_FileInputStream_03 {
public static void main(String[] args) {
	String file="./src/day01/com/IO_01_FileInputStream_01.java";
	try(FileInputStream fis=new FileInputStream(file)){
	//available : 可获取的字节数
		System.out.println(fis.available());
		// byte[] bytes = new byte[fis.available()];
		byte[] bytes = new byte[1024];
		int count = fis.read(bytes);
		System.out.println(new String(bytes, 0,count));
		System.out.println(count);
		count = fis.read(bytes);

		// new String(bytes) 把自己数组中所有的数据转换为字符串,但是可能有冗余数据
		// 所以推荐使用 new String(bytes,0,count) 只把本次读取的数据转换为字符串
		System.out.println(new String(bytes, 0, count));
	}catch (Exception e) {
		// TODO: handle exception
	}
}
}

1.3.2 OutputStream

常用方法:

方法	描述
void close()	关闭此输出流并释放与此流有关的所有系统资源
void flush()	刷新此输出流并强制写出所有缓冲的输出字节
void write(byte[] b)	将 b.length个字节从指定的字节数组写入此输出流
void write(byte[] b, int off, int len)	将指定字节数组中从偏移量 off 开始的 len 个字节写入此输出流
abstract void write(int b)	将指定的字节写入此输出流

输出流 是把内存中的数据写出到硬盘中
  如果该文件不存在,会自动创建,但是不会创建文件夹
  如果对应的文件夹目录不存在,就报错
  构造方法 
 
         FileOutputStream(String path) : 向该文件中写出数据,并覆盖原有内容
 
         FileOutputStream(String path,boolean append) : 向该文件中写出数据,如果append为true就追加写出,如果为false就覆盖
  write(int) : 写出一个数据
          write(byte[] b) : 写出该数组中所有内容
          write(byte[] b,int off,int len) : 写出该数组中指定数据
  
          flush() : 刷缓存,不调用也可以,关闭流的时候会自动调用
  辅助方法 : getBytes() : String中的方法,用于获取字符串对应的字节数组

代码:

public class IO_06_FileOutputStream_01 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		try {
			FileOutputStream fos = new FileOutputStream("D:/a.txt");
			FileOutputStream fos1 = new FileOutputStream("D:/a.txt",true);
			fos.write(97);
			fos.write(98);
			fos.write(99);
			fos.write(100);
			fos.write('\n');
			String str="你好吗?";
			byte[] b=str.getBytes();
			fos.write(b);
			fos.flush();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println("done!");
	}

}

 1.3.3 Reader

常用方法:

方法	描述
abstract void close()	关闭该流
int read()	读取单个字符
int read(char[] cbuf)	将字符读入数组
abstract int read(char[] cbuf, int off, int len)	将字符读入数组的某一部分

FileReader 字符输入流, 字节输入流是一次读取一个字节,而字符输入流一次读取一个字符
   并且java中汉字采用的是unicode编码,而unicode编码占用16位,就是一个字符
   所以使用字符输入流可以解决汉字乱码问题
   字符流一般只用于纯文本文件,比如压缩包,图片,视频等,还是需要使用字节流处理
   read() : 读取一个字符,返回该字符的int值,到达文件末尾返回 -1

read(char[]) : 读取一个char数组,返回当前次读取的个数,到达末尾返回-1

代码:

public class IO_05_FileReader_01 {
	public static void main(String[] args) {
		String file="./src/day01/com/IO_01_FileInputStream_01.java";
			try (FileReader fr = new FileReader(file)) {
			int temp = 0;
			while ((temp = fr.read()) != -1) {
				System.out.print((char) temp);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
			
	}
}

 1.3.4 Writer

Writer的继承关系：蓝色为节点流，黑色为处理流(小红旗重点 ) 

常用方法:

方法	描述
void write(int c)	写入单个字符
void write(char[] cbuf)	写入字符数组
abstract void write(char[] cbuf, int off, int len)	写入字符数组的某一部分
void write(String str)	写入字符串
void write(String str, int off, int len)	写入字符串的某一部分
Writer append(char c)	将指定字符添加到此writer
abstract void flush()	刷新该流的缓冲
abstract void close()	关闭此流，但要先刷新它

代码:

public class IO_07_FileWriter {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		try (
				FileWriter fw = new FileWriter("D:/a.txt",true);
				){
			// 写出字符串
			fw.write("你好吗?\n");
			char[] chars = {'a','b','c','d'};
			// 写出char数组
			fw.write(chars);
			fw.flush();
			
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

二 文件流

分类	字节流	字符流
文件输入流	FileInputStream	FileReader
文件输出流	FileOutputStream	FileWriter

三 缓冲流

3.1 分类

分类	字节流	字符流
文件输入流	BufferedInputStream	BufferedReader
文件输出流	BufferedOutputStream	BufferedWriter

3.2 特点

1 主要是为了提高效率而存在

2 提供eadLine(),newLine()这样的简便方法(针对缓冲字符流) 

        readLine():读取一行,

        newLine():换行,相当于/n 

3 在读取和写入时,会有缓冲部分,用flush()为了刷新缓存,将内存数据写入到磁盘

BufferedInputStream 代码:

public class IO_08_BufferedInputStream {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		long startTime = System.currentTimeMillis();
		try (FileInputStream fis = new FileInputStream("D:/a.txt");){
			byte[] bytes = new byte[1024];
//			int temp = 0;
//			while((temp=fis.read(bytes)) != -1){
			
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		try (
				FileInputStream fis = new FileInputStream("D:/a.txt");
				BufferedInputStream bis = new BufferedInputStream(fis);
				){
			byte[] bytes = new byte[1024];
			int temp = 0;
			while((temp=bis.read(bytes)) != -1){		
				 System.out.println(new String(bytes,0,temp));
			}
			long endTime = System.currentTimeMillis();
			System.out.println("读取完成,耗时 : "+(endTime-startTime));
			// 字节流 : 120
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

}

BufferedOutputStream 代码:

public class IO_09_BufferedOutputStream {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		try (FileOutputStream fos = new FileOutputStream("D:/a.txt");
				BufferedOutputStream bos = new BufferedOutputStream(fos);
		) {
			bos.write(97);
			bos.write(98);
			bos.write(99);
			bos.write(100);
			bos.write('\n');
			String str = "你好吗1111111";
			byte[] bytes = str.getBytes();
			bos.write(bytes);
			bos.flush();//刷新缓存
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

}

BufferedReader 代码:

        

public class IO_10_BufferedReader {
public static void main(String[] args) {
	try (FileReader fr = new FileReader("D:/a.txt");
			BufferedReader br = new BufferedReader(fr);) {
		String temp = null;
		// 读取一行
		while ((temp = br.readLine())  != null) {
			System.out.println(temp);
		}

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

BufferedWriter 代码:

public class IO_11_BufferedWriter {
public static void main(String[] args) {
	String file="D:/a.txt";
	BufferedWriter bw=null;
	try {
		 bw=new BufferedWriter(new FileWriter(file));
		bw.write("早上好?");
		bw.newLine();
		bw.write("晚上吃啥");
		bw.flush();
		
	} catch (IOException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}finally{
		try {
			if(bw!=null)
			bw.close();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

练习 实现一个压缩包的复制

package work;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * 1 编码实现一个压缩包a.rar文件的复制。
 * @author 黄泽锋
*@author 2021年10月27日上午9:42:38
 *
 */
public class work_01 {
public static void main(String[] args) {
	String file="D:/a.rar";
	String file1="D:/test/a.rar";
	try (FileInputStream fis=new FileInputStream(file);
		FileOutputStream fos=new FileOutputStream(file1);
			BufferedOutputStream bos=new BufferedOutputStream(fos);
	){
		byte[] bytes=new byte[fis.available()];
		String temp1=null;
		int temp=0;
		while((temp=fis.read(bytes))!=-1){
			fos.write(temp);
		}
		fos.flush();
	} catch (Exception e) {
		// TODO: handle exception
	}
	System.out.println("done!");
	
	}
}