【尚硅谷_java基础】十四、IO流

已于 2022-01-21 16:58:08 修改
阅读量1.2k 收藏 9
点赞数 5
分类专栏： # java基础 文章标签： java 开发语言 后端
于 2022-01-21 16:55:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42301220/article/details/122519268
版权

文章目录

返回总目录

参考资料

  1. https://blog.csdn.net/PorkBird/article/details/113727505
  2. https://www.bilibili.com/video/BV1Kb411W75N?p=605

1. File类的使用

1.1 实例化

  • java.io.File类：文件和文件目录路径的抽象表示形式，与平台无关

  • File 能新建、删除、重命名文件和目录，但File 不能访问文件内容本身。如果需要访问文件内容本身，则需要使用输入/输出流。

  • 想要在Java程序中表示一个真实存在的文件或目录，那么必须有一个File对象，但是Java程序中的一个File对象，可能没有一个真实存在的文件或目录。

  • File对象可以作为参数传递给流的构造器

  • 常用构造器

    • public File(String pathname)
      以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
      • 绝对路径： 是一个固定的路径,从盘符开始
      • 相对路径： 是相对于某个位置开始
    • public File(String parent,String child)
      以parent为父路径， child为子路径创建File对象。
    • public File(File parent,String child)
      根据一个父File对象和子文件路径创建File对象

  • 路径分隔符

    • 路径中的每级目录之间用一个路径分隔符隔开。

    • 路径分隔符和系统有关：

      • windows和DOS系统默认使用“\”来表示
      • UNIX和URL使用“/”来表示

    • Java程序支持跨平台运行，因此路径分隔符要慎用。

    • 为了解决这个隐患， File类提供了一个常量:
      public static final String separator。根据操作系统，动态的提供分隔符。

    • 示例

      File file1 = new File("d:\\atguigu\\info.txt");
File file2 = new File("d:" + File.separator + "atguigu" + File.separator + "info.txt");
File file3 = new File("d:/atguigu");

1.2 常用方法

  • File类的获取功能

    * public String getAbsolutePath()：获取绝对路径
* public String getPath() ：获取路径
* public String getName() ：获取名称
* public String getParent()：获取上层文件目录路径。若无，返回null
* public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
* public long lastModified() ：获取最后一次的修改时间，毫秒值
  • 如下的两个方法适用于文件目录：
    * public String[] list() ：获取指定目录下的所有文件或者文件目录的名称数组
    * public File[] listFiles()：获取指定目录下的所有文件或者文件目录的File数组

  • File类的重命名功能

     *  public boolean renameTo(File dest):把文件重命名为指定的文件路径
 *    比如：file1.renameTo(file2)为例：
 *         要想保证返回true,需要file1在硬盘中是存在的，且file2不能在硬盘中存在。

  • File类的判断功能

     public boolean isDirectory()： 判断是否是文件目录
 public boolean isFile() ： 判断是否是文件
 public boolean exists() ： 判断是否存在
 public boolean canRead() ： 判断是否可读
 public boolean canWrite() ： 判断是否可写
 public boolean isHidden() ： 判断是否隐藏

  • 示例

    package pers.chh3213.file;

import java.io.File;

public class FileCreate {
    public static void main(String[] args) {
        File file = new File("hello.txt");//相对于当前module
        System.out.println(file.getAbsoluteFile());
        System.out.println(file.getPath());
        System.out.println(file.getName());
        System.out.println(file.getParent());
        boolean isTrue = file.exists();
        System.out.println(isTrue);
    }
}

  • File类的创建功能

    public boolean createNewFile() ： 创建文件。 若文件存在， 则不创建， 返回false
public boolean mkdir() ： 创建文件目录。 如果此文件目录存在， 就不创建了。如果此文件目录的上层目录不存在， 也不创建。
public boolean mkdirs() ： 创建文件目录。 如果上层文件目录不存在， 一并创建

    注意事项：如果你创建文件或者文件目录没有写盘符路径， 那么， 默认在项目路径下。

    • 举例

      File dir1 = new File("D:/IOTest/dir1");
if (!dir1.exists()) { // 如果D:/IOTest/dir1不存在，就创建为目录
dir1.mkdir();
}
// 创建以dir1为父目录,名为"dir2"的File对象
File dir2 = new File(dir1, "dir2");
if (!dir2.exists()) { // 如果还不存在，就创建为目录
dir2.mkdirs();
}
File dir4 = new File(dir1, "dir3/dir4");
if (!dir4.exists()) {
dir4.mkdirs();
}
// 创建以dir2为父目录,名为"test.txt"的File对象
File file = new File(dir2, "test.txt");
if (!file.exists()) { // 如果还不存在，就创建为文件
file.createNewFile();
}

  • File类的删除功能

    public boolean delete()： 删除文件或者文件夹

    删除注意事项：
    Java中的删除不走回收站。要删除一个文件目录， 请注意该文件目录内不能包含文件或者文件目录

在这里插入图片描述

当硬盘中真有一个真实的文件或目录存在时，创建File对象时，各个属性会显式赋值。
当硬盘中没有真实的文件或目录对应时，那么创建对象时，除了指定的目录和路径外，其他的属性都是取成员变量的默认值。

1.3 练习

  1. 利用File构造器， new 一个文件目录file
    1)在其中创建多个文件和目录
    2)编写方法，实现删除file中指定文件的操作
package pers.chh3213.file;

import org.junit.Test;

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

public class FileExercise {
    /**
     * 1. 利用File构造器， new 一个文件目录file
     * 	1)在其中创建多个文件和目录
     * 	2)编写方法，实现删除file中指定文件的操作
     */
    @Test
    public void test01(){
        File dir = new File("src/pers/chh3213/file/test01");
        if(!dir.exists()){
            dir.mkdirs();
        }
        File file1 = new File(dir, "01.txt");
        File file2 = new File(dir, "02.txt");
        try{
            file1.createNewFile();
            file2.createNewFile();
        }catch (IOException e){
            e.printStackTrace();
        }
        File dir2 = new File(dir, "/dir");
        if(!dir2.exists()){
            dir2.mkdirs();
        }
        delFile(file1);


    }
    public void delFile(File file){
        file.delete();
    }
}
  1. 判断指定目录下是否有后缀名为.jpg的文件，如果有，就输出该文件名称
	@Test
    public void test02(){
        /**
         *  判断指定目录下是否有后缀名为.jpg的文件，如果有，就输出该文件名称
         */
        File dir = new File("src/pers/chh3213/file/test01");

        isExist(dir);

    }
    public void isExist(File dir){
        String[] files = dir.list();
        for (String file:files
             ) {
            if(file.endsWith(".jpg")){
                System.out.println(file);
            }
        }

    }
  1. 遍历指定目录所有文件名称，包括子文件目录中的文件。
    拓展1：并计算指定目录占用空间的大小
    拓展2：删除指定文件目录及其下的所有文件
package pers.chh3213.file;

import org.junit.Test;

import java.io.File;

public class ListFileTest {
    @Test
    public  void test() {
        // 递归:文件目录
        /** 打印出指定目录所有文件名称，包括子文件目录中的文件 */

        // 1.创建目录对象
        File dir = new File("src/pers/chh3213/file/test01");

        // 2.打印目录的子文件
        printSubFile(dir);
    }

    public  void printSubFile(File dir) {
        // 打印目录的子文件
        File[] subfiles = dir.listFiles();

        for (File f : subfiles) {
            if (f.isDirectory()) {// 文件目录
                printSubFile(f);
            } else {// 文件
                System.out.println(f.getAbsolutePath());
            }

        }
    }

    // 方式二：循环实现
    // 列出file目录的下级内容，仅列出一级的话
    // 使用File类的String[] list()比较简单
    public  void listSubFiles(File file) {
        if (file.isDirectory()) {
            String[] all = file.list();
            for (String s : all) {
                System.out.println(s);
            }
        } else {
            System.out.println(file + "是文件！");
        }
    }

    // 列出file目录的下级，如果它的下级还是目录，接着列出下级的下级，依次类推
    // 建议使用File类的File[] listFiles()
    public  void listAllSubFiles(File file) {
        if (file.isFile()) {
            System.out.println(file);
        } else {
            File[] all = file.listFiles();
            // 如果all[i]是文件，直接打印
            // 如果all[i]是目录，接着再获取它的下一级
            for (File f : all) {
                listAllSubFiles(f);// 递归调用：自己调用自己就叫递归
            }
        }
    }

    // 拓展1：求指定目录所在空间的大小
    // 求任意一个目录的总大小
    public  long getDirectorySize(File file) {
        // file是文件，那么直接返回file.length()
        // file是目录，把它的下一级的所有大小加起来就是它的总大小
        long size = 0;
        if (file.isFile()) {
            size += file.length();
        } else {
            File[] all = file.listFiles();// 获取file的下一级
            // 累加all[i]的大小
            for (File f : all) {
                size += getDirectorySize(f);// f的大小;
            }
        }
        return size;
    }

    // 拓展2：删除指定的目录
    public  void deleteDirectory(File file) {
        // 如果file是文件，直接delete
        // 如果file是目录，先把它的下一级干掉，然后删除自己
        if (file.isDirectory()) {
            File[] all = file.listFiles();
            // 循环删除的是file的下一级
            for (File f : all) {// f代表file的每一个下级
                deleteDirectory(f);
            }
        }
        // 删除自己
        file.delete();
    }
}

2. IO流原理及流的分类

2.1 Java IO原理

  • I/O是Input/Output的缩写，I/O技术是非常实用的技术，用于处理设备之间的数据传输。如读/写文件，网络通讯等。
  • Java程序中，对于数据的输入/输出操作以“流(stream)”的方式进行。
  • java.io包下提供了各种“流”类和接口，用以获取不同种类的数据，并通过标准的方法输入或输出数据。
  • 输入input：读取外部数据（磁盘、光盘等存储设备的数据）到程序（内存）中。
  • 输出output：将程序（内存）数据输出到磁盘、光盘等存储设备中。

在这里插入图片描述

2.2 流的分类

  • 按操作数据单位不同分为：字节流(8 bit)，字符流(16 bit)

  • 按数据流的流向不同分为：输入流，输出流

  • 按流的角色的不同分为：节点流，处理流
    在这里插入图片描述

  • Java的IO流共涉及40多个类，实际上非常规则，都是从如下4个抽象基类派生的。

  • 由这四个类派生出来的子类名称都是以其父类名作为子类名后缀。

在这里插入图片描述

2.3 IO流体系

在这里插入图片描述

2.4 节点流和处理流

  • 节点流：直接从数据源或目的地读写数据
    在这里插入图片描述

  • 处理流：不直接连接到数据源或目的地，而是“连接” 在已存在的流（节点流或处理流）之上，通过对数据的处理为程序提供更为强大的读写功能。
    在这里插入图片描述

2.5 InputStream & Reader

  • InputStream 和 Reader 是所有输入流的基类。

  • InputStream（典型实现： FileInputStream）

  • Reader（典型实现： FileReader）

  • 程序中打开的文件 IO 资源不属于内存里的资源，垃圾回收机制无法回收该资源，所以应该显式关闭文件 IO 资源。

  • FileInputStream从文件系统中的某个文件中获得输入字节。 FileInputStream用于读取非文本数据之类的原始字节流。要读取字符流， 需要使用 FileReader

2.5.1 InputStream

  • int read()
    从输入流中读取数据的下一个字节。 返回 0 到 255 范围内的 int 字节值。 如果因为已经到达流末尾而没有可用的字节， 则返回值 -1。
  • int read(byte[] b)
    从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中。 如果因为已经到达流末尾而没有可用的字节， 则返回值 -1。 否则以整数形式返回实际读取的字节数。
  • int read(byte[] b, int off,int len)
    将输入流中最多 len 个数据字节读入 byte 数组。 尝试读取 len 个字节， 但读取的字节也可能小于该值。 以整数形式返回实际读取的字节数。 如果因为流位于
    文件末尾而没有可用的字节， 则返回值 -1。
  • public void close() throws IOException关闭此输入流并释放与该流关联的所有系统资源。

2.5.2 Reader

  • int read()
    读取单个字符。 作为整数读取的字符， 范围在 0 到 65535 之间 (0x00-0xffff)（2个字节的Unicode码） ， 如果已到达流的末尾， 则返回 -1
  • int read(char[] cbuf)
    将字符读入数组。 如果已到达流的末尾， 则返回 -1。 否则返回本次读取的字符数。
  • int read(char[] cbuf,int off,int len)
    将字符读入数组的某一部分。 存到数组cbuf中， 从off处开始存储， 最多读len个字符。 如果已到达流的末尾， 则返回 -1。 否则返回本次读取的字符数。
  • public void close() throws IOException
    关闭此输入流并释放与该流关联的所有系统资源。

2.6 OutputStream & Writer

  • 因为字符流直接以字符作为操作单位，所以 Writer 可以用字符串来替换字符数组，即以 String 对象作为参数
  • FileOutputStream 从文件系统中的某个文件中获得输出字节。FileOutputStream用于写出非文本数据之类的原始字节流。 要写出字符流， 需要使用FileWriter

2.6.1 OutputStream

  • void write(int b)
    将指定的字节写入此输出流。 write 的常规协定是：向输出流写入一个字节。 要写入的字节是参数 b 的八个低位。 b 的 24 个高位将被忽略。 即写入0~255范围的。
  • void write(byte[] b)
    将 b.length 个字节从指定的 byte 数组写入此输出流。 write(b) 的常规协定是：应该与调用 write(b, 0, b.length) 的效果完全相同。
  • void write(byte[] b,int off,int len)
    将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流。
  • public void flush()throws IOException
    刷新此输出流并强制写出所有缓冲的输出字节， 调用此方法指示应将这些字节立即写入它们预期的目标。
  • public void close() throws IOException
    关闭此输出流并释放与该流关联的所有系统资源。

2.6.2 Writer

  • void write(int c)
    写入单个字符。 要写入的字符包含在给定整数值的 16 个低位中， 16 高位被忽略。 即
    写入0 到 65535 之间的Unicode码。
  • void write(char[] cbuf)
    写入字符数组。
  • void write(char[] cbuf,int off,int len)
    写入字符数组的某一部分。 从off开始， 写入len个字符
  • void write(String str)
    写入字符串。
  • void write(String str,int off,int len)
    写入字符串的某一部分。
  • void flush()
    刷新该流的缓冲， 则立即将它们写入预期目标。
  • public void close() throws IOException
    关闭此输出流并释放与该流关联的所有系统资源。

3. 节点流(或文件流)

3.1 读取文件

  1. 建立一个流对象，将已存在的一个文件加载进流。

    FileReaderfr= new FileReader(new File(“Test.txt”));

  2. 创建一个临时存放数据的数组。

    char[] ch= new char[1024];

  3. 调用流对象的读取方法将流中的数据读入到数组中。

    fr.read(ch);

  4. 关闭资源。

    fr.close();

    package pers.chh3213.IOstream;

import org.junit.Test;

import java.io.FileReader;
import java.io.IOException;
import java.io.File;

public class ReadTest {
    @Test
    public void test01(){
        FileReader fr = null;
        try {
            fr = new FileReader(new File("src/pers/chh3213/file/test01/01.txt"));
            char[] buf = new char[1024];
            int len;
            while ((len = fr.read(buf)) != -1) {
                System.out.print(new String(buf, 0, len));
            }
        } catch (IOException e) {
            System.out.println("read-Exception :" + e.getMessage());
        } finally {
            if (fr != null) {
                try {
                    fr.close();
                } catch (IOException e) {
                    System.out.println("close-Exception :" + e.getMessage());
                }
            }
        }
    }

    //对read()操作升级：使用read的重载方法
    @Test
    public void test2(){
        FileReader fr = null;
        try {
            //1.File类的实例化
            File file = new File("src/pers/chh3213/file/test01/01.txt");

            //2.FileReader流的实例化
            fr = new FileReader(file);

            //3.读入的操作
            //read(char[] cbuf):返回每次读入cbuf数组中的字符的个数。如果达到文件末尾，返回-1
            char[] cbuf = new char[5];
            int len;
            fr.read(cbuf);
            while((len = fr.read(cbuf)) != -1){
                //方式一：
                //错误的写法
//                for(int i = 0;i < cbuf.length;i++){
//                    System.out.print(cbuf[i]);
//                }
                正确的写法
//                for(int i = 0;i < len;i++){
//                    System.out.print(cbuf[i]);
//                }

                //方式二：
                //错误的写法,对应着方式一的错误的写法
//                String str = new String(cbuf);
//                System.out.print(str);
                //正确的写法
                String str = new String(cbuf,0,len);
                System.out.print(str);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if(fr != null){
                //4.资源的关闭
                try {
                    fr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }

            }
        }

    }
}

3.2 写入文件

创建流对象，建立数据存放文件

FileWriterfw= new FileWriter(new File(“Test.txt”));

调用流对象的写入方法，将数据写入流

fw.write(“atguigu-songhongkang”);

关闭流资源，并将流中的数据清空到文件中。

fw.close();

package pers.chh3213.IOstream;

import org.junit.Test;

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

public class WriteTest {
    @Test
    public void test01(){
        FileWriter fw = null;
        try {
            File file = new File("hello.txt");
            fw = new FileWriter(file,false);
            fw.write("hello world\n");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(fw != null){

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

3.3实际使用测试

3.3.1 使用FileReader和FileWriter实现文本文件的复制

package pers.chh3213.IOstream;

import org.junit.Test;
import java.io.*;

public class CopyTest {

    @Test
    public void test() {
        FileReader fr = null;
        FileWriter fw = null;
        try {
            //1.创建File类的对象，指明读入和写出的文件
            File srcFile = new File("hello1.txt");
            File srcFile2 = new File("hello2..txt");

            //不能使用字符流来处理图片等字节数据
//            File srcFile = new File("爱情与友情.jpg");
//            File srcFile2 = new File("爱情与友情1.jpg");

            //2.创建输入流和输出流的对象
            fr = new FileReader(srcFile);
            fw = new FileWriter(srcFile2);

            //3.数据的读入和写出操作
            char[] cbuf = new char[5];
            int len;//记录每次读入到cbuf数组中的字符的个数
            while((len = fr.read(cbuf)) != -1){
                //每次写出len个字符
                fw.write(cbuf,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4.关闭流资源
            //方式一：
//            try {
//                if(fw != null)
//                    fw.close();
//            } catch (IOException e) {
//                e.printStackTrace();
//            }finally{
//                try {
//                    if(fr != null)
//                        fr.close();
//                } catch (IOException e) {
//                    e.printStackTrace();
//                }
//            }
            //方式二：
            try {
                if(fw != null)
                    fw.close();
            } catch (IOException e) {
                e.printStackTrace();
            }

            try {
                if(fr != null)
                    fr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

3.3.2 使用FileInputStream不能读取文本文件的测试

  • 使用字节流FileInputStream处理文本文件，可能出现乱码。

    package pers.chh3213.IOstream;

import org.junit.Test;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

/**
 * 测试FileInputStream和FileOutputStream的使用
 *
 * 结论：
 *    1. 对于文本文件(.txt,.java,.c,.cpp)，使用字符流处理
 *    2. 对于非文本文件(.jpg,.mp3,.mp4,.avi,.doc,.ppt,...)，使用字节流处理
 */
public class FileInputTest {
    //使用字节流FileInputStream处理文本文件，可能出现乱码。
    @Test
    public void testFileInputStream(){
        FileInputStream fis = null;
        try {
            //1.造文件
            File file = new File("hello.txt");

            //2.造流
            fis = new FileInputStream(file);

            //3.读数据
            byte[] buffer = new byte[5];
            int len;//记录每次读取的字节的个数
            while((len = fis.read(buffer)) != -1){
                String str = new String(buffer,0,len);
                System.out.print(str);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if(fis != null) {
                //4.关闭资源
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

3.3.3 使用FileInputStream和FileOutputStream读写非文本文件

package pers.chh3213.IOstream;

import org.junit.Test;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileInputOutputTest {
    /**
     * 实现对图片的复制操作
     */
    @Test
    public void testFileInputOutputStream()  {
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            //1.造文件
            File srcFile = new File("pic1.jpg");
            File destFile = new File("pic2.jpg");

            //2.造流
            fis = new FileInputStream(srcFile);
            fos = new FileOutputStream(destFile);

            //3.复制的过程
            byte[] buffer = new byte[5];
            int len;
            //4.读数据
            while((len = fis.read(buffer)) != -1){
                fos.write(buffer,0,len);
            }
            System.out.println("复制成功");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(fos != null){
                //5.关闭资源
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(fis != null){
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }

            }
        }

    }
}

3.3.4 使用FileInputStream和FileOutputStream复制文件的方法测试

import org.junit.Test;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileIOPutTest {

    //指定路径下文件的复制
    public void copyFile(String srcPath,String destPath){
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            //
            File srcFile = new File(srcPath);
            File destFile = new File(destPath);

            //
            fis = new FileInputStream(srcFile);
            fos = new FileOutputStream(destFile);

            //复制的过程
            byte[] buffer = new byte[1024];
            int len;
            while((len = fis.read(buffer)) != -1){
                fos.write(buffer,0,len);
            }

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(fos != null){
                //
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(fis != null){
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }

            }
        }
    }

    @Test
    public void testCopyFile(){

        long start = System.currentTimeMillis();

//        String srcPath = "C:\\Users\\29433\\Desktop\\164.jpg";
//        String destPath = "C:\\Users\\29433\\Desktop\\164.jpg";

        String srcPath = "hello.txt";
        String destPath = "hello3.txt";

        copyFile(srcPath,destPath);

        long end = System.currentTimeMillis();

        System.out.println("复制操作花费的时间为：" + (end - start));//1
    }
}

3.4 注意事项

  • 定义文件路径时，注意：可以用/或者\\。
  • 写入文件时，对应的File可以不存在的。并不会报异常
    • File对应的硬盘中的文件如果不存在，在输出的过程中，会自动创建此文件。
  • 在读取文件时，必须保证该文件已存在，否则报异常。
  • 在写入一个文件时，如果使用构造器FileOutputStream(file)或者FileWriter(file,false)，则目录下有同名文件将被覆盖。
  • 如果使用构造器FileOutputStream(file,true)，则目录下的同名文件不会被覆盖，在文件内容末尾追加内容。
  • 字节流（InputStream, OutputStream）操作字节，比如：.mp3， .avi， .rmvb， mp4， .jpg， .doc， .ppt
  • 字符流(Reader, Writer)操作字符，只能操作普通文本文件。 最常见的文本文件：.txt， .java， .c， .cpp等语言的源代码。尤其注意.doc,excel,ppt这些不是文本文件。

4. 缓冲流

  • 为了提高数据读写的速度，Java API提供了带缓冲功能的流类，在使用这些流类时，会创建一个内部缓冲区数组，缺省使用8192个字节(8Kb)的缓冲区。
    在这里插入图片描述

  • 缓冲流要“套接”在相应的节点流之上，根据数据操作单位可以把缓冲流分为：

    BufferedInputStream和BufferedOutputStream
    BufferedReader和BufferedWriter

  • 当读取数据时，数据按块读入缓冲区，其后的读操作则直接访问缓冲区

  • 当使用BufferedInputStream读取字节文件时，BufferedInputStream会一次性从文件中读取8192个(8Kb)，存在缓冲区中，直到缓冲区装满了，才重新从文件中读取下一个8192个字节数组。

  • 向流中写入字节时，不会直接写到文件，先写到缓冲区中直到缓冲区写满，BufferedOutputStream才会把缓冲区中的数据一次性写到文件里。使用方法flush()可以强制将缓冲区的内容全部写入输出流

  • 关闭流的顺序和打开流的顺序相反。只要关闭最外层流即可，关闭最外层流也会相应关闭内层节点流

  • flush()方法的使用：手动将buffer中内容写入文件

  • 如果是带缓冲区的流对象的close()方法，不但会关闭流，还会在关闭流之前刷新缓冲区，关闭后不能再写出。
    在这里插入图片描述

4.1 缓冲流(字节型)实现非文本文件的复制

  • 示例

    package pers.chh3213.bufferStream;

/**
 * Created with IntelliJ IDEA.
 *
 * @author : chh3213
 * @version : 1.0
 * @Project : File
 * @Package : pers.chh3213.bufferStream
 * @ClassName : BufferedStreamTest.java
 * @createTime : 2022/1/18 10:43
 * @Email :
 * @Description :
 */
import org.junit.Test;

import java.io.*;

/**
 * 处理流之一：缓冲流的使用
 *
 *  1.缓冲流：
 *  BufferedInputStream
 *  BufferedOutputStream
 *  BufferedReader
 *  BufferedWriter
 */
public class BufferedStreamTest {
    /**
     * 实现非文本文件的复制
     */
    @Test
    public void bufferedStreamTest(){
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;
        try {
            //1.造文件
            File srcFile = new File("1.jpg");
            File destFile = new File("2.jpg");
            //2.造流
            //2.1 造节点流
            FileInputStream fis = new FileInputStream((srcFile));
            FileOutputStream fos = new FileOutputStream(destFile);
            //2.2 造缓冲流
            bis = new BufferedInputStream(fis);
            bos = new BufferedOutputStream(fos);

            //3.复制的细节：读取、写入
            byte[] buffer = new byte[10];
            int len;
            while((len = bis.read(buffer)) != -1){
                bos.write(buffer,0,len);
//                bos.flush();//刷新缓冲区
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4.资源关闭
            //要求：先关闭外层的流，再关闭内层的流
            if(bos != null){
                try {
                    bos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }

            }
            if(bis != null){
                try {
                    bis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            //说明：关闭外层流的同时，内层流也会自动的进行关闭。关于内层流的关闭，我们可以省略.
//        fos.close();
//        fis.close();
        }
    }
}



        @Test
    public void test02(){
        BufferedReader br = null;
        BufferedWriter bw = null;
        try {
// 创建缓冲流对象：它是处理流，是对节点流的包装
            br = new BufferedReader(new FileReader("hello1.txt"));
            bw = new BufferedWriter(new FileWriter("hello2.txt"));
            String str;
            while ((str = br.readLine()) != null) { // 一次读取字符文本文件的一行字符
                bw.write(str); // 一次写入一行字符串
                bw.newLine(); // 写入行分隔符
            }
            bw.flush(); // 刷新缓冲区
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
// 关闭IO流对象
            try {
                if (bw != null) {
                    bw.close(); // 关闭过滤流时,会自动关闭它所包装的底层节点流
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (br != null) {
                    br.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

4.2 缓冲流与节点流读写速度对比

package pers.chh3213.bufferStream;
import org.junit.Test;
import java.io.*;


/**
 * 处理流之一：缓冲流的使用
 *
 *  1.缓冲流：
 *  BufferedInputStream
 *  BufferedOutputStream
 *  BufferedReader
 *  BufferedWriter
 *
 *  2.作用：提供流的读取、写入的速度
 *    提高读写速度的原因：内部提供了一个缓冲区
 *
 *  3. 处理流，就是“套接”在已有的流的基础上。
 *
 */
public class BufferSpeedTest {

    //实现文件复制的方法
    public void copyFileWithBuffered(String srcPath,String destPath){
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;

        try {
            //1.造文件
            File srcFile = new File(srcPath);
            File destFile = new File(destPath);
            //2.造流
            //2.1 造节点流
            FileInputStream fis = new FileInputStream((srcFile));
            FileOutputStream fos = new FileOutputStream(destFile);
            //2.2 造缓冲流
            bis = new BufferedInputStream(fis);
            bos = new BufferedOutputStream(fos);

            //3.复制的细节：读取、写入
            byte[] buffer = new byte[1024];
            int len;
            while((len = bis.read(buffer)) != -1){
                bos.write(buffer,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4.资源关闭
            //要求：先关闭外层的流，再关闭内层的流
            if(bos != null){
                try {
                    bos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }

            }
            if(bis != null){
                try {
                    bis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }

            }
            //说明：关闭外层流的同时，内层流也会自动的进行关闭。关于内层流的关闭，我们可以省略.
//        fos.close();
//        fis.close();
        }
    }

    @Test
    public void testCopyFileWithBuffered(){
        long start = System.currentTimeMillis();

        String srcPath = "1.jpg";
        String destPath = "3.jpg";


        copyFileWithBuffered(srcPath,destPath);


        long end = System.currentTimeMillis();

        System.out.println("复制操作花费的时间为：" + (end - start));//1
    }

}

4.3 缓冲流(字符型)实现文本文件的复制

import org.junit.Test;
import java.io.*;

public class BufferedTest {
  /**
     * 使用BufferedReader和BufferedWriter实现文本文件的复制
     */
    @Test
    public void test4(){
        BufferedReader br = null;
        BufferedWriter bw = null;
        try {
            //创建文件和相应的流
            br = new BufferedReader(new FileReader(new File("dbcp.txt")));
            bw = new BufferedWriter(new FileWriter(new File("dbcp1.txt")));

            //读写操作
            //方式一：使用char[]数组
//            char[] cbuf = new char[1024];
//            int len;
//            while((len = br.read(cbuf)) != -1){
//                bw.write(cbuf,0,len);
//    //            bw.flush();
//            }

            //方式二：使用String
            String data;
            while((data = br.readLine()) != null){
                //方法一：
//                bw.write(data + "\n");//data中不包含换行符
                //方法二：
                bw.write(data);//data中不包含换行符
                bw.newLine();//提供换行的操作
            }

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //关闭资源
            if(bw != null){

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

4.4 练习

  1. 分别使用节点流： FileInputStream、 FileOutputStream和缓冲流：BufferedInputStream、 BufferedOutputStream实现文本文件/图片/视频文件的复制。并比较二者在数据复制方面的效率
package pers.chh3213.bufferStream;

import org.junit.Test;

import java.io.*;

/**
 * Created with IntelliJ IDEA.
 *
 * @author : chh3213
 * @version : 1.0
 * @Project : File
 * @Package : pers.chh3213.bufferStream
 * @ClassName : ExerciseTest.java
 * @createTime : 2022/1/19 9:28
 * @Email :
 * @Description :
 *
 * 1. 分别使用节点流： FileInputStream、 FileOutputStream和
 * 缓冲流：BufferedInputStream、 BufferedOutputStream实现
 * 文本文件/图片/视频文件的复制。并比较二者在数据复制方面的效率
 * 代码对文本进行复制，其他类似
 */
public class ExerciseTest {
    /**
     * 分别使用节点流： FileInputStream、 FileOutputStream
     */
    @Test
    public void test01(){
        FileInputStream file1_input = null;
        FileOutputStream file1_output = null;
        try {
            File file1 = new File("hello1.txt");
            File file1_copy = new File("hello1_cp.txt");
            file1_input = new FileInputStream(file1);
            file1_output = new FileOutputStream(file1_copy);
            //3.复制的过程
            byte[] buffer = new byte[5];
            int len;
            //4.读数据
            while((len = file1_input.read(buffer)) != -1){
//                System.out.println(len);
                file1_output.write(buffer,0,len);
            }
            System.out.println("复制成功");
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            if(file1_input!=null ){
                try {
                    file1_input.close();
                }catch (IOException e){
                    e.printStackTrace();
                }
            }
            if(file1_output!=null ) {
                try {
                    file1_output.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

        }

    }

    /**
     *  缓冲流：BufferedInputStream、 BufferedOutputStream实现
     */
    @Test
    public void test02(){
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;
        try{
            File file1 = new File("hello1.txt");
            File file1_copy = new File("hello1_cpp.txt");
            FileInputStream file1_input = new FileInputStream(file1);
            FileOutputStream file1_output = new FileOutputStream(file1_copy);
            bis = new BufferedInputStream(file1_input);
            bos = new BufferedOutputStream(file1_output);
            byte[] bt = new byte[5];
            int len;
            while((len=bis.read(bt))!=-1){
//                System.out.println(len);
                bos.write(bt,0,len);
            }
            System.out.println("复制成功");

        }catch (IOException e){
            e.printStackTrace();
        }finally {
            if(bis!=null){
                try{
                    bis.close();
                }catch (IOException e){
                    e.printStackTrace();
                }
            }
            if(bos!=null){
                try{
                    bos.close();
                }catch (IOException e){
                    e.printStackTrace();
                }
            }
        }
    }

}
  1. 实现图片加密解密操作。
    在这里插入图片描述
package pers.chh3213.bufferStream;

import org.junit.Test;

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

/**
 * Created with IntelliJ IDEA.
 *
 * @author : chh3213
 * @version : 1.0
 * @Project : File
 * @Package : pers.chh3213.bufferStream
 * @ClassName : ExerciseTest2.java
 * @createTime : 2022/1/19 10:56
 * @Email :
 * @Description : 实现图片加密解密操作。
 */
public class ExerciseTest2 {
    /**
     * 实现图片加密操作。
     */
    @Test
    public void test01(){
        FileInputStream fi = null;
        FileOutputStream fo = null;
        try{
            File file = new File("time.png");
            File file_secret = new File("time_jiami.png");
            fi = new FileInputStream(file);
            fo = new FileOutputStream(file_secret);
            int len;
            //法一
//            while((len=fi.read())!=-1){
//                fo.write(len^5);
//            }
					//法二
            byte[] buffer = new byte[20];
            while ((len = fi.read(buffer)) != -1) {
                //字节数组进行修改
                //错误的
                //            for(byte b : buffer){
                //                b = (byte) (b ^ 5);
                //            }

                //正确的
                for (int i = 0; i < len; i++) {
                    buffer[i] = (byte) (buffer[i] ^ 5);
                }

                fo.write(buffer, 0, len);
            }

        }catch (IOException e){
            e.printStackTrace();
        }finally {
            if(fi!=null){
                try{
                    fi.close();
                }catch (IOException e){
                    e.printStackTrace();
                }
            }
            if(fo!=null){
                try{
                    fo.close();
                }catch (IOException e){
                    e.printStackTrace();
                }
            }
        }
    }
    /**
     * 实现图片解密操作
     */
    @Test
    public void test02(){
        FileInputStream fi = null;
        FileOutputStream fo = null;
        try{
            File f_secret = new File("time_jiami.png");
            File f_ = new File("time_jiemi.png");
            fo = new FileOutputStream(f_);
            fi = new FileInputStream(f_secret);
            int len;
            //法一
//            while((len=fi.read())!=-1){
//                fo.write(len^(5));
//            }
					//法二
            byte[] buffer = new byte[20];
            while ((len = fi.read(buffer)) != -1) {
                //字节数组进行修改
                //错误的
                //            for(byte b : buffer){
                //                b = (byte) (b ^ 5);
                //            }

                //正确的
                for (int i = 0; i < len; i++) {
                    buffer[i] = (byte) (buffer[i] ^ 5);
                }

                fo.write(buffer, 0, len);
            }
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            if(fi!=null){
                try {
                    fi.close();
                }catch (IOException e){
                    e.printStackTrace();
                }
            }
            if(fo!=null){
                try {
                    fo.close();
                }catch (IOException e){
                    e.printStackTrace();
                }
            }
        }
    }
}
  1. 获取文本上每个字符出现的次数
    提示：遍历文本的每一个字符；字符及出现的次数保存在Map中；将Map中数据写入文件
package pers.chh3213.bufferStream;

import org.junit.Test;

import java.io.*;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

/**
 * Created with IntelliJ IDEA.
 *
 * @author : chh3213
 * @version : 1.0
 * @Project : File
 * @Package : pers.chh3213.bufferStream
 * @ClassName : ExerciseTest3.java
 * @createTime : 2022/1/20 10:44
 * @Email :
 * @Description :
 * 获取文本上每个字符出现的次数
 * 提示：遍历文本的每一个字符；字符及出现的次数保存在Map中；
 * 将Map中数据写入文件
 */
public class ExerciseTest3 {
    @Test
    public void test(){
        FileReader fi = null;
        BufferedWriter fo = null;
        try{
            Map<Character, Integer> map = new HashMap<>();
            File file1 = new File("hello1.txt");
            File file2 = new File("count_hello1.txt");
            fi = new FileReader(file1);
            fo =new BufferedWriter(new FileWriter(file2, false)) ;
            int len;
            char[] chars = new char[1];
            // 将字符数据统计写入map
            while((len=fi.read(chars))!=-1){
                if(map.containsKey(chars[0])){
                    map.put(chars[0],map.get(chars[0])+1);
                }else{
                    map.put(chars[0],1);
                }
            }
            //将map数据保存在txt中
            //遍历map,再写入数据
            Set<Map.Entry<Character, Integer>> entrySet = map.entrySet();
            for (Map.Entry<Character, Integer> entry : entrySet) {
                switch (entry.getKey()) {
                    case ' ':
                        fo.write("空格=" + entry.getValue());
                        break;
                    case '\t'://\t表示tab 键字符
                        fo.write("tab键=" + entry.getValue());
                        break;
                    case '\r'://
                        fo.write("回车=" + entry.getValue());
                        break;
                    case '\n'://
                        fo.write("换行=" + entry.getValue());
                        break;
                    default:
                        fo.write(entry.getKey() + "=" + entry.getValue());
                        break;
                }
                fo.newLine();
            }

        }catch (IOException e){
            e.printStackTrace();
        }finally {
            if(fi!=null){
                try{
                    fi.close();
                }catch (IOException e){
                    e.printStackTrace();
                }
            }
            if(fo!=null){
                try{

                    fo.close();
                }catch (IOException e){
                    e.printStackTrace();
                }
            }
        }
    }
}

5. 转换流

5.1 概述

  • 转换流提供了在字节流和字符流之间的转换。Java API提供了两个转换流：

    1. InputStreamReader：将InputStream转换为Reader
      • 实现将字节的输入流按指定字符集转换为字符的输入流。
      • 需要和InputStream“套接”。
      • 构造器
        public InputStreamReader(InputStreamin)
        public InputSreamReader(InputStreamin,StringcharsetName)
        如：Reader isr= new InputStreamReader(System.in,”gbk”);
    2. OutputStreamWriter：将Writer转换为OutputStream
      • 实现将字符的输出流按指定字符集转换为字节的输出流。
      • 需要和OutputStream“套接”。
      • 构造器
        public OutputStreamWriter(OutputStreamout)
        public OutputSreamWriter(OutputStreamout,StringcharsetName)

  • 字节流中的数据都是字符时，转成字符流操作更高效。

  • 很多时候我们使用转换流来处理文件乱码问题。实现编码和解码的功能。
    在这里插入图片描述

  • 解码：字节、字节数组 —>字符数组、字符串
  • 编码：字符数组、字符串 —> 字节、字节数组
package pers.chh3213.transformStream;

import org.junit.Test;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;

public class InputStreamReaderTest {

    /**
     * 此时处理异常的话，仍然应该使用try-catch-finally
     * InputStreamReader的使用，实现字节的输入流到字符的输入流的转换
     */
    @Test
    public void test() throws IOException {

        FileInputStream fis = new FileInputStream("hello2.txt");
//        InputStreamReader isr = new InputStreamReader(fis);//使用系统默认的字符集
        //参数2指明了字符集，具体使用哪个字符集，取决于文件保存时使用的字符集
        InputStreamReader isr = new InputStreamReader(fis,"UTF-8");//使用系统默认的字符集

        char[] cbuf = new char[20];
        int len;
        while((len = isr.read(cbuf)) != -1){
            String str = new String(cbuf,0,len);
            System.out.print(str);
        }

        isr.close();
    }

}

5.2 转换流的使用

  • 可以将字符按指定编码格式存储
  • 可以对文本数据按指定编码格式来解读
  • 指定编码表的动作由构造器完成
    package pers.chh3213.transformStream;

import org.junit.Test;

import java.io.*;
public class InputStreamReaderTest {
    @Test
    public void testMyInput() throws Exception {
        FileInputStream fis = new FileInputStream("hello2.txt");
        FileOutputStream fos = new FileOutputStream("dbcp5.txt");
        InputStreamReader isr = new InputStreamReader(fis, "GBK");
        OutputStreamWriter osw = new OutputStreamWriter(fos, "GBK");
        BufferedReader br = new BufferedReader(isr);
        BufferedWriter bw = new BufferedWriter(osw);
        String str = null;
        while ((str = br.readLine()) != null) {
            bw.write(str);
            bw.newLine();
            bw.flush();
        }
        bw.close();
        br.close();
    }
}

5.3 字符编码

  • 编码表的由来
    计算机只能识别二进制数据，早期由来是电信号。为了方便应用计算机，让它可以识别各个国家的文字。就将各个国家的文字用数字来表示，并一一对应，形成一张表。这就是编码表。
  • 常见的编码表
    • ASCII：美国标准信息交换码。
      • 用一个字节的7位可以表示。
    • ISO8859-1：拉丁码表。欧洲码表
      • 用一个字节的8位表示。
    • GB2312：中国的中文编码表。最多两个字节编码所有字符
    • GBK：中国的中文编码表升级，融合了更多的中文文字符号。最多两个字节编码
    • Unicode：国际标准码，融合了目前人类使用的所有字符。为每个字符分配唯一的字符码。所有的文字都用两个字节来表示。
    • UTF-8：变长的编码方式，可用1-4个字节来表示一个字符。
  • 在Unicode出现之前，所有的字符集都是和具体编码方案绑定在一起的（即字符集≈编码方式） ，都是直接将字符和最终字节流绑定死了。
  • GBK等双字节编码方式， 用最高位是1或0表示两个字节和一个字节。
  • Unicode不完美，这里就有三个问题，
    一个是，我们已经知道，英文字母只用一个字节表示就够了，第二个问题是如何才能区别Unicode和ASCII？计算机怎么知道两个字节表示一个符号，而不是分别表示两个符号呢？第三个，如果和GBK等双字节编码方式一样，用最高位是1或0表示两个字节和一个字节，就少了很多值无法用于表示字符，不够表示所有字符。Unicode在很长一段时间内无法推广，直到互联网的出现。
  • 面向传输的众多UTF（UCS Transfer Format）标准出现了，顾名思义，UTF-8就是每次8个位传输数据，而UTF-16就是每次16个位。这是为传输而设计的编码，并使编码无国界，这样就可以显示全世界上所有文化的字符了。
  • Unicode只是定义了一个庞大的、全球通用的字符集，并为每个字符规定了唯一确定的编号，具体存储成什么样的字节流，取决于字符编码方案。推荐的Unicode编码是UTF-8和UTF-16。
    在这里插入图片描述在这里插入图片描述

6. 标准输入、 输出流

  • System.in和System.out分别代表了系统标准的输入和输出设备

  • 默认输入设备是：键盘，输出设备是：显示器
    System.in的类型是InputStream
    System.out的类型是PrintStream，是OutputStream的子类FilterOutputStream的子类

  • 重定向：通过System类的setIn，setOut方法对默认设备进行改变。

    public static void setIn(InputStreamin)
    public static void setOut(PrintStreamout)

  • 示例

    package com.atguigu.java;
// MyInput.java: Contain the methods for reading int, double, float, boolean, short, byte and
// string values from the keyboard

import java.io.*;

public class MyInput {
    // Read a string from the keyboard
    public static String readString() {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        // Declare and initialize the string
        String string = "";

        // Get the string from the keyboard
        try {
            string = br.readLine();

        } catch (IOException ex) {
            System.out.println(ex);
        }

        // Return the string obtained from the keyboard
        return string;
    }

    // Read an int value from the keyboard
    public static int readInt() {
        return Integer.parseInt(readString());
    }

    // Read a double value from the keyboard
    public static double readDouble() {
        return Double.parseDouble(readString());
    }

    // Read a byte value from the keyboard
    public static double readByte() {
        return Byte.parseByte(readString());
    }

    // Read a short value from the keyboard
    public static double readShort() {
        return Short.parseShort(readString());
    }

    // Read a long value from the keyboard
    public static double readLong() {
        return Long.parseLong(readString());
    }

    // Read a float value from the keyboard
    public static double readFloat() {
        return Float.parseFloat(readString());
    }
}

  • 例题

从键盘输入字符串，要求将读取到的整行字符串转成大写输出。然后继续进行输入操作，直至当输入“e”或者“exit”时，退出程序。

package pers.chh3213.standardInputOutputStream;

import org.junit.Test;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class standardTest {
    /**
     *  方法一：使用Scanner实现，调用next()返回一个字符串
     *  方法二：使用System.in实现。System.in  --->  转换流 ---> BufferedReader的readLine()
     */
    public static void main(String[] args) {
        System.out.println("请输入信息(退出输入e或exit):");
        // 把"标准"输入流(键盘输入)这个字节流包装成字符流,再包装成缓冲流
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String s = null;
        try {
            while ((s = br.readLine()) != null) { // 读取用户输入的一行数据 --> 阻塞程序
                if ("e".equalsIgnoreCase(s) || "exit".equalsIgnoreCase(s)) {
                    System.out.println("安全退出!!");
                    break;
                }
                // 将读取到的整行字符串转成大写输出
                System.out.println("-->:" + s.toUpperCase());
                System.out.println("继续输入信息");
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (br != null) {
                    br.close(); // 关闭过滤流时,会自动关闭它包装的底层节点流
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

7. 打印流

  • 实现将基本数据类型的数据格式转化为字符串输出

  • 打印流：PrintStream和PrintWriter

    • 提供了一系列重载的print()和println()方法，用于多种数据类型的输出
    • PrintStream和PrintWriter的输出不会抛出IOException异常
    • PrintStream和PrintWriter有自动flush功能
    • PrintStream 打印的所有字符都使用平台的默认字符编码转换为字节。在需要写入字符而不是写入字节的情况下，应该使用PrintWriter 类。
    • System.out返回的是PrintStream的实例
    package pers.chh3213.printStream;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.PrintStream;
import java.io.File;

public class printStreamTest {
    public static void main(String[] args) {
        PrintStream ps = null;
        try {
            FileOutputStream fos = new FileOutputStream(new File("hello1.txt"));
            // 创建打印输出流,设置为自动刷新模式(写入换行符或字节 '\n' 时都会刷新输出缓冲区)
            ps = new PrintStream(fos, true);
            if (ps != null) {// 把标准输出流(控制台输出)改成文件
                System.setOut(ps);
            }
            for (int i = 0; i <= 255; i++) { // 输出ASCII字符
                System.out.print((char) i);
                if (i % 50 == 0) { // 每50个数据一行
                    System.out.println(); // 换行
                }
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } finally {
            if (ps != null) {
                ps.close();
            }
        }
    }
}

8. 数据流

  • 为了方便地操作Java语言的基本数据类型和String的数据，可以使用数据流。

  • 数据流有两个类：(用于读取和写出基本数据类型、String类的数据）
    DataInputStream和DataOutputStream
    分别“套接”在InputStream和OutputStream子类的流上

  • DataInputStream中的方法

    boolean readBoolean()	
byte readByte()
char readChar()	
float readFloat()
double readDouble()	
short readShort()
long readLong()	
int readInt()
String readUTF()	
void readFully(byte[s] b)

  • DataOutputStream中的方法

    将上述的方法的read改为相应的write即可。

练习：将内存中的字符串、基本数据类型的变量写出到文件中。

import org.junit.Test;
import java.io.*;

public class OtherStreamTest {    
   /**
     *   注意：处理异常的话，仍然应该使用try-catch-finally.
     */
    @Test
    public void test3() throws IOException {
        //1.
        DataOutputStream dos = new DataOutputStream(new FileOutputStream("data.txt"));
        //2.
        dos.writeUTF("我爱北京天安门");
        dos.flush();//刷新操作，将内存中的数据写入文件
        dos.writeInt(23);
        dos.flush();
        dos.writeBoolean(true);
        dos.flush();
        dos.writeLong(1234567890L); // 写入长整数
        dos.flush();
        //3.
        dos.close();
    }

    /**
     * 将文件中存储的基本数据类型变量和字符串读取到内存中，保存在变量中。
     *
     * 注意点：读取不同类型的数据的顺序要与当初写入文件时，保存的数据的顺序一致！
     */
    @Test
    public void test4() throws IOException {
        //1.
        DataInputStream dis = new DataInputStream(new FileInputStream("data.txt"));
        //2.
        String name = dis.readUTF();
        int age = dis.readInt();
        boolean isMale = dis.readBoolean();

        System.out.println("name = " + name);
        System.out.println("age = " + age);
        System.out.println("isMale = " + isMale);

        //3.
        dis.close();

    }
}

9. 对象流

  • ObjectInputStream和OjbectOutputSteam
  • 用于存储和读取基本数据类型数据或对象的处理流。它的强大之处就是可以把Java中的对象写入到数据源中，也能把对象从数据源中还原回来。
  • 序列化：用`ObjectOutputStream类保存基本类型数据或对象的机制
  • 反序列化：用ObjectInputStream`类读取基本类型数据或对象的机制
  • ObjectOutputStream和ObjectInputStream不能序列化static和transient修饰的成员变量

9.1 对象的序列化

  • 对象序列化机制允许把内存中的Java对象转换成平台无关的二进制流，从而允许把这种二进制流持久地保存在磁盘上，或通过网络将这种二进制流传输到另一个网络节点。//当其它程序获取了这种二进制流，就可以恢复成原来的Java对象(简单来说，序列化过程：将内存中的java对象保存到磁盘中或通过网络传输出去)

  • 序列化的好处在于可将任何实现了Serializable接口的对象转化为字节数据，使其在保存和传输时可被还原

  • 序列化是RMI（Remote Method Invoke –远程方法调用）过程的参数和返回值都必须实现的机制，而RMI 是JavaEE的基础。因此序列化机制是JavaEE平台的基础

  • 如果需要让某个对象支持序列化机制，则必须让对象所属的类及其属性是可序列化的，为了让某个类是可序列化的，该类必须实现如下两个接口之一。否则，会抛出NotSerializableException异常

    • Serializable
    • Externalizable

  • 凡是实现Serializable接口的类都有一个表示序列化版本标识符的静态变量：

    • private static final long serialVersionUID;
    • serialVersionUID用来表明类的不同版本间的兼容性。 简言之，其目的是以序列化对象进行版本控制，有关各版本反序列化时是否兼容。
    • 如果类没有显示定义这个静态常量，它的值是Java运行时环境根据类的内部细节自动生成的。 若类的实例变量做了修改， serialVersionUID可能发生变化。 故建议，显式声明。

  • 简单来说， Java的序列化机制是通过在运行时判断类的serialVersionUID来验证版本一致性的。在进行反序列化时， JVM会把传来的字节流中的serialVersionUID与本地相应实体类的serialVersionUID进行比较，如果相同就认为是一致的，可以进行反序列化，否则就会出现序列化版本不一致的异常。 (InvalidCastException)

9.2 使用对象流序列化对象

  • 若某个类实现了Serializable接口，该类的对象就是可序列化的：

    • 创建一个ObjectOutputStream
    • 调用ObjectOutputStream对象的writeObject(对象) 方法输出可序列化对象
    • 注意写出一次，操作flush()一次（flush()是把留在内存这个缓冲区的数据强行输出，即清空缓冲区数据）

  • 反序列化

    • 创建一个ObjectInputStream对象调用readObject()方法读取流中的对象—将磁盘文件中的对象还原为内存中的一个java对象

  • 强调：如果某个类的属性不是基本数据类型或String 类型，而是另一个引用类型，那么这个引用类型必须是可序列化的，否则拥有该类型的Field的类也不能序列化

  • 示例1—写入字符串

    package pers.chh3213.objectStream;

import org.junit.Test;

import java.io.*;

/**
 * Created with IntelliJ IDEA.
 *
 * @author : chh3213
 * @version : 1.0
 * @Project : File
 * @Package : pers.chh3213.objectStream
 * @ClassName : ObjectStreamTest.java
 * @createTime : 2022/1/20 17:00
 * @Email :
 * @Description :
 */
public class ObjectStreamTest {
    /**
     * //序列化：将对象写入到磁盘或者进行网络传输。
     * //要求对象必须实现序列化
     * @throws IOException
     */
    @Test
    public void test01() throws IOException {
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("data1.txt"));
        oos.writeObject(new String("i love you"));
        oos.flush();//刷新
        oos.close();
    }

    /**
     * //反序列化：将磁盘中的对象数据源读出。
     * @throws Exception
     */
    @Test
    public void test02() throws Exception{
        File file;
        ObjectInputStream ois = new ObjectInputStream(new BufferedInputStream(new FileInputStream("data1.txt")));
        String s = (String) ois.readObject();
        System.out.println(s.toString());
        ois.close();
    }
}

  • 示例2–自定义对象

    • Person类和Pet类
      package pers.chh3213.objectStream;

import java.io.Serializable;

/**
 * Created with IntelliJ IDEA.
 *
 * @author : chh3213
 * @version : 1.0
 * @Project : File
 * @Package : pers.chh3213.objectStream
 * @ClassName : Person.java
 * @createTime : 2022/1/20 17:09
 * @Email :
 * @Description :
 */
public class Person implements Serializable {
    private String name;
    private int age;
    private String address;
    private Pet pet;

    public Person(String name, int age, String address, Pet pet) {
        this.name = name;
        this.age = age;
        this.address = address;
        this.pet = pet;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", address='" + address + '\'' +
                ", pet=" + pet +
                '}';
    }
}
//如果某个类的属性不是**基本数据类型或String 类型**，而是另一个**引用类型**，
//那么这个引用类型**必须是可序列化**的，否则拥有该类型的`Field `的类也不能**序列化**

class Pet implements Serializable{
    private String name;
    public Pet(String name){
        this.name = name;
        System.out.println("养了一只"+ this.name);
    }
}
    • 测试类
      package pers.chh3213.objectStream;

import org.junit.Test;

import java.io.*;

/**
 * Created with IntelliJ IDEA.
 *
 * @author : chh3213
 * @version : 1.0
 * @Project : File
 * @Package : pers.chh3213.objectStream
 * @ClassName : ObjectStreamTest.java
 * @createTime : 2022/1/20 17:00
 * @Email :
 * @Description :
 */
public class ObjectStreamTest {
    /**
     * //序列化：将对象写入到磁盘或者进行网络传输。
     * //要求对象必须实现序列化
     * @throws IOException
     */
    @Test
    public void test01() throws IOException {
        ObjectOutputStream oos = null;
        try {
            oos = new ObjectOutputStream(new FileOutputStream("data1.txt"));
            Person p = new Person("韩梅梅", 18, "中华大地", new Pet("cat"));
            oos.writeObject(p);
            oos.flush();
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            if(oos!=null){
                try{
                    oos.close();

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

    /**
     * //反序列化：将磁盘中的对象数据源读出。
     * @throws Exception
     */
    @Test
    public void test02() throws Exception{
        File file;
        ObjectInputStream ois = new ObjectInputStream(new BufferedInputStream(new FileInputStream("data1.txt")));
        Person p = (Person) ois.readObject();
        System.out.println(p.toString());
        ois.close();
    }

}

9.3 对java.io.Serializable接口的理解

  • 实现了Serializable接口的对象，可将它们转换成一系列字节，并可在以后完全恢复回原来的样子。 这一过程亦可通过网络进行。这意味着序列化机制能自动补偿操作系统间的差异。 换句话说，可以先在Windows机器上创建一个对象，对其序列化，然后通过网络发给一台Unix机器，然后在那里
    准确无误地重新“装配”。不必关心数据在不同机器上如何表示，也不必关心字节的顺序或者其他任何细节。
  • 由于大部分作为参数的类如String、Integer等都实现了java.io.Serializable的接口，也可以利用多态的性质，作为参数使接口更灵活。

10. 随机存取文件流

  • RandomAccessFile 声明在java.io包下，但直接继承于java.lang.Object类。并且它实现了DataInput、DataOutput这两个接口，也就意味着这个类既可以读也可以写。

  • RandomAccessFile 类支持“随机访问” 的方式，程序可以直接跳到文件的任意地方来读、写文件

    • 支持只访问文件的部分内容
    • 可以向已存在的文件后追加内容

  • RandomAccessFile 对象包含一个记录指针，用以标示当前读写处的位置。RandomAccessFile类对象可以自由移动记录指针：

    • long getFilePointer()：获取文件记录指针的当前位置
    • void seek(long pos)：将文件记录指针定位到pos位置

  • 构造器

    public RandomAccessFile(Filefile, Stringmode)
    public RandomAccessFile(Stringname, Stringmode)

  • 创建RandomAccessFile类实例需要指定一个mode参数，该参数指定RandomAccessFile的访问模式：

    r: 以只读方式打开
    rw：打开以便读取和写入
    rwd:打开以便读取和写入；同步文件内容的更新
    rws:打开以便读取和写入；同步文件内容和元数据的更新

如果模式为只读r，则不会创建文件，而是会去读取一个已经存在的文件，如果读取的文件不存在则会出现异常。如果模式为rw读写。如果文件不存在则会去创建文件，如果存在则不会创建。

  • RandomAccessFile的使用
    • RandomAccessFile既可以作为一个输入流，又可以作为一个输出流
    • 如果RandomAccessFile作为输出流时，写出到的文件如果不存在，则在执行过程中自动创建。 如果写出到的文件存在，则会对原有文件内容进行覆盖。（默认情况下，从头覆盖）

10.1 读取写入文件内容

  • 读取文件内容

    	RandomAccessFile raf = new RandomAccessFile(“test.txt”, “rw”） ;
	raf.seek(5);
	byte [] b = new byte[1024];
	int off = 0;
	int len = 5;
	raf.read(b, off, len);
	String str = new String(b, 0, len);
	System.out.println(str);
	raf.close();

  • 在某个位置写入文件内容

    RandomAccessFile raf = new RandomAccessFile("test.txt", "rw");
raf.seek(5);
//先读出来
String temp = raf.readLine();
//定位到某个位置
raf.seek(5);
//写入
raf.write("xyz".getBytes());
//写入temp
raf.write(temp.getBytes());
raf.close();

  • 示例

    package pers.chh3213.randomAccess;

/**
 * Created with IntelliJ IDEA.
 *
 * @author : chh3213
 * @version : 1.0
 * @Project : File
 * @Package : pers.chh3213.randomAccess
 * @ClassName : RandomAccessFileTest.java
 * @createTime : 2022/1/21 10:23
 * @Email :
 * @Description :
 */
import org.junit.Test;

import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;

/**
 * RandomAccessFile的使用
 * 1.RandomAccessFile直接继承于java.lang.Object类，实现了DataInput和DataOutput接口
 * 2.RandomAccessFile既可以作为一个输入流，又可以作为一个输出流
 * 3.如果RandomAccessFile作为输出流时，写出到的文件如果不存在，则在执行过程中自动创建。
 *   如果写出到的文件存在，则会对原有文件内容进行覆盖。（默认情况下，从头开始覆盖）
 */
public class RandomAccessFileTest{

    @Test
    public void test(){

        RandomAccessFile raf1 = null;
        RandomAccessFile raf2 = null;
        try {
            raf1 = new RandomAccessFile(new File("1.jpg"),"r");
            raf2 = new RandomAccessFile(new File("爱情与友情1.jpg"),"rw");

            byte[] buffer = new byte[1024];
            int len;
            while((len = raf1.read(buffer)) != -1){
                raf2.write(buffer,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(raf1 != null){
                try {
                    raf1.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }

            }
            if(raf2 != null){
                try {
                    raf2.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
		//如果写出到的文件存在，则会对原有文件内容进行覆盖。（默认情况下，从头覆盖）
    @Test
    public void test2() throws IOException {

        RandomAccessFile raf1 = new RandomAccessFile("hello1.txt","rw");

        raf1.write("xyz".getBytes());

        raf1.close();

    }

}

10.2 RandomAccessFile实现数据的插入操作

package pers.chh3213.randomAccess;

import org.junit.Test;

import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;

/**
 * 4.可以通过相关的操作，实现RandomAccessFile“插入”数据的效果
 */
public class RandomTest {

    /**
     * 使用RandomAccessFile实现数据的插入效果
     */
    @Test
    public void test3() throws IOException {
        RandomAccessFile raf1 = new RandomAccessFile("hello2.txt","rw");

        raf1.seek(3);//将指针调到角标为3的位置
        //保存指针3后面的所有数据到StringBuilder中
        StringBuilder builder = new StringBuilder((int) new File("hello.txt").length());
        byte[] buffer = new byte[20];
        int len;
        while((len = raf1.read(buffer)) != -1){
            builder.append(new String(buffer,0,len)) ;
        }
        //调回指针，写入“xyz”
        raf1.seek(3);
        raf1.write("xyz".getBytes());

        //将StringBuilder中的数据写入到文件中
        raf1.write(builder.toString().getBytes());

        raf1.close();

        //思考：将StringBuilder替换为ByteArrayOutputStream
    }

}

  • 简单来说，插入操作就是

    RandomAccessFile raf = new RandomAccessFile("test.txt", "rw");
raf.seek(5);
//先读出来
String temp = raf.readLine();
//定位到某个位置
raf.seek(5);
//写入
raf.write("xyz".getBytes());
//写入temp
raf.write(temp.getBytes());
raf.close();

10.3 流的基本应用小结

  • 流是用来处理数据的。
  • 处理数据时，一定要先明确数据源，与数据目的地
    • 数据源可以是文件，可以是键盘。
    • 数据目的地可以是文件、显示器或者其他设备。
  • 而流只是在帮助数据进行传输,并对传输的数据进行处理，比如过滤处理、转换处理等。

11. NIO.2中Path、 Paths、Files类的使用

  • Java NIO (New IO，Non-Blocking IO)是从Java 1.4版本开始引入的一套新的IO API，可以替代标准的Java IO API。NIO与原来的IO有同样的作用和目的，但是使用的方式完全不同，NIO支持面向缓冲区的(IO是面向流的)、基于通道的IO操作。NIO将以更加高效的方式进行文件的读写操作。

  • Java API中提供了两套NIO，一套是针对标准输入输出NIO，另一套就是网络编程NIO。
    在这里插入图片描述

  • 随着JDK 7 的发布，Java对NIO进行了极大的扩展，增强了对文件处理和文件系统特性的支持，以至于我们称他们为NIO.2。因为NIO 提供的一些功能，NIO已经成为文件处理中越来越重要的部分。

  • 早期的Java只提供了一个File类来访问文件系统，但File类的功能比较有限，所提供的方法性能也不高。而且，大多数方法在出错时仅返回失败，并不会提供异常信息。

  • NIO. 2为了弥补这种不足，引入了Path接口，代表一个平台无关的平台路径，描述了目录结构中文件的位置。Path可以看成是File类的升级版本，实际引用的资源也可以不存在。

  • 在以前IO操作都是这样写的:

    import java.io.File;

File file = new File(“index.html”);

  • 但在Java7 中，我们可以这样写

    import java.nio.file.Path;
import java.nio.file.Paths;
Path path = Paths.get(“index.html”);

  • 同时，NIO.2在java.nio.file包下还提供了Files、Paths工具类，Files包含了大量静态的工具方法来操作文件；Paths则包含了两个返回Path的静态工厂方法。

  • Paths类提供的静态get()方法用来获取Path对象：

    static Pathget(String first, String … more) : 用于将多个字符串串连成路径
    static Path get(URI uri): 返回指定uri对应的Path路径

11.1 Path接口

在这里插入图片描述

11.2 Files 类

在这里插入图片描述
在这里插入图片描述

  • 示例

    package com.atguigu.java1;

import java.io.File;
import java.nio.file.Path;
import java.nio.file.Paths;

import org.junit.Test;

/**
 * 1. jdk 7.0 时，引入了 Path、Paths、Files三个类。
 * 2.此三个类声明在：java.nio.file包下。
 * 3.Path可以看做是java.io.File类的升级版本。也可以表示文件或文件目录，与平台无关
 * <p>
 * 4.如何实例化Path:使用Paths.
 * static Path get(String first, String … more) : 用于将多个字符串串连成路径
 * static Path get(URI uri): 返回指定uri对应的Path路径
 *
 * @author shkstart
 * @create 2019 下午 2:44
 */
public class PathTest {

    //如何使用Paths实例化Path
    @Test
    public void test1() {
        Path path1 = Paths.get("d:\\nio\\hello.txt");//new File(String filepath)

        Path path2 = Paths.get("d:\\", "nio\\hello.txt");//new File(String parent,String filename);

        System.out.println(path1);
        System.out.println(path2);

        Path path3 = Paths.get("d:\\", "nio");
        System.out.println(path3);
    }

    //Path中的常用方法
    @Test
    public void test2() {
        Path path1 = Paths.get("d:\\", "nio\\nio1\\nio2\\hello.txt");
        Path path2 = Paths.get("hello.txt");

//		String toString() ： 返回调用 Path 对象的字符串表示形式
        System.out.println(path1);

//		boolean startsWith(String path) : 判断是否以 path 路径开始
        System.out.println(path1.startsWith("d:\\nio"));
//		boolean endsWith(String path) : 判断是否以 path 路径结束
        System.out.println(path1.endsWith("hello.txt"));
//		boolean isAbsolute() : 判断是否是绝对路径
        System.out.println(path1.isAbsolute() + "~");
        System.out.println(path2.isAbsolute() + "~");
//		Path getParent() ：返回Path对象包含整个路径，不包含 Path 对象指定的文件路径
        System.out.println(path1.getParent());
        System.out.println(path2.getParent());
//		Path getRoot() ：返回调用 Path 对象的根路径
        System.out.println(path1.getRoot());
        System.out.println(path2.getRoot());
//		Path getFileName() : 返回与调用 Path 对象关联的文件名
        System.out.println(path1.getFileName() + "~");
        System.out.println(path2.getFileName() + "~");
//		int getNameCount() : 返回Path 根目录后面元素的数量
//		Path getName(int idx) : 返回指定索引位置 idx 的路径名称
        for (int i = 0; i < path1.getNameCount(); i++) {
            System.out.println(path1.getName(i) + "*****");
        }

//		Path toAbsolutePath() : 作为绝对路径返回调用 Path 对象
        System.out.println(path1.toAbsolutePath());
        System.out.println(path2.toAbsolutePath());
//		Path resolve(Path p) :合并两个路径，返回合并后的路径对应的Path对象
        Path path3 = Paths.get("d:\\", "nio");
        Path path4 = Paths.get("nioo\\hi.txt");
        path3 = path3.resolve(path4);
        System.out.println(path3);

//		File toFile(): 将Path转化为File类的对象
        File file = path1.toFile();//Path--->File的转换

        Path newPath = file.toPath();//File--->Path的转换

    }


}

课后练习

简答题

什么是java序列化，如何实现java序列化？

答：序列化就是一种用来处理对象流的机制，所谓对象流也就是将对象的内容进行流化。
可以对流化后的对象进行读写操作，也可将流化后的对象传输于网络之间。
序列化是为了解决在对对象流进行读写操作时所引发的问题。
序列化的实现：将需要被序列化的类实现Serializable接口，该接口没有需要实现的方法，
implements Serializable只是为了标注该对象是可被序列化的，然后使用一个输出流(如：FileOutputStream)来构造一个ObjectOutputStream(对象流)对象，接着，使用ObjectOutputStream对象的writeObject(Object obj)方法就可以将参数为obj的对象写出(即保存其状态)，要恢复的话则用输入流。

使用处理流的优势有哪些？如何识别所使用的流是处理流还是节点流？

【优势】对开发人员来说，使用处理流进行输入/输出操作更简单；使用处理流的执行效率更高。
【判别】处理流的构造器的参数不是一个物理节点，而是已经存在的流。而节点流都是直接以物理IO及节点作为构造器参数的。缓冲流、对象流等都是处理流。

Java中有几种类型的流？JDK为每种类型的流提供了一些抽象类以供继承，请指出它们分别是哪些类？

【答案】Java中按所操作的数据单元的不同，分为字节流和字符流。
字节流继承于·InputStream·和·OutputStream类;
字符流继承于Reader和Writer。
按流的流向的不同，分为输入流和输出流。
按流的角色来分，可分为节点流和处理流。缓冲流、转换流、对象流和打印流等都属于处理流，使得输入/输出更简单，执行效率更高。

什么是标准的I/O流？

在java语言中，用stdin表示键盘，用stdout表示监视器。他们均被封装在System类的类变量in 和out中，对应于系统调用System.in和System.out。这样的两个流加上System.err统称为标准流，它们是在System类中声明的3个类变量：
public static InputStream in
public static PrintStream out
public static PrintStream err

数组有没有length()方法？String有没有length()方法？File有没有length()方法？ArrayList有没有length()方法？

数组没有length()方法，但是有 length属性。
String和File有length()方法。
ArrayList没有length()方法，有size()方法获取有效元素个数。

BufferedReader流能直接指向一个文件对象吗？

不能直接流向文件对象，要在里面套一个FileReader

编程题

使用File类删除某个文件夹（例如D盘下的temp文件夹）下的所有文件和文件夹:
1） 判断temp文件夹下的文件类型，如果是文件则直接删除
2） 如果是文件夹则获取该文件夹下的子文件和文件夹
3） 使用递归的方式删除所有temp文件夹下的文件和文件夹

package pers.chh3213.exercise;

import org.junit.Test;

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

/**
 * Created with IntelliJ IDEA.
 *
 * @author : chh3213
 * @version : 1.0
 * @Project : File
 * @Package : pers.chh3213.exercise
 * @ClassName : DelFileTest.java
 * @createTime : 2022/1/21 13:40
 * @Email :
 * @Description :
 */
public class DelFileTest {
    @Test
    public void test01() throws IOException {
        deleteDirectory(new File("1.jpg"));

    }
    // 拓展2：删除指定的目录
    public  void deleteDirectory(File file) {
        // 如果file是文件，直接delete
        // 如果file是目录，先把它的下一级干掉，然后删除自己
        if (file.isDirectory()) {
            File[] all = file.listFiles();
            // 循环删除的是file的下一级
            for (File f : all) {// f代表file的每一个下级
                deleteDirectory(f);
            }
        }
        // 删除自己
        file.delete();
    }
}

利用IO流操作文件

  1. 利用java代码在D盘下创建一个mytemp文件夹
  2. 显示D盘下所有的.Java文件，包括D盘的子文件夹下的.java文件
  3. 把上述显示的文件都复制到mytemp文件夹中
package pers.chh3213.exercise;

import org.junit.Test;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

/**
 * Created with IntelliJ IDEA.
 *
 * @author : chh3213
 * @version : 1.0
 * @Project : File
 * @Package : pers.chh3213.exercise
 * @ClassName : CopyJavaFileTest.java
 * @createTime : 2022/1/21 13:54
 * @Email :
 * @Description :
 */
public class CopyJavaFileTest {
    @Test
    public void test(){
        File dir = new File("E:\\CHH3213_KING\\研究生\\导师\\就业规划\\Java_Learning\\eclpise_workspace\\File\\FileClass\\src\\pers\\chh3213\\exercise\\mytemp");
        //创建文件夹
        if(!dir.exists()){
            dir.mkdirs();
        }
        //显示所有。java文件
        File display_dir = new File("E:\\CHH3213_KING\\研究生\\导师\\就业规划\\Java_Learning\\eclpise_workspace\\File\\FileClass\\src\\pers\\chh3213\\file");
        Set name_set = displayJava(display_dir);
        //将显示的java文件全部复制到mytemp文件夹中
        Iterator iterator = name_set.iterator();
        while (iterator.hasNext()){
            String name = (String)iterator.next();
//            System.out.println(name);
            File f = new File(name);
            copyFile(f);
        }
    }
    public void copyFile(File file) {
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
             fis = new FileInputStream(file);
             File out_file = new File("E:\\CHH3213_KING\\研究生\\导师\\就业规划\\Java_Learning\\eclpise_workspace\\File\\FileClass\\src\\pers\\chh3213\\exercise\\mytemp\\" + file.getName());
             fos = new FileOutputStream(out_file);
            int len;
            while ((len = fis.read()) != -1) {
                fos.write(len);
            }
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            if(fis!=null){
                try {
                    fis.close();
                }catch (IOException e){
                    e.printStackTrace();
                }
            }
            if(fos!=null){
                try {
                    fos.close();
                }catch (IOException e){
                    e.printStackTrace();
                }
            }
        }
    }

    public Set displayJava(File dir){
        File[] files = dir.listFiles();
        Set<String> set = new HashSet<String>();
        for (File file:files
             ) {
            if (file.isDirectory()){
                displayJava(file);
            }
            else{
                String name = file.getName();
                if(name.endsWith(".java")){
                    //将显示的文件绝对路径名保存下来
                    String path = file.getAbsolutePath();
                    set.add(path);
                    System.out.println(name);
                }
            }
        }
        return set;
    }
}

使用RandomAccessFile流将一个文本文件倒置读出

package pers.chh3213.exercise;

import java.io.IOException;
import java.io.RandomAccessFile;
import java.io.File;

public class RandomAccessTest {
    public static void main(String args[]){
        File f=new File("hello1.txt");
        try{
            RandomAccessFile random=new RandomAccessFile(f,"rw");    //以随机读取方式打开文件
            random.seek(0);
            long m=random.length();               //m = 文件长度
            while (m >= 0){
                m--;                                      //每次循环m都减1,等于从后往前
                random.seek(m);                    //定位到文件中第m个字符
                int c=random.readByte();        //c被赋值为文件中第m个字符
                if(c<=255&&c>=0)  {
                    System.out.print((char)c);       //如果asc码<=255,>=0,则判断是个英文字符,直接打印.
                }
                else {                                   //如果不在asc码范围内,则判断是个汉字字符
                    m--;                                   //汉字字符是占2个字节的,所以m再退一个字节(m=m-1)

                    random.seek(m);
                    byte cc[]=new byte[2];
                    random.readFully(cc);               //cc被复制为文件中连续的两个字节
                    System.out.print(new String(cc)); //把cc转换为字符串,打印(这里会打印出汉字)
                }
            }
        }catch(IOException e){}
    }

}


使用输入流读取试题文件，每次显示试题文件中的一道题目。读取到字符“*”时暂停读取，等待用户从键盘输入答案。用户做完全部题目后。程序给出用户的得分。
1）	试题内容如下：
(1)北京奥运是什么时间开幕的？
   A.2008-08-08  B. 2008-08-01 
C.2008-10-01 D. 2008-07-08
********************
(2)下列哪个国家不属于亚洲？
   A.沙特  B.印度 C.巴西  D.越南
********************
(3)下列哪个国家最爱足球？
   A.刚果  B.越南 C.老挝  D.巴西
********************
(4)下列哪种动物属于猫科动物？
   A.鬣狗  B.犀牛 C.大象 D.狮子
********************

2）程序运行如下：
(1)北京奥运是什么时间开幕的？
   A.2008-08-08  B. 2008-08-01 
C.2008-10-01 D. 2008-07-08
输入选择的答案（A、B、C、D）：A
(2)下列哪个国家不属于亚洲？
   A.沙特  B.印度 C.巴西  D.越南
输入选择的答案（A、B、C、D）：

package pers.chh3213.exercise;

import org.junit.Test;

import java.io.*;
import java.util.Scanner;

/**
 * Created with IntelliJ IDEA.
 *
 * @author : chh3213
 * @version : 1.0
 * @Project : File
 * @Package : pers.chh3213.exercise
 * @ClassName : ExamTest.java
 * @createTime : 2022/1/21 15:28
 * @Email :
 * @Description :
 */
public class ExamTest {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        File file = new File("exam.txt");
        if(!file.exists()){
            try {
                file.createNewFile();
            }catch (IOException e){
                e.printStackTrace();
            }
        }
        //写入试题
        writeFile(file);
        //读取试题并作答
        readFile(file);
        
    }

    /**
     * 写入试题
     * @param file
     */
    public static void writeFile(File file){
        FileWriter fw = null;
        try {
            fw = new FileWriter(file);
            String s = "(1)北京奥运是什么时间开幕的？\n" +
                    "   A.2008-08-08  B. 2008-08-01 \n" +
                    "C.2008-10-01 D. 2008-07-08\n" +
                    "********************\n" +
                    "(2)下列哪个国家不属于亚洲？\n" +
                    "   A.沙特  B.印度 C.巴西  D.越南\n" +
                    "********************\n" +
                    "(3)下列哪个国家最爱足球？\n" +
                    "   A.刚果  B.越南 C.老挝  D.巴西\n" +
                    "********************\n" +
                    "(4)下列哪种动物属于猫科动物？\n" +
                    "   A.鬣狗  B.犀牛 C.大象 D.狮子\n" +
                    "********************\n";
            fw.write(s);
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            if(fw!=null){
                try{
                    fw.close();
                }catch (IOException e){
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * 读取试题
     * @param file
     */
    public static void readFile(File file){
        FileReader fr = null;
        BufferedReader br = null;
        Scanner scanner = new Scanner(System.in);
        StringBuffer result = new StringBuffer();//存储用户输入的答案
        String answer = "ABCD"; //假设四题的标准答案
        try{
            fr = new FileReader(file);
            br = new BufferedReader(fr);
            String s;
            while((s= br.readLine())!=null){
                if(!s.startsWith("*")){
                    System.out.println(s);
                }else{
                    System.out.println("输入选择的答案（A、B、C、D）：");
                    result.append(scanner.next().charAt(0));
                }
            }
            System.out.println(result);
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            if(br!=null){
                try{
                    br.close();
                }catch (IOException e){
                    e.printStackTrace();
                }
            }
            int score=0;
            for (int i = 0; i < result.length(); i++) {
                if(result.charAt(i)==answer.charAt(i)){
                    score+=25;
                }

            }
            System.out.println("得分："+score);
        }
    }
}
CHH3213
关注
  • 5
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
尚硅谷——宋红康老师超详细IO流的相关讲解
筱筱攻程师的博客
05-14 970
文章目录一、File 类的使用1.常用构造器2.路径分隔符3.常用方法二、IO流原理及流的分类1.Java IO原理2.流的分类3.InputStream & Reader输入流介绍与使用3.1使用字节流处理文本文件案例3.2read()测试：3.3read(char[] cbuf)测试4.OutputStream & Writer输出流介绍与使用4.1write()测试4.2读取文件内容并写入到另一个文件案例4.3图片赋值案例4.4视频复制案例三、节点流(或文件流)1.读取文件2. 写入文
尚硅谷java学习笔记——10.java IO流
无关风月
01-17 1035
java.io.File 类1、凡是与输入、输出相关的类、接口等都定义在java.io 包下 2、File是一个类，可以有构造器创建其对象。此对象对应着一个文件（.txt .avi .doc .ppt .mp3）或文件目录 3、File类对象是与平台无关的。 4、File中的方法，仅涉及到如何创建、删除、重命名等。对于内容，必须用IO流完成。 5、File类的对象常作为io流的具体类的构造器
第十三章 IO流（尚硅谷最新版Java零基础编程_2019版笔记）
quanquanya的博客
03-31 223
第十三章 IO流 JUnit单元测试步骤： 1.配置方法:参考1或参考2 ​ 使用@Test可能会报错，解决方法：选择Add “JUnit4” to classpath 2.创建Java类，进行单元测试 ​ Java类要求：此类是public的；此类提供公共的无参构造器 3.此类中声明单元测试方法 ​ 单元测试方法要求：方法的权限是public；没有返回值；没有形参 4.此单元测试方法上需要声...
尚硅谷Java入门视频教程第十三章——IO流
yw_1121的博客
06-16 243
尚硅谷Java入门视频教程第十三章——IO流
尚硅谷_初级_IO流（java_NIO(new IO)）
张老师的博客
10-31 261
一：File 类的使用 1.File 类的理解 （1）File 类的一个实例化对象，代表 一个文件 或者 一个文件目录（俗称：文件夹） （2）File 类声明在 java.io 包下 （3）File 类中涉及到，关于文件 或者 文件目录 的操作方法， 比如：创建，删除，重命名，修改时间文件大小 等方法。 并未涉及到 写入或者读取文件内容的操作，如果涉及到 文件中的内容，则需要使用 .
尚硅谷_Java基础实战_Bank项目_项目需求
04-11
【尚硅谷_Java基础实战_Bank项目_项目需求】是一个针对初学者的Java编程实践课程，旨在通过构建一个银行管理系统的项目，深入理解和掌握Java基础知识。这个项目涵盖了多个关键的编程概念和技术，对于想要在IT行业中...
尚硅谷_宋红康_第13章_IO流.pdf
07-05
本教程特点： 1.更适合零基础学员： ·自Java语言起源始，循序渐进...·Java语言基础阶段：12720行代码，Java语言高级阶段：11684行代码 ·课堂实战项目3套，课后实战项目2套 ·近百道企业面试真题精讲精练、极具实战性
尚硅谷_宋红康_20天Java核心_资料工具
03-17
6. **输入输出流**：Java的IO流用于读写文件、网络通信等。分为字节流和字符流，包括输入流（InputStream/Reader）和输出流（OutputStream/Writer），还有缓冲流、转换流和对象流等。 7. **线程与并发**：Java提供...
尚硅谷_宋红康_第13章节练习_IO流.doc
07-05
【Java流的类型】Java中的流分为两大类：字节流和字符流。字节流继承自`InputStream`和`OutputStream`，而字符流继承自`Reader`和`Writer`。根据流的方向，又有输入流和输出流之分。此外，根据角色不同，流还可以...
【尚硅谷】Java学习笔记13之IO流（1）
qq_34104173的博客
07-27 186
1.File类的使用 1.1 File类的理解 File类的一个对象，代表一个文件或一个文件目录(俗称：文件夹) File类声明在java.io包下 File类中涉及到关于文件或文件目录的创建、删除、重命名、修改时间、文件大小等方法，并未涉及到写入或读取文件内容的操作。如果需要读取或写入文件内容，必须使用IO流来完成。 后续File类的对象常会作为参数传递到流的构造器中，指明读取或写入的"终点"。 1.2 File的实例化 1.2.1 常用构造器 File(String filePath) File(S
【尚硅谷】Java学习笔记13之IO流（2）
qq_34104173的博客
07-28 165
4 缓冲流的使用 4.1 缓冲流涉及到的类 BufferedInputStream BufferedOutputStream BufferedReader BufferedWriter 4.2.作用： **作用：**提供流的读取、写入的速度 提高读写速度的原因：内部提供了一个缓冲区。默认情况下是8kb 4.3 典型代码 4.3.1 使用BufferedInputStream和BufferedOutputStream:处理非文本文件 //实现文件复制的方法 public void copyFil
Java尚硅谷基础笔记-day14 IO流
alyja的博客
07-22 722
第十三章 IO流File类的使用IO流原理及流的分类节点流缓冲流转换流标准输入、输出流打印流数据流对象流随机存取文件流NIO.2中Path、Paths，Files类的使用 File类的使用 IO流原理及流的分类 节点流 缓冲流 转换流 标准输入、输出流 打印流 数据流 对象流 随机存取文件流 NIO.2中Path、Paths，Files类的使用 ...
13_IO流
海涛帅帅的博客
09-14 235
List item File的使用 java.io.File类：文件和文件目录路径的抽象表示形式，与平台 无关 File 能新建、删除、重命名文件和目录，但 File 不能访问文件内容本身。 如果需要访问文件内容本身，则需要使用输入/输出流。 想要在Java程序中表示一个真实存在的文件或目录，那么必须有一个File对 象，但是Java程序中的一个File对象，可能没有一个真实存在的文件或目录。 File对象可以作为参数传递给流的构造器 常用构造器 public File(Str..
尚硅谷javaIO流
最新发布
m0_63961750的博客
05-09 92
所有的文字都用两个字节来表示。如果流使用的构造器是：FileWriter(file,false) / FileWriter(file):对原有文件的覆盖，默认为false。它的强大之处就是可以把Java中的对象写入到数据源中，也能把对象从数据源中还原回来。3.如果RandomAccessFile作为输出流时，写出到的文件如果不存在，则在执行过程中自动创建。3.要想一个java对象是可序列化的，需要满足相应的要求。2.File对应的硬盘中的文件如果不存在，在输出的过程中，会自动创建此文件。
Java学习_Day 17(学习内容：尚硅谷IO流JAVA零基础P587-P597)
好一个区块链
05-21 172
P587 IO流-FileReader读入数据的基本操作 package com.io; import org.junit.Test; import java.io.File; import java.io.FileNotFoundException; import java.io.FileReader; import java.io.IOException; /** * 流的体系架构 * 抽象基类 节点流 缓冲流 * InputS
Java学习(尚硅谷)IO流学习之流的体系结构(节点流+缓冲流)
m0_55895641的博客
05-01 219
package com.atguigu.java; import org.junit.Test; import java.io.File; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; /** * 一、流的分类 * 1.操作数据单位不同：字节流、字符流 * 2.数据的流向：输入流、输出流 * 3.流的角色：节点流、处理流 * <p> * 二、流的体系结构 *.
Java IO 模型 B站课程(尚硅谷)学习总结
weixin_43740223的博客
04-06 1142
IO模型就是用什么样的通道进行数据的发送和接收，很大程度上决定了程序通信的性能。 Java共支持3种网络编程模型/IO模式：BIO，NIO，AIO 1. IO模型介绍 Java BIO Blocking IO,阻塞io 服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不做任何事情就会造成不必要的连接开销。 Java NIO Non-Blocking IO,同步非阻塞io 服务器实现模式为一个线程处理多个请求(连接)，即客户端发送的连接请求都会注
allllll
热门推荐
Lumos427的博客
06-07 1万+
alll
尚硅谷佟刚详解Java IO基础：File、流分类与序列化
本资源主要介绍Java基础中的IO（Input/Output）操作，由尚硅谷的IO讲师佟刚讲解。内容涵盖了以下几个核心知识点： 1. **IO概述**：Java的IO系统负责程序与外部数据交互，包括读取和写入磁盘、光盘等存储设备。IO...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

CHH3213

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值