IO流

1 IO流
- 1.1 IO流概述
- 1.2 IO流的分类
- 1.3 IO流的使用场景
2 File类
- 2.1 File类概述
- 2.2 File类构造方法
- 2.3 File类常用方法
- 2.4 File类案例
3 字节流
- 3.1 字节流写数据
- 3.2 字节流写数据的三种方式
- 3.3 字节流写数据加异常处理
- 3.4 字节流读数据
- 3.5 字节流复制文件
4 字节缓冲流
- 4.1 字节缓冲流概述
- 4.2 字节缓冲流构造方法
- 4.3 小结
5 字符流
- 5.1 字符流概述
- 5.2 字符串的编码解码
- 5.3 字符流写数据
- 1.4 字符流读数据
- 5.5 字符流案例
6 字符缓冲流
- 6.1 构造方法
- 6.2 特有方法
- 6.3 缓冲流案例

1 IO流

之前存储的数据是不能够永久化存储的，只要代码运行结束，所有数据都会丢失。而想要数据永久话存储就必须要用到IO，可以跟本地硬盘交互。

1.1 IO流概述

IO：输入/输出(Input/Output)
- I表示input，是数据从硬盘进内存的过程，称为读
- O表示output，是数据从内存到硬盘的过程，称为写
流：是一种抽象概念，是对数据传输的总称，也就是说数据在设备间的传输称为流，流的本质是数据传输

IO的数据传输，可以看做是一种数据的流动，按照流动的方向，以内存为参照物，进行读写操作。

1.2 IO流的分类

按照数据的流向
- 输入流：读数据
- 输出流：写数据
按照数据类型来分
- 字节流
  - 字节输入流
  - 字节输出流
- 字符流
  - 字符输入流
  - 字符输出流

在这里插入图片描述

1.3 IO流的使用场景

如果操作的是纯文本文件，优先使用字符流
如果操作的是图片、视频、音频等二进制文件，优先使用字节流
如果不确定文件类型，优先使用字节流，字节流是万能的流

纯文本文件：用Windows自带的记事本打开能读懂的文件就是纯文本文件，txt文件就直接是纯文本文件

2 File类

2.1 File类概述

File类

它是文件和目录路径名的抽象表示
文件和目录是可以通过File封装成对象的
对于File而言，其封装的并不是一个真正存在的文件，仅仅是一个路径名而已。它可以是存在的，也可以是不存在的，将来是要通过具体的操作把这个路径的内容转换为具体存在的
在读写数据时告诉虚拟机要操作的（文件/文件夹）在哪
对（文件/文件夹）进行操作，包括创建、删除等

2.2 File类构造方法

在这里插入图片描述

public static void main(String[] args) {
	//method1();
	//method2();
	//method3();
}

private static void method3() {
	//File(File parent, String child)      从父抽象路径名和子路径名字符串创建新的File实例
	File file1 = new File("C:\\it");
	String path = "a.txt";
	File file = new File(file1,path);
	System.out.println(file);//C:\it\a.txt
}

private static void method2() {
	//File(String parent, String child)    从父路径名字符串和子路径名字符串创建新的File实例
	String path1 = "C:\\it";
	String path2 = "a.txt";
	File file = new File(path1,path2);//把两个路径拼接.
	System.out.println(file);//C:\it\a.txt
}

private static void method1() {
	//File(String pathname)        通过将给定的路径名字符串转换为抽象路径名来创建新的File实例
	String path = "C:\\it\\a.txt";
	File file = new File(path);
	//问题:为什么要把字符串表示形式的路径变成File对象?
	//就是为了使用File类里面的方法.
}

注意：

绝对路径
是一个完整的路径,从盘符开始

相对路径
是一个简化的路径,相对当前项目下的路径

public static void main(String[] args) {
    // 是一个完整的路径,从盘符开始
    File file1 = new File("D:\\it\\a.txt");

    // 是一个简化的路径,从当前项目根目录开始
    File file2 = new File("a.txt");
    File file3 = new File("模块名\\a.txt");
}

2.3 File类常用方法

创建功能

在这里插入图片描述

public static void main(String[] args) throws IOException {
	//public boolean createNewFile()    创建一个新的空的文件
			//注意点:
				//1.如果文件存在,那么创建失败,返回false
				//2.如果文件不存在,那么创建成功,返回true
				//3.createNewFile方法不管调用者有没有后缀名,只能创建文件.

	//public boolean mkdir()            创建一个单级文件夹
			//注意点:
				//1.只能创建单级文件夹,不能创建多级文件夹
				//2.不管调用者有没有后缀名,只能创建单级文件夹

	//public boolean mkdirs()           创建一个多级文件夹
			//注意点:
				//1,可以创建单级文件夹,也可以创建多级文件夹
				//2.不管调用者有没有后缀名,只能创建文件夹

	//疑问:
		//既然mkdirs能创建单级,也能创建多级.那么mkdir还有什么用啊? 是的


	//method1();
	//method2();

	File file = new File("C:\\it\\aaa.txt");
	boolean result = file.mkdirs();
	System.out.println(result);
}

private static void method2() {
	File file = new File("C:\\it\\aaa.txt");
	boolean result = file.mkdir();
	System.out.println(result);
}

private static void method1() throws IOException {
	File file1 = new File("C:\\it\\aaa");
	boolean result1 = file1.createNewFile();
	System.out.println(result1);
}

删除功能

在这里插入图片描述

//注意点:
	//1.不走回收站的.
	//2.如果删除的是文件,那么直接删除.如果删除的是文件夹,那么能删除空文件夹
	//3.如果要删除一个有内容的文件夹,只能先进入到这个文件夹,把里面的内容全部删除完毕,才能再次删除这个文件夹
//简单来说:
	//只能删除文件和空文件夹.
public static void main(String[] args) {
	//method1();
	File file = new File("C:\\it");
	boolean result = file.delete();
	System.out.println(result);
}

private static void method1() {
	File file = new File("C:\\it\\a.txt");
	boolean result = file.delete();
	System.out.println(result);
}

判断功能

在这里插入图片描述

public static void main(String[] args) {
	//method1();
	//method2();
	
private static void method2() {
	File file = new File("a.txt");
	boolean result = file.exists();
	System.out.println(result);
}

private static void method1() {
	File file = new File("C:\\it\\a.txt");
	boolean result1 = file.isFile();
	boolean result2 = file.isDirectory();
	System.out.println(result1);
	System.out.println(result2);
}

获取功能

在这里插入图片描述

public static void main(String[] args) {
   File file = new File("D:\\aaa");
   System.out.println(f.getAbsolutePath());
   System.out.println(f.getPath());
   System.out.println(f.getName());

	File[] files = file.listFiles();//返回值是一个File类型的数组
	System.out.println(files.length);
	for (File path : files) {
		System.out.println(path);
	}
}

注意：

当调用者不存在时，listFiles方法返回null
当调用者是一个文件时，listFiles方法返回null
当调用者是一个空文件夹时，listFiles方法返回一个长度为0的数组
当调用者是一个有内容的文件夹时，进入文件夹，listFiles方法会获取这个文件夹里面所有的文件和文件夹的File对象，并把这些File对象都放在一个数组中返回。包括隐藏文件和隐藏文件夹都可以获取。
当调用者是一个有权限才能进入的文件夹时，listFiles方法返回null

2.4 File类案例

在当前模块下的aaa文件夹中创建一个a.txt文件

public static void main(String[] args) throws IOException {
   /* File file = new File("filemodule\\aaa\\a.txt");
	file.createNewFile();*/
	//注意点:文件所在的文件夹必须要存在.

	File file = new File("filemodule\\aaa");
	if(!file.exists()){
		//如果文件夹不存在,就创建出来
		file.mkdirs();
	}
	File newFile = new File(file,"a.txt");
	newFile.createNewFile();
}

删除一个多级文件夹

public static void main(String[] args) {
	//delete方法
	//只能删除文件和空文件夹.
	//如果现在要删除一个有内容的文件夹?
	//先删掉这个文件夹里面所有的内容.
	//最后再删除这个文件夹
	File src = new File("C:\\Users\\apple\\Desktop\\src");
	deleteDir(src);
}

private static void deleteDir(File src) {
	//先删掉这个文件夹里面所有的内容.
	//递归 方法在方法体中自己调用自己.
	//注意: 可以解决所有文件夹和递归相结合的题目
	//1.进入 --- 得到src文件夹里面所有内容的File对象.
	File[] files = src.listFiles();
	//2.遍历 --- 因为我想得到src文件夹里面每一个文件和文件夹的File对象.
	for (File file : files) {
		if(file.isFile()){
			//3.判断 --- 如果遍历到的File对象是一个文件,那么直接删除
			file.delete();
		}else{
			//4.判断
			//递归
			deleteDir(file);//参数一定要是src文件夹里面的文件夹File对象
		}
	}
	//最后再删除这个文件夹
	src.delete();
}

统计一个文件夹中，每种文件出现的次数

public static void main(String[] args) {
	//统计 --- 定义一个变量用来统计. ---- 弊端:同时只能统计一种文件
	//利用map集合进行数据统计,键 --- 文件后缀名  值 ----  次数

	File file = new File("filemodule");
	HashMap<String, Integer> hm = new HashMap<>();
	getCount(hm, file);
	System.out.println(hm);
}

private static void getCount(HashMap<String, Integer> hm, File file) {
	File[] files = file.listFiles();
	for (File f : files) {
		if(f.isFile()){
			String fileName = f.getName();
			String[] fileNameArr = fileName.split("\\.");
			if(fileNameArr.length == 2){
				String fileEndName = fileNameArr[1];
				if(hm.containsKey(fileEndName)){
					//已经存在
					//将已经出现的次数获取出来
					Integer count = hm.get(fileEndName);
					//这种文件又出现了一次.
					count++;
					//把已经出现的次数给覆盖掉.
					hm.put(fileEndName,count);
				}else{
					//不存在
					//表示当前文件是第一次出现
					hm.put(fileEndName,1);
				}
			}
		}else{
			getCount(hm,f);
		}
	}
}

3 字节流

3.1 字节流写数据

字节流抽象基类
- InputStream：这个抽象类是表示字节输入流的所有类的超类
- OutputStream：这个抽象类是表示字节输出流的所有类的超类
- 子类名特点：子类名称都是以其父类名作为子类名的后缀
字节输出流
- FileOutputStream(String name)：创建文件输出流以指定的名称写入文件
使用字节输出流写数据的步骤
- 创建字节输出流对象(调用系统功能创建了文件，创建字节输出流对象，让字节输出流对象指向文件)
- 调用字节输出流对象的写数据方法
- 释放资源(关闭此文件输出流并释放与此流相关联的任何系统资源)

public static void main(String[] args) throws IOException {
	//1.创建字节输出流的对象 --- 告诉虚拟机我要往哪个文件中写数据了
	FileOutputStream fos = new FileOutputStream("D:\\a.txt");
	//FileOutputStream fos = new FileOutputStream(new File("D:\\a.txt"));

	//2,写数据，传递一个整数时，那么实际上写到文件中的，是这个整数在码表中对应的那个字符.
	fos.write(97); //会在文件中写入a

	//3,释放资源，告诉操作系统，我现在已经不要再用这个文件了
	fos.close();
}

注意：

如果文件不存在，会帮我们自动创建出来.
如果文件存在，会把文件清空.

3.2 字节流写数据的三种方式

在这里插入图片描述

public static void main(String[] args) throws IOException {
    FileOutputStream fos = new FileOutputStream("bytestream\\a.txt");
  /*fos.write(97);
    fos.write(98);
    fos.write(99);*/
    
    /* byte [] bys = {97,98,99};
    fos.write(bys);*/

    byte [] bys = {97,98,99,100,101,102,103};
    fos.write(bys,1,2); //98,99即写入bc
    
    fos.close();
}

那么，现在有两个小问题

字节流写数据如何实现换行？
windows:\r\n
linux:\n
mac:\r
getBytes()是字符串的一个方法，可以将字符串转换为字节

字节流写数据如何实现追加写入？
public FileOutputStream(String name,boolean append)
创建文件输出流以指定的名称写入文件。如果第二个参数为true ，则字节将写入文件的末尾而不是开头

public static void main(String[] args) throws IOException {
	//第二个参数就是续写开关,如果没有传递,默认就是false,
	//表示不打开续写功能,那么创建对象的这行代码会清空文件.

	//如果第二个参数为true,表示打开续写功能
	//那么创建对象的这行代码不会清空文件.
	FileOutputStream fos = new FileOutputStream("bytestream\\a.txt",true);

	fos.write(97);
	//加一个换行
	fos.write("\r\n".getBytes());
	fos.write(98);
	//加一个换行
	fos.write("\r\n".getBytes());
	fos.write(99);
	//加一个换行
	fos.write("\r\n".getBytes());
	fos.write(100);
	//加一个换行
	fos.write("\r\n".getBytes());
	fos.write(101);
	//加一个换行
	fos.write("\r\n".getBytes());

	fos.close();
}

3.3 字节流写数据加异常处理

有如下代码：

try {
    FileOutputStream fos = new FileOutputStream("a.txt");
    fos.write(97);
    fos.close();
}catch (IOException e){
    e.printStackTrace();
}

我们如何操作才能让close方法一定执行呢？

异常处理的标准格式：

try{
	可能出现异常的代码;
}catch(异常类名 变量名){
	异常的处理代码;
}finally{
	执行所有清除操作; // 在异常处理时提供finally块来执行所有的清除操作，比如IO流的释放资源，被finally控制的语句一定会执行，除非JVM退出
}

加异常处理后的代码如下：

public static void main(String[] args) {
	FileOutputStream fos = null;
	try {
		//System.out.println(2/0);
		fos = new FileOutputStream("D:\\a.txt");
		fos.write(97);
	}catch(IOException e){
	   e.printStackTrace();
	}finally {
		//finally语句里面的代码,一定会被执行.
		if(fos != null){
			try {
				fos.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

3.4 字节流读数据

字节输入流

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

字节输入流读取数据的步骤

创建字节输入流对象
调用字节输入流对象的读数据方法
释放资源

一次读一个字节数据

public static void main(String[] args) throws IOException {
	//如果文件存在,那么就不会报错.
	//如果文件不存在,那么就直接报错.
	FileInputStream fis = new FileInputStream("bytestream\\a.txt");

	int read = fis.read();
	//一次读取一个字节,返回值就是本次读到的那个字节数据.
	//也就是字符在码表中对应的那个数字.
	//如果我们想要看到的是字符数据,那么一定要强转成char

	System.out.println(read); // 97
	System.out.println((char)read); //a

	//释放资源
	fis.close();
}

一次读多个字节数据

public static void main(String[] args) throws IOException {
	FileInputStream fis = new FileInputStream("bytestream\\a.txt");
	//文件中多个字节我怎么办?
	/*while(true){
		int i1 = fis.read(); 内容读取结束读取到空格时返回-1
		System.out.println(i1); 
	}*/ 

	int b;
	while ((b = fis.read())!=-1){
		System.out.println((char) b);
	}
	fis.close();
}

3.5 字节流复制文件

小文件复制

将C:\it\a.jpg的文件复制到模块bytestream下

public static void main(String[] args) throws IOException {
	//创建了字节输入流,准备读数据.
	FileInputStream fis = new FileInputStream("C:\\it\\a.jpg");
	//创建了字节输出流,准备写数据.
	FileOutputStream fos = new FileOutputStream("bytestream\\a.jpg");

	int b;
	while((b = fis.read())!=-1){
		fos.write(b);
	}

	fis.close();
	fos.close();
}

大文件复制

对于大文件的复制问题，字节流通过创建字节数组，可以一次读写多个数据

一次读一个字节数组的方法：

public int read(byte[] b)：从输入流读取最多b.length个字节的数据
返回的是读入缓冲区的总字节数，也就是实际的读取字节个数

public static void main(String[] args) throws IOException {
	FileInputStream fis = new FileInputStream("C:\\itheima\\a.avi");
	FileOutputStream fos = new FileOutputStream("bytestream\\a.avi");

	byte [] bytes = new byte[1024];// 该字节数组的大小是1024字节
	int len;//本次读到的有效字节个数 --- 这次读了几个字节

	while((len = fis.read(bytes))!=-1){  // 循环读取
		fos.write(bytes,0,len);//0索引开始，读取len个字节
	}

	fis.close();
	fos.close();
}

4 字节缓冲流

4.1 字节缓冲流概述

BufferedOutputStream：该类实现缓冲输出流，通过设置这样的输出流，应用程序可以向底层输出流写入字节，而不必为写入的每个字节导致底层系统的调用
BufferedInputStream：创建BufferedInputStream将创建一个内部缓冲区数组，当从流中读取或跳过字节时，内部缓冲区将根据需要从所包含的输入流中重新填充，一次很多字节

4.2 字节缓冲流构造方法

在这里插入图片描述

一次读写一个字节

public static void main(String[] args) throws IOException {
	//就要利用缓冲流去拷贝文件

	//创建一个字节缓冲输入流
	//在底层创建了一个默认长度为8192的字节数组。
	BufferedInputStream bis = new BufferedInputStream(new FileInputStream("bytestream\\a.avi"));
	//创建一个字节缓冲输出流
	//在底层也创建了一个默认长度为8192的字节数组。
	BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("bytestream\\copy.avi"));

	int b;
	while((b = bis.read()) != -1){
		bos.write(b);
	}

	//方法的底层会把字节流给关闭。
	bis.close();
	bos.close();
}

一次读写一个字节数组

public static void main(String[] args) throws IOException {
	//缓冲流结合数组，进行文件拷贝

	//创建一个字节缓冲输入流
	BufferedInputStream bis = new BufferedInputStream(new FileInputStream("bytestream\\a.avi"));

	//创建一个字节缓冲输出流
	BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("bytestream\\copy.avi"));

	byte [] bytes = new byte[1024];
	int len;
	while((len = bis.read(bytes)) != -1){
		bos.write(bytes,0,len);
	}

	bis.close();
	bos.close();
}

为什么构造方法需要的是字节流，而不是具体的文件或者路径呢？

字节缓冲流仅仅提供缓冲区，而真正读写数据还是得依靠基本的字节流对象进行操作

4.3 小结

字节流：

可以操作（拷贝）所有类型的文件

字节缓冲流：

可以提高效率；
不能直接操作文件，需要传递字节流

拷贝文件的四种方式：

字节流一次读写一个字节
字节流一次读写一个字节数组
字节缓冲流一次读写一个字节
字节缓冲流一次读写一个字节数组

5 字符流

5.1 字符流概述

既然字节流可以操作所有文件，为什么要学习字符流？

如果利用字节流，把文本文件中的中文，读取到内存中，有可能出现乱码
如果利用字节流，把中文写到文本文件中，也有可能出现乱码

为什么字节流读取文本文件，可能会出现乱码？

因为字节流一次读一个字节，而不管GBK还是UTF-8一个中文都是多个字节，用字节流每次只能读其中的一部分，所以会出现乱码的问题

由于字节流操作中文不是特别的方便，所以Java就提供字符流（字符流 = 字节流 + 编码表）

计算某种规则，将字符变成二进制，再存储到计算机中，称为编码
按照同样的规则，将存储在计算机中的二进制数解析显示出来，称为解码
编码和解码的方式必须一致，否则会导致乱码

Windows默认使用码表为：GBK，一个中文两个字节
IDEA和以后工作默认使用Unicode的UTF-8编码格式，一个中文三个字节
不管是在哪张码表中，中文的第一个字节一定是负数

注意：

想要进行拷贝，一律使用字节流或者字节缓冲流
想要把文本文件中的数据读到内存中，使用字符输入流
想要把内存中的数据写到文本文件中，使用字符输出流

5.2 字符串的编码解码

在这里插入图片描述

public static void main(String[] args) throws UnsupportedEncodingException {
    method1();
    method2();
}

private static void method2() throws UnsupportedEncodingException {
    byte[] bytes =  {-28, -67, -96, -27, -91, -67, -28, -72, -106, -25, -107, -116};

    //利用默认的UTF-8进行解码
    String s1 = new String(bytes);
    System.out.println(s1);//你好世界

    //利用指定的编码进行解码
    String s2 = new String(bytes,"UTF-8");
    System.out.println(s2);//你好世界
}

private static void method1() throws UnsupportedEncodingException {
    String s  = "你好世界";
    //利用idea默认的UTF-8将中文编码为一系列的字节
    byte[] bytes1 =  s.getBytes();
    System.out.println(Arrays.toString(bytes1)); // [-28, -67, -96, -27, -91, -67, -28, -72, -106, -25, -107, -116]

    byte[] bytes2 =  s.getBytes("UTF-8");
    System.out.println(Arrays.toString(bytes1)); // [-28, -67, -96, -27, -91, -67, -28, -72, -106, -25, -107, -116]
}

5.3 字符流写数据

Writer: 用于写入字符流的抽象父类
FileWriter: 用于写入字符流的常用子类

构造方法：

在这里插入图片描述

成员方法：

在这里插入图片描述

public static void main(String[] args) throws IOException {
    //创建字符输出流的对象
    //FileWriter fw = new FileWriter(new File("charstream\\a.txt"));
    FileWriter fw = new FileWriter("charstream\\a.txt");


    //写一个字符
    fw.write(97);
    fw.write(98);
    fw.write(99);


    //写出一个字符数组
    char [] chars1 = {97,98,99,100,101};
    fw.write(chars1);


    //写出字符数组的一部分
    char [] chars2 = {97,98,99,100,101};
    fw.write(chars2,0,3);


    //写一个字符串
    String line1 = "黑马程序员abc";
    fw.write(line1);


    //写一个字符串的一部分
    String line2 = "黑马程序员abc";
    fw.write(line2, 0, 2);

    //释放资源
    fw.close();
}

注意：

在创建字符输出流对象时，如果文件存在就清空，如果文件不存在就创建，但是要保证父级路径存在
写数据时，写出int类型的整数，实际写出的是整数在码表上对应的字母，写出字符串数据，是把字符串本身原样输出

刷新和关闭的方法：

在这里插入图片描述

1.4 字符流读数据

Reader: 用于读取字符流的抽象父类
FileReader: 用于读取字符流的常用子类

构造方法

在这里插入图片描述

成员方法

在这里插入图片描述

public static void main(String[] args) throws IOException {
    //创建字符输入流的对象
    // FileReader fr = new FileReader(new File("charstream\\a.txt"));
    FileReader fr = new FileReader("charstream\\a.txt");

    //读取数据
    
    //一次读取一个字符
/*        int ch;
    while((ch = fr.read()) != -1){
        System.out.println((char) ch);
    }*/


    //一次读取多个字符。
    //创建一个数组
    char [] chars = new char[1024];
    int len;
    //read方法还是读取，但是是一次读取多个字符
    //他把读到的字符都存入到chars数组。
    //返回值：表示本次读到了多少个字符。
    while((len = fr.read(chars))!=-1){
        System.out.println(new String(chars,0,len));
    }

    //释放资源
    fr.close();
}

5.5 字符流案例

案例需求：
- 将键盘录入的用户名和密码保存到本地实现永久化存储
实现步骤：
- 获取用户输入的用户名和密码
- 将用户输入的用户名和密码写入到本地文件中
- 关流，释放资源
示例代码：

public static void main(String[] args) throws IOException {
	//将键盘录入的用户名和密码保存到本地实现永久化存储
	//要求：用户名独占一行，密码独占一行

	//分析：
	//1，实现键盘录入，把用户名和密码录入进来
	Scanner sc = new Scanner(System.in);
	System.out.println("请录入用户名");
	String username = sc.next();
	System.out.println("请录入密码");
	String password = sc.next();

	//2.分别把用户名和密码写到本地文件。
	FileWriter fw = new FileWriter("charstream\\a.txt");
	//将用户名和密码写到文件中
	fw.write(username);
	//表示写出一个回车换行符 windows \r\n  MacOS \r  Linux \n
	fw.write("\r\n");
	fw.write(password);
	//刷新流
	fw.flush();
	//释放资源
	fw.close();
}

6 字符缓冲流

6.1 构造方法

在这里插入图片描述

BufferedWriter：将文本写入字符输出流，缓冲字符，以提供单个字符，数组和字符串的高效写入，可以指定缓冲区大小，或者可以接受默认大小。默认值足够大，可用于大多数用途
BufferedReader：从字符输入流读取文本，缓冲字符，以提供字符，数组和行的高效读取，可以指定缓冲区大小，或者可以使用默认大小。默认值足够大，可用于大多数用途

public static void main(String[] args) throws IOException {
    read();
    write();
}

private static void write() throws IOException {
    //字符缓冲输出流
    BufferedWriter bw = new BufferedWriter(new FileWriter("charstream\\a.txt"));

    //写出数据
    //实际写出的是97对应的字符a
    bw.write(97);
    bw.write("\r\n");

    //实际写出的是97 - 101 对应的字符 abcde
    char [] chars = {97,98,99,100,101};
    bw.write(chars);
    bw.write("\r\n");

    //实际写的是abc
    bw.write(chars,0,3);
    bw.write("\r\n");

    //会把字符串的内容原样写出
    bw.write("我是一个程序员");
    bw.write("\r\n");

    //会把字符串的一部分写出 abcde
    String line = "abcdefg";
    bw.write(line,0,5);
    
    bw.flush();
    bw.close();

}

private static void read() throws IOException {
    //字符缓冲输入流
    BufferedReader br = new BufferedReader(new FileReader("charstream\\a.txt"));

    //读取数据
    char [] chars = new char[1024];
    int len;
    while((len = br.read(chars)) != -1){
        System.out.println(new String(chars,0,len));
    }

    br.close();
}

6.2 特有方法

BufferedWriter：

在这里插入图片描述

public static void main(String[] args) throws IOException {
	//字符缓冲流的特有功能
	//字符缓冲输出流BufferedWrite ： newLine  跨平台的换行符


	//创建对象
	BufferedWriter bw = new BufferedWriter(new FileWriter("charstream\\a.txt"));


	//写出数据
	bw.write("程序员666");
	//跨平台的回车换行
	bw.newLine();
	bw.write("abcdef");
	//跨平台的回车换行
	bw.newLine();
	bw.write("-------------");

	//刷新流
	bw.flush();
	//释放资源
	bw.close();
}

BufferedReader：

在这里插入图片描述

public static void main(String[] args) throws IOException {
    //字符缓冲流的特有功能
    //字符缓冲输入流BufferedReader： readLine 读一整行

    //创建对象
    BufferedReader br = new BufferedReader(new FileReader("charstream\\a.txt"));


/*        //读取数据
    String line1 = br.readLine();
    String line2 = br.readLine();
    String line3 = br.readLine();
    //在之前，如果读不到数据，返回-1
    //但是readLine如果读不到数据返回null
    String line4 = br.readLine();
    System.out.println(line1);
    System.out.println(line2);
    System.out.println(line3);
    System.out.println(line4);*/

    //使用循环来进行改进
    String line;
    //可以读取一整行数据。一直读，读到回车换行为止。
    //但是他不会读取回车换行符。
    while((line = br.readLine()) != null){
        System.out.println(line);
    }
    
    // 释放资源
    br.close();
}

6.3 缓冲流案例

字符缓冲流操作文件中数据排序案例

案例需求
- 使用字符缓冲流读取文件中的数据，排序后再次写到本地文件
实现步骤
- 将文件中的数据读取到程序中
- 对读取到的数据进行处理
- 将处理后的数据添加到集合中
- 对集合中的数据进行排序
- 将排序后的集合中的数据写入到文件中
代码实现

public static void main(String[] args) throws IOException {
	//需求：读取文件中的数据，排序后再次写到本地文件
	//分析：
	//1.要把文件中的数据读取进来。
	BufferedReader br = new BufferedReader(new FileReader("charstream\\sort.txt"));
	//输出流一定不能写在这里，因为会清空文件中的内容
	//BufferedWriter bw = new BufferedWriter(new FileWriter("charstream\\sort.txt"));

	String line = br.readLine();
	System.out.println("读取到的数据为" + line);
	br.close();

	//2.按照空格进行切换
	String[] split = line.split(" ");//9 1 2 5 3 10 4 6 7 8
	//3.把字符串类型的数组变成int类型
	int [] arr = new int[split.length];
	//遍历split数组，可以进行类型转换。
	for (int i = 0; i < split.length; i++) {
		String smallStr = split[i];
		//类型转换
		int number = Integer.parseInt(smallStr);
		//把转换后的结果存入到arr中
		arr[i] = number;
	}
	//4.排序
	Arrays.sort(arr);
	System.out.println(Arrays.toString(arr));


	//5.把排序之后结果写回到本地 1 2 3 4...
	BufferedWriter bw = new BufferedWriter(new FileWriter("charstream\\sort.txt"));
	//写出
	for (int i = 0; i < arr.length; i++) {
		bw.write(arr[i] + " ");
		bw.flush();
	}
	//释放资源
	bw.close();
}