【IO流】的学习

IO流

IO：input、output

流：指的是程序中数据的流动方向

分类:
按流向分：
输入流：从文件到控制台（读取文件中的数据至控制台）
输出流：从控制台到文件（将控制台中的数据存储至文件）

按数据类型分：
**字节流：**使用单个字节进行数据传输（传输数据最基本单位为字节）
字节输入流 InputStream(抽象类)
字节输出流 OutputStream(抽象类)
**字符流：**使用单个字符进行数据传输（传输数据最基本单位为字符）
字符输入流 Reader(抽象类)
字符输出流 Writer(抽象类)
注意：I/O默认按照数据类型分类

流的使用

1、声明操作文件对象（new File(url)）

2、创建相应的流（字节、字符、输入、输出流）

3、进相应的操作（读取、写入）

4、关闭流释放资源（输出流需要先进行刷新）

字节流

字节输入流

字节输入流的抽象类: 程序可以从数据源中连续读取字节的对象称为字节输入流，字节输入流的抽象类

方法	描述
public void close()	关闭输入流
public abstract int read()	以数字的方式读取内容
public int read(byte[] b)	将内容读到byte数组中，同时返回读入的个数

字节输出流

OutputStream: 程序可以向数据源中连续写入字节的对象称为字节输出流 ，字节输出流的抽象类

方法	描述
public void close()	关闭输出流
public abstract void write(int b)	在数据流中写入一个字节
public void write(byte[] b,int off,int len)	在数据流中写入一个指定范围的byte数组
public void write(byte[] b)	在数据流中写入一个byte数组
public void flush()	刷新缓冲区

文件字节输入流

FileInputStream：用于读取文件数据的流，继承于字节输入流

构造方法

FileInputStream(File file)

以指定文件对象作为数据源进行数据的读取

FileInputStream(String fileUrl)

以指定文件名创建对象并作为数据源进行读取

常用方法

int read()

每次从数据源中读取一个字节数据，返回读取长度，如果没有下一个要读取数据则返回-1

int read(byte[] b)

每次从数据源读取指定数组长度的数据并存入数组中，返回读取长度，如果没有下一个套读取数据则返回-1

void close()

关闭数据源释放资源

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
//文件字节输入流
//文件中以字节形式读取数据
public class FileInputSreamTest {
	public static void main(String[] args) throws IOException {
		// 构造方法
		// new FileInputStream(file)
		// 连接指定文件进行流操作

		// new FileInputStream(name)
		// 连接指定名称的文件进行流操作

		// 流的使用
		// 1创建指定文件
		File file = new File("F://test/a.txt");
		// 2创建相应操作流并指定文件
		FileInputStream fis = new FileInputStream(file);
		// 3进行相应操作
		// int read = fis.read();// 读取一个字节,再次执行会向下读取返回指定字符ascii码值 没有则返回-1
		// (1)fis.read()
		// 每次读取一个字节数据并返回
		// 当进行文字读取时，一个文字根据编码不同占用字节不同，会造成乱码
		// int code=0;
		// while((code=fis.read())!=-1){//现将读取的数据赋值给变量之后进行判断
		// System.out.println((char)code);
		// }
		//(2)fis.read(byte[]);
		byte[] b=new byte[1024];
		int length=0;//每次获取数据的长度
		while((length=fis.read(b))!=-1){
			System.out.println(new String(b,0,length));
		}
		// 4关闭流释放资源
		fis.close();
	}
}

文件字节输出流

FileOutputStream：用于将数据输出至文件的流，继承与字节输出流

构造方法

FileOutputStream(File file)

以指定文件对象作为数据输出源进行数据的写入，覆盖原数据

FileOutputStream(String fileName)

以指定字符串创建文件对象并作为数据输出源进行数据的写入，覆盖原数据

FileOutputStream(File file，boolean bool)

以指定文件对象输入是否进行追加输入，进行数据的写入

FileOutputStream(String fileName，boolean bool)

以指定字符串创建文件对象并输入是否进行追加输入，进行数据的写入

常用方法

void write(int i）

将指定数据以字节形式输出至文件

void write(byte[] b)

将指定字节数组以字节形式输出至文件

void write(byte[] b ,int startindex,int length )

将指定字节数组指定起始位指定长度的字节数据输出至文件

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
//文件字节输出流
//将数据以字节流的形式输出至指定文件
public class FileOutPutStreamTest {
	public static void main(String[] args) throws Exception {
		// 构造方法
		// new FileOutputStream(file,boolean)
		// new FileOutputStream(url,boolean)
		// boolean代表是否追加输入

		// 流的使用
		// 1创建指定文件
		File file = new File("F://test/a.txt");
		// 2创建相应操作流并指定文件
		FileOutputStream fos = new FileOutputStream(file, true);//false覆盖输入
		// 3进行相应操作
		//(1)fos.write(99);
		//将单个字节写入输出位置文件
		//(2)fos.write("你好吗".getBytes());
		//将指定字节数组写入输出文件
		fos.write("1234567".getBytes(),0,4);
		//将指定字节数组指定数据索引输出至文件
		
		// 4关闭流释放资源
		fos.flush();//输出流需要先刷新缓冲区(将缓冲区中没来得及输出的数据输出)
		fos.close();
	}
}

字节高效流

在创建操作流时额外创建缓冲区，从而提高对数据源的读取与写入速度

（高效流的使用是在字节流基础上添加的缓冲区，所以在使用时人需要创建字节流对象）

高效流提高执行效率的原因

在进行文件读取时，先将数据一部分存储在缓冲区中，在进行获取操作时我们直接从缓冲区获取数据无需直接到数据源进行获取，缓冲区属于内存，执行效率高

高效输入流

BufferedInputStream

构造方法

​ public BufferedInputStream(InputStream in)
​ public BufferedInputStream(InputStream in,int size)
第一种形式的构造方法创建带有32个字节缓冲区的缓冲流
第二种形式的构造方法按照创建了指定大小的缓冲区。

高效输出流

BufferedOutputStream

构造方法

​ public BufferedOutputStream(OutputStream in)
​ public BufferedOutputStream(OutputStream in,int size)
第一种形式的构造方法创建带有32个字节缓冲区的缓冲流
第二种形式的构造方法按指定的大小来创建缓冲区。

使用高效流进行文件复制

	// 高效输入输出流进行文件复制
	public static void bufferedCopy(String oldFileName, String newFileName) throws IOException {
		Date d1 = new Date();
		// 1创建要操作的文件对象
		File oldFile = new File(oldFileName);
		// 创建要写入的文件对象
		File newFile = new File(newFileName);
		newFile.createNewFile();
		// 2创建相应的流
		// 创建文件字节输入流
		FileInputStream fis = new FileInputStream(oldFile);
		// 使用文件字节输入流对象创建高效输入流
		BufferedInputStream bis = new BufferedInputStream(fis,1024);

		// 创建文件字节输出流
		FileOutputStream fos = new FileOutputStream(newFile,false);
		// 使用文件字节输出流对象创建高效输出流
		BufferedOutputStream bos = new BufferedOutputStream(fos);

		// 3进行流操作
		// 创建存储数据的字节数组与每次读取的长度
		int length = 0;
		byte[] b = new byte[1024];
		// 高效输入流循环读取
		while ((length = bis.read(b)) != -1) {
			// 使用高效输出流将每次读取的数据输出
			bos.write(b, 0, length);// 只输出每次读取长度的数据
		}
		// 4 关闭流释放资源
		bis.close();
		bos.flush();
		bos.close();
		Date d2 = new Date();
		System.out.println("高效字节流进行文件复制:" + (d2.getTime() - d1.getTime()));
	}

字符流

字符读取流

Reade：以字符形式进行数据源的读取，字符读取流的抽象类

方法	描述
public abstract void close()	关闭输入流
public int read()	读取单个字符
public int read(char[] c)	将内容读取到字符数组中，并返回读取的长度

字符写入流

Writer：以字符形式将数据输出至数据源，字符写入流的抽象类

方法	描述
public abstract void close()	关闭输出流
public void write(String str)	输出字符串
public void write(char[] c)	输出字符数组
public abstract void flush()	强制清空缓存

文件字符读取流

FileReader：用于以字符形式进行文件数据的读取，Reader的子类

构造方法

FileReader(File file)

以指定文件对象创建文件字符读取流

FileReader(String fileName)

先以文件路径创建文件后创建文件字符读取流

常用方法

reader(char[] c)

使用指定字符数组读取数据并存入字符数组，返回实际读取长度，如果没有返回-1

close()

关闭文件字符读取流释放资源

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;

//文件字符流读取数据
public class FileReaderTest {
	public static void main(String[] args) throws Exception {
		// 构造方法
		// new FileReader(file)
		// new FileReader(fileName)
		File file = new File("f://test/shz.txt");
		FileReader fr = new FileReader(file);
		char[] c = new char[50];
		int length = 0;
		while ((length = fr.read(c)) != -1) {
			System.out.print(new String(c, 0, length));
		}
		fr.close();
	}
}

文件字符写入流

FileWriter：将数据以字符形式写入至文件，Writer的子类

构造方法

FileWriter(File file)

以指定文件对象创建文件写入流

FileWriter(String fileName)

以指定文件字符串地址创建文件对象创建文件写入流

FileWriter(File file, boolean append)

以指定文件对象创建文件写入流，输入append进行文件的追加覆写

FileWriter(String fileName,boolean append)

以指定文件字符串地址创建文件对象创建文件写入流，输入append进行文件的追加覆写

常用方法

write(String str);

将指定字符串写入

write(char[] c,int startIndex,int length);

将指定字符串数组由指定索引开始指定长度写入

flush()

刷新缓冲区将数据写入

close()

关闭写入流并释放资源

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;

//文件字符写入流写入数据
public class FileWriterTest {
	public static void main(String[] args) throws Exception {
		// 构造方法
		// new FileWriter(file)
		// new FileWriter(fileName)
		// new FileWriter(file, append)
		// new FileWriter(fileName, append)

		File file = new File("F://test/静夜思.txt");
		file.createNewFile();

		FileWriter fw = new FileWriter(file);

		fw.write("静夜思\r\n");
		fw.write("李白\r\n");
		fw.write("床前明月光\r\n");
		fw.write("疑是地上霜\r\n");
		fw.write("举头望明月\r\n");
		fw.write("低头思故乡\r\n");
		// fw.write(str);
		// 直接将字符串写入
		// fw.write(c, 0, length);
		// 将自定字符数组由指定索引开始指定长度写入
		fw.flush();
		fw.close();
	}
}

字符高效流

提供了缓冲区的对字符进行操作的流

字符高效读取流

BufferedReader

方法	类型	描述
public BufferedReader(Reader in)	构造方法	接收Reader类实例
public String readLine()	方法	从缓冲区中读取一行文本
public int read()	方法	读取单个字符
public int read(char[] c,int off,int len)	方法	读取字符数组的一部分

字符高效写入流

BUfferedWriter

方法	类型	描述
public BufferedWriter(Writer out)	构造方法	接收Writer类实例
public void newLine()	方法	写入一个行分隔符
public void write(String s,int off,int len)**	方法	写入字符串的一部分

使用字符高效流赋值文档

		// 1创建要操作的文件对象
		File oldFile = new File("F://test/shz.txt");
		// 创建要写入的文件对象
		File newFile = new File("F://test/shz3.txt");
		newFile.createNewFile();
		// 2创建相应的流
		// 创建文件字符读取流
		FileReader fr = new FileReader(oldFile);
		// 创建文件高效字符读取流
		BufferedReader br = new BufferedReader(fr);
		// 创建文件字符写入流
		FileWriter fw = new FileWriter(newFile);
		// 创建文件高效字符写入流
		BufferedWriter bw = new BufferedWriter(fw);
		// 3进行流操作
		// 创建存储数据的字符数组与每次读取的字符串
		String str = "";
		while ((str = br.readLine()) != null) {
			bw.write(str);
			bw.newLine();//输入换行
		}
		// 4 关闭流释放资源
		br.close();
		bw.flush();
		bw.close();

字节流与字符流对比

字符流可以理解为进一步使用的字节流，本质还是字节流，只不过每次进行操作时操作多个字节

字节流	字符流
操作时不会用到缓冲区（内存）	操作时使用了缓冲区（内存）
以字节为单位输入输出数据	以字符为单位输入输出数据
字节流按照8位传输	字符流按照16位传输