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类常用方法

1. 创建功能

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);
}

2. 删除功能

//注意点://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);
}

3. 判断功能

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);
}

4. 获取功能

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类案例

1. 在当前模块下的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();
}

2. 删除一个多级文件夹

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();
}

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

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即写入bcfos.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命名

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

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

1. 一次读一个字节数据

public static void main(String[] args) throws IOException {//如果文件存在,那么就不会报错.//如果文件不存在,那么就直接报错.FileInputStream fis = new FileInputStream("bytestream\\a.txt");int read = fis.read();//一次读取一个字节,返回值就是本次读到的那个字节数据.//也就是字符在码表中对应的那个数字.//如果我们想要看到的是字符数据,那么一定要强转成charSystem.out.println(read); // 97System.out.println((char)read); //a//释放资源fis.close();
}

2. 一次读多个字节数据

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

3.5 字节流复制文件

1. 小文件复制

将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();
}

2. 大文件复制

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

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

• 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 字节缓冲流构造方法

1. 一次读写一个字节

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();
}

2. 一次读写一个字节数组

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 \nfw.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对应的字符abw.write(97);bw.write("\r\n");//实际写出的是97 - 101 对应的字符 abcdechar [] chars = {97,98,99,100,101};bw.write(chars);bw.write("\r\n");//实际写的是abcbw.write(chars,0,3);bw.write("\r\n");//会把字符串的内容原样写出bw.write("我是一个程序员");bw.write("\r\n");//会把字符串的一部分写出 abcdeString 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如果读不到数据返回nullString 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();
}