Java中的IO流

流

流：在java数据中所有数据都是使用流读写的。流是一种有顺序的，有起点和终点的字节集合，是对数据传输的总称或抽象。即数据在两个设备间的传输成为流，流的本质是数据传输。

1.按照流向分：输入流，输出流
2.按照处理数据的单位分：字节流（8位的字节）；字符流（16位的字节）

输入输出流

输入就是将数据从各种输入设备（包括文件，键盘等）中读取到内存中。
输出是将数据写入到各种输出设备（比如文件，显示器，磁盘等）。
文件既可以作为输入设备，又可以作为输出设备。

文件：在外设硬盘上面保存数据得一种方式。
文件由两个部分组成：属性（文件大小，文件名，文件类型等）+内容（文件中得数据）

字节流和字符流（java.io包中）

File类不支持文件内容处理，如果处理文件内容，必须通过流的操作模式来完成。

字节流：数据流中最小的数据单元是字节。InputStream,OutputStream
字符流：数据中最小的数据单元是字符，Java中的字符是Unicode编码，一个字符占用两个字节。Reader,Writer

字节流

1.FileInputStream和FileOutputStream

FileInputStream从文件系统中的某个文件中获得输入字节。
FileInputStream用于读取诸如图像数据之类的原始字节流。

文件输出流是用于将数据写入到输出流 File 或一个 FileDescriptor 。
特别是某些平台允许一次只能打开一个文件来写入一个 FileOutputStream （或其他文件写入对象）。 在这种情况下，如果所涉及的文件已经打开，则此类中的构造函数将失败。

public class FileInputStream extends InputStream {}
public class FileOutputStream extends OutputStream {}

//通过打开与实际文件的连接创建一个 FileInputStream ，该文
件由文件系统中的 File 对象 file 命名
FileInputStream(File file) {}

//通过打开与实际文件的连接来创建一个 FileInputStream ，该
文件由文件系统中的路径名 name 命名。
FileInputStream(String name) {}

//创建文件输出流以写入由指定的 File 对象表示的文件。
FileOutputStream(File file) {}
//创建文件输出流以指定的名称写入文件.
FileOutputStream(String name) {}

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class Test {
public static void main(String[] args) throws IOException {
FileInputStream fin=new FileInputStream("D:\\C++1.jpg");
FileOutputStream fout=new FileOutputStream("D:\\C++1111.jpg");
int len=0;
byte[] buff=new byte[1024];
while((len=fin.read(buff))!=-1) {
fout.write(buff, 0, len);
}
fin.close();
fout.close();
}
}

2.字节缓冲流BufferedInputStream和BufferedOutputStream

为什么需要缓冲流？
当我们用read()读取文件时，每读取一个字节，访问一次硬盘，效率很低。文件过大时，操作起来不是很方便。因此我们需要用到buffer缓存流，当创建buffer对象时，会创建一个缓存区数组。当我们读取一个文件时，先从硬盘中读取到缓冲区，然后从缓冲区输出即可，效率会更高。

public class BufferedInputStream extends FilterInputStream  //换入输入流
public class BufferedOutputStream  extends FilterOutputStream //缓冲输出流

//创建一个 BufferedInputStream 并保存其参数，输入流 in ，供以后使用。
BufferedInputStream(InputStream in)  {}
//创建 BufferedInputStream 具有指定缓冲区大小，并保存其参数，输入流 in ，供以后使用。
BufferedInputStream(InputStream in, int size)

//创建一个新的缓冲输出流，以将数据写入指定的底层输出流。
BufferedOutputStream(OutputStream out) {}
//创建一个新的缓冲输出流，以便以指定的缓冲区大小将数据写入指定的底层输出流
BufferedOutputStream(OutputStream out, int size)

//实现文件拷贝
package fileoperate;

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

public class BufferInputStreamTest {

	public static void main(String[] args) throws IOException {
		File file=new File("D:\\jl.txt");
		if(!file.isFile())
		{
			return;
		}
		BufferedInputStream bfis=new BufferedInputStream(new FileInputStream(file));
		BufferedOutputStream bfos=new BufferedOutputStream(new FileOutputStream("src\\"+file.getName()));
		byte bytes[]=new byte[1024];
		int temp=0;
		try {
			while((temp=bfis.read(bytes))!=-1){
				bfos.write(bytes,0,temp);
			}
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		bfos.flush();
		bfos.close();
		bfis.close();
		System.out.println("copy成功！");
	}
}

字符流

1.字符流FileReader和FileWriter

public class FileReader extends InputStreamReader
//如果要从文件中读取内容，可以直接使用 FileReader 子类
//FileReader 是用于读取字符流。 要读取原始字节流，请考虑使用 FileInputStream

public class FileWriter extends OutputStreamWriter
//如果是向文件中写入内容，应该使用 FileWriter 子类
//FileWriter 是用于写入字符流。 要编写原始字节流，请考虑使用 FileOutputStream

FileReader(File file)  //创建一个新的 FileReader ，给出 File 读取。
FileReader(String fileName) //创建一个新的 FileReader ，给定要读取的文件的名称。

FileWriter(File file)   //给一个File对象构造一个FileWriter对象。
FileWriter(String fileName)  //构造一个给定文件名的FileWriter对象

//示例使用 FileReader 和 FileWriter 复制文件：
public class CopyFileDemo {
public static void main(String[] args) throws IOException {
//创建输入流对象
FileReader fr = new FileReader("E:\\bit\\bitSrc.java");
//创建输出流对象
FileWriter fw = new FileWriter("E:\\bit\\bitCopy.java");
//读写数据
int ch;
while((ch=fr.read())!=-1) {
fw.write(ch);
}
//释放资源
fw.close();
fr.close();
}

2.字符缓冲流BufferedReader和BufferedWriter

提高字符流读写的效率，进行字符批量的读写，提高了单个字符读写的效率。BufferedReader用于加快读取字符的速度，BufferedWriter用于加快写入的速度。

BufferedReader和BufferedWriter类各拥有8192个字符的缓冲区。当BufferedReader在读取文本文件时，会先尽量从文件中读入字符数据并放满缓冲区，而之后若使用read()方法，会先从缓冲区中进行读取。如果缓冲数据不足，才会再从文件中读取，使用BufferedWriter时，写入的数据并不会先输出到目的地，而是先存储至缓冲区中。如果缓冲区中的数据满了，才会一次对目的地进行写出。

//从字符输入流读取文本，缓冲字符，以提供字符，数组和行的高效读取
public class BufferedReader extends Reader 
public class BufferedWriter  extends Writer

BufferedReader(Reader in) //创建使用默认大小的输入缓冲区的缓冲字符输入流。
BufferedReader(Reader in, int sz) //创建使用指定大小的输入缓冲区的缓冲字符输入流。

BufferedWriter(Writer out)  //创建使用默认大小的输出缓冲区的缓冲字符输出流。
BufferedWriter(Writer out, int sz)  //创建一个新的缓冲字符输出流，使用给定大小的输出缓冲区。

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class FileWrite {
public static void main(String[] args) throws IOException {
FileReader reader=new FileReader("E:\\BIT\\bit.txt");
BufferedReader bReader=new BufferedReader(reader);
FileWriter writer=new FileWriter(":\\BIT\\bit2.txt");
BufferedWriter bWriter=new BufferedWriter(writer);
String content="";
//readLine一行一行的读取
while((content=bReader.readLine())!=null){
//\r\n换行
bWriter.write(content+"\r\n");
}
/**
 * 关闭流的顺序：
 * 当A依赖B的时候先关闭A，再关闭B
 * 带缓冲的流最后关闭的时候会执行一次flush
 */
reader.close();
bReader.close();
bWriter.close();
writer.close();
}
}

字节流VS字符流

1.字节流操作的基本单位是字节；字符流操作的基本单位是Unicode码元。

2.字节流在操作的时候本身不会用到缓冲区的，是与文件本身直接操作的；
而字符流在操作的时候使用到缓冲区的。

3.所有文件的存储都是字节的存储，在磁盘上保留的是字节。

4.在使用字节流操作中，即使没有关闭资源（close方法），也能输出；而字符流不使用close方法的话，不会输出任何内容。

字符字节转换流

InputStreamReader 是Reader的子类，将输入的字节流转换成字符流。
OutputStreamWriter 是Writer的子类，将输出的字符流转换成字节流。

public class InputStreamReader extends Reader
public class OutputStreamWriter  extends Writer

InputStreamReader(InputStream in)  //创建一个使用默认字符集的
InputStreamReader。
InputStreamReader(InputStream in,Charset cs) //创建一个使用给定字符集的
InputStreamReader。

OutputStreamWriter(OutputStream out)  //创建一个使用默认字符编码的
OutputStreamWriter。
OutputStreamWriter(OutputStream out, Charset cs)  //创建一个使用给定字符集的
OutputStreamWriter。

应用 ：读文件，写文件（重要）

读文件

package fileoperation;
/**
 * @author jiang.liang
 *
 * 2021/04/13
 */
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;

public class FileRead {

	public static void main(String args[]) {
		fileRead("D:/练习/StringTest.java");
	}

	public static void fileRead(String filePath) {
		if(filePath==null) {
			return;
		}
		BufferedReader br = null;
		try{
			br=new BufferedReader(new InputStreamReader(new FileInputStream(new File(filePath))));
			String line="";
			while((line=br.readLine())!=null) {
				System.out.println(line);
			}

		}catch(FileNotFoundException e) {
			System.out.println("该文件不存在");
			e.printStackTrace();
		}catch(IOException e){
			e.printStackTrace();
		}finally {
			close(br);
		}
	}

	public static void close(BufferedReader br) {

		if(br == null) {
			return;
		}

		try {
			br.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

写文件

package fileoperation;
/**
 * @author jiang.liang
 *
 * 2021/04/13
 */
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;

public class FileWrite {
	public static void main(String[] args) {
		fileWrite("D:/练习/fileWrite.txt");
	}

	public static void fileWrite(String filePath) {
		if(filePath == null) {
			return;
		}
		BufferedWriter bw=null;
		try {
			bw=new BufferedWriter(new OutputStreamWriter(new FileOutputStream(new File(filePath))));
			bw.write("我是一个学生！！I am a student!!hhhh");
			System.out.println("hello");
			bw.flush();
		}catch(FileNotFoundException e) {
			System.out.println("该文件不存在");
			e.printStackTrace();
		}catch(IOException e){
			e.printStackTrace();
		}finally {
			close(bw);
		}
	}

	public static void close(BufferedWriter bw) {

		if(bw == null) {
			return;
		}
		try {
			bw.close();
		} catch (IOException e) {
			e.printStackTrace();
		}

	}
}