JavaSE IO流

最新推荐文章于 2024-03-19 22:35:49 发布
最新推荐文章于 2024-03-19 22:35:49 发布
阅读量682 收藏 1
点赞数
分类专栏： JavaSE 文章标签： java javase
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46651512/article/details/112095663
版权

JavaSE IO 流

1.File

1.1 File 类的概述和构造方法

  • File：它是文件和目录路径名的抽象表示
    • 文件和目录是可以通过 File 封装成对象的
    • 对于 File 而言，其封装的并不是一个真正存在的文件，仅仅是一个路径名而已。它可以是存在的，也可以是不存在的。将来是要通过具体的操作把这个路径的内容转换为具体存在的

在这里插入图片描述

package com.File01;

import java.io.File;

/*
    File：它是文件和目录路径名的抽象表示
        1.文件和目录是可以通过 File 封装成对象的
        2.对于 File 而言，其封装的并不是一个真正存在的文件，仅仅是一个路径名而已。
          它可以是存在的，也可以是不存在的。将来是要通过具体的操作把这个路径的内容转换为具体存在的
    构造方法：
        File(String pathName):通过将给定的路径名字符串转换为抽象路径名来创建新的File实例
        File(String parent,String child):从父路径名字符串和子路径名字符串创建新的File实例
        File(File parent,String child):从父抽象路径名和子路径名字符串创建新的File实例
 */
public class FileDemo01 {
    public static void main(String[] args){
        //File(String pathName):通过将给定的路径名字符串转换为抽象路径名来创建新的File实例
        File f1 = new File("D:\\(F)\\IDEA\\IO\\bug.txt");//bug.txt并不存在
        System.out.println(f1); //D:\(F)\IDEA\IO\bug.txt

        //File(String parent,String child):从父路径名字符串和子路径名字符串创建新的File实例
        File f2 = new File("D:\\(F)\\IDEA\\IO","bug.txt");
        System.out.println(f2);//D:\(F)\IDEA\IO\bug.txt

        //File(File parent,String child):从父抽象路径名和子路径名字符串创建新的File实例
        File f3 = new File("D:\\(F)\\IDEA\\IO");
        File f4 = new File(f3,"bug.txt");
        System.out.println(f4);//D:\(F)\IDEA\IO\bug.txt
    }
}

1.2 File 类的创建功能

在这里插入图片描述

package com.File01;

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

/*
    File类创建功能：
        public boolean createNewFile():当具有该名称的文件不存在时，创建一个由该抽象路径名命名的新空文件
            如果文件不存在，就创建文件，并返回true
            如果文件存在，就不创建文件，并返回false
        public boolean mkdir():创建由此抽象路径名命名的目录
            如果目录不存在，就创建目录，并返回true
            如果目录存在，就不创建目录，并返回false
        public boolean mkdirs():创建由此抽象路径名命名的目录，包括任何必需但不存在的父目录
            如果目录不存在，就创建目录，并返回true
            如果目录存在，就不创建目录，并返回false
 */
public class FileDemo02 {
    public static void main(String[] args) throws IOException {
        //1.在D:\(F)\IDEA\IO目录下创建一个文件bug.txt
        File f1 = new File("D:\\(F)\\IDEA\\IO\\bug.txt");
        System.out.println(f1.createNewFile());
        System.out.println("-------");

        //2.在D:\(F)\IDEA\IO目录下创建一个目录JavaSE
        File f2 = new File("D:\\(F)\\IDEA\\IO\\JavaSE");
        System.out.println(f2.mkdir());
        System.out.println("-------");

        //3.在D:\(F)\IDEA\IO目录下创建一个多级目录JavaWEB\HTML
        File f3 = new File("D:\\(F)\\IDEA\\IO\\JavaWEB\\HTML");
        System.out.println(f3.mkdirs());

    }
}

1.3 File 类的删除功能

在这里插入图片描述

  • 绝对路径和相对路径的区别

    • 绝对路径：完整的路径名 ，不需要任何其他信息就可以定位它所表示的文件。
      例如：D:(F)\IDEA\IO\bug.txt
    • 相对路径：必须使用取自其他路径名的信息进行解释。
      例如：myFile\java.txt

  • 删除目录时的注意事项：

    • 如果一个 目录中有内容（目录，文件），不能直接删除。应该先删除目录中的内容，最后才能删除目录
package com.File01;

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

/*
    File类的删除功能：
        public boolean delete():删除由此抽象路径名表示的文件或目录
 */
public class FileDemo03 {
    public static void main(String[] args) throws IOException {
        //1.在当前模块目录下创建java.txt文件
        File f1 = new File("myFile\\java.txt");
//        System.out.println(f1.createNewFile());

        //2.删除当前模块目录下的java.txt文件
//        System.out.println(f1.delete());
        System.out.println("-------");

        //3.在当前模块目录下创建bug目录
        File f2 = new File("myFile\\bug");
//        System.out.println(f2.mkdir());

        //4.删除当前模块目录下的bug目录
//        System.out.println(f2.delete());
        System.out.println("-------");

        //5.在当前模块目录下创建一个目录njust，然后在该目录下创建一个文件FH.txt
        File f3 = new File("myFile\\njust");
        System.out.println(f3.mkdir());
        File f4 = new File("myFile\\njust\\FH.txt");
        System.out.println(f4.createNewFile());

        //6.删除当前模块下的目录njust
        System.out.println(f4.delete());
        System.out.println(f3.delete());

    }
}

1.4 File 类的判断和获取功能

在这里插入图片描述

package com.File01;

import java.io.File;

/*
    File类的判断和获取功能：
        public boolean isDirectory():测试此抽象路径名表示的File是否为目录
        public boolean isFile():测试此抽象路径名表示的File是否为文件
        public boolean exists():测试此抽象路径名表示的File是否存在

        public String getAbsolutePath():返回此抽象路径名的绝对路径名字符串
        public String getPath():将此抽象路径名转换为路径名字符串
        public String getName():返回由此抽象路径名表示的文件或目录的名称

        public String[] list():返回此抽象路径名表示的目录中的文件和目录的名称字符串数组
        public File[] listFiles():返回此抽象路径名表示的目录中的文件和目录的File对象数组
 */
public class FileDemo04 {
    public static void main(String[] args){
        //创建一个File对象
        File f1 = new File("myFile\\java.txt");

        System.out.println(f1.isDirectory());
        System.out.println(f1.isFile());
        System.out.println(f1.exists());

        System.out.println(f1.getAbsolutePath());
        System.out.println(f1.getPath());
        System.out.println(f1.getName());
        System.out.println("-------");

//        public String[] list():返回此抽象路径名表示的目录中的文件和目录的名称字符串数组
//        public File[] listFiles():返回此抽象路径名表示的目录中的文件和目录的File对象数组
        File f2 = new File("D:\\(F)\\IDEA\\IO");
        String[] strArray = f2.list();
        for(String str : strArray){
            System.out.println(str);
        }
        System.out.println("-------");

        File[] fileArray = f2.listFiles();
        for(File file : fileArray){
//            System.out.println(file);
//            System.out.println(file.getName());
            if(file.isFile()){
                System.out.println(file.getName());
            }
        }


    }
}

1.5 递归

  • 递归概述：
    从编程的角度来看，递归指的是方法定义中调用方法本身的现象

  • 递归解决问题的思路：
    把一个复杂的问题层层转化为一个 与原问题相似的规模较小 的问题来求解
    递归策略只需 少量的程序 就可以描述解题过程所需要的多次重复计算

  • 递归解决问题要找到两个内容：

    1. 递归出口：否则会出现内存溢出
    2. 递归规则：与原问题相似的规模较小的问题
package com.Recursion;
/*
    递归概述：
        从编程的角度来看，递归指的是方法定义中调用方法本身的现象
 */
public class RecursionDemo01 {
    public static void main(String[] args){
        //不死神兔问题，就第20个月兔子的对数
        //每个月的兔子对数：1,1,2,3,5,8,13...
        int[] arr = new int[20];
        arr[0] = 1;
        arr[1] = 1;
        for(int i = 2;i < arr.length;i++){
            arr[i] = arr[i-1] + arr[i-2];
        }
        System.out.println(arr[19]);
        System.out.println(f(20));
    }
    /*
        递归解决问题，首先就是要定义一个方法：
            定义一个方法f(n)：表示第n个月的兔子对数
            那么，第n-1个月的兔子对数为：f(n-1)
            同理，第n-2个月的兔子对数为：f(n-2)
        StackOverFlowError:当堆栈溢出发生时抛出一个应用程序递归太深
     */
    public static int f(int n){
        if(n == 1 || n == 2){
            return 1;
        }else {
            return f(n - 1) + f(n - 2);
        }
    }
}
  • 递归求阶乘
public class DiGuiDemo01{
	public static void main(String[] args){
		int result = jc(5);
		System.out.println("5的阶乘是：" + result);
	}
	public static int jc(int n){
		if(n == 1){
			return 1;
		}else{
			return n * jc(n-1);
		}
	}
}

在这里插入图片描述

进栈的过程：

在这里插入图片描述

  • 案例（遍历目录）
package com.Recursion;

import java.io.File;
/*
    需求：
        给定一个路径（D:\(F)\IDEA\IO），通过递归完成遍历该目录下的所有内容，并把所有文件的绝对路径输出在控制台
    思路：
        1.根据给定的路径创建一个File对象
        2.定义一个方法，用于获取给定目录下的所有内容，参数为第1步创建的File对象
        3.获取给定的File目录下的所有文件或者目录的File数组
        4.遍历该File数组，得到每一个File对象
        5.判断该File对象是否是目录
            是：递归调用
            不是：获取绝对路径输出在控制台
        6.调用方法
 */
public class RecursionDemo03 {
    public static void main(String[] args){
        //1.根据给定的路径创建一个File对象
        File srcFile = new File("D:\\(F)\\IDEA\\IO");
        //6.调用方法
        getAllFilePath(srcFile);
    }
    //2.定义一个方法，用于获取给定目录下的所有内容，参数为第1步创建的File对象
    public static void getAllFilePath(File srcFile){
        //3.获取给定的File目录下的所有文件或者目录的File数组
        File[] fileArray = srcFile.listFiles();
        //4.遍历该File数组，得到每一个File对象
        if(fileArray != null){//考虑程序的健壮性
            for(File file : fileArray){
                //5.判断该File对象是否是目录
                if(file.isDirectory()){
                    //是：递归调用
                    getAllFilePath(file);
                }else{
                    //不是：获取绝对路径输出在控制台
                    System.out.println(file.getAbsolutePath());
                }
            }
        }
    }
}

2.字节流

2.1 IO 流的概述和分类

  • IO 流的概述：
    • IO：输入/输出(Input/Output)
    • 流：流是一种抽象概念，是对数据传输的总称。也就是说数据在设备间的传输称为流，流的本质是数据传输
    • IO 流就是用来处理设备间数据传输问题的
      常见的应用有：文件复制，文件上传，文件下载

在这里插入图片描述

  • IO 流的分类

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

  • 一般来说，我们说 IO 流的分类是按照 数据类型 来分的

  • 这两种流都在什么情况下使用？
    如果数据通过Windows自带的记事本软件打开，我们还可以 读懂里面的内容 ，就使用字符流，否则使用字节流。如果不知道该使用哪种类型的流，就用字节流

    • 用记事本打开 jpg 文件：
      在这里插入图片描述

2.2 字节流写数据

  • 字节流抽象基类

    • InputStream ：这个抽象类是表示字节输入流的所有类的超类
    • OutputStream：这个抽象类是表示字节输出流的所有类的超类
    • 子类名特点：子类名称都是以其父类名作为子类名的后缀

  • FileOutputStream：文件输出流用于将数据写入File

    • FileOutputStream(String name)：创建文件输出流以指定的名称写入文件

  • 使用字节输出流写数据的步骤：

    1. 创建字节输出流对象（调用系统功能创建了文件；创建了字节输出流对象；让字节输出流对象指向文件）
    2. 调用字节输出流对象的写数据方法
    3. 释放资源（关闭此文件输出流并释放与此流相关联的任何系统资源）
package com.ByteStream01;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

/*
    FileOutputStream：文件输出流用于将数据写入File
        FileOutputStream(String name)：创建文件输出流以指定的名称写入文件
 */
public class FileOutputStreamDemo01 {
    public static void main(String[] args) throws IOException {
        //创建字节输出流对象
        //FileOutputStream(String name)：创建文件输出流以指定的名称写入文件
        FileOutputStream fos = new FileOutputStream("myByteStream\\fos.txt");
        /*
            创建字节输出流对象做了三件事情：
                1.调用系统功能创建了文件
                2.创建了字节输出流对象
                3.让字节输出流对象指向创建好的文件
         */

        //void write (int b):将指定的字节写入此文件输出流
        fos.write(97);//结果：a  (ASCII码)

        //所有和IO操作相关的内容最后都要释放资源
        //void close():关闭此文件输出流并释放与此流相关联的任何系统资源
        fos.close();

    }
}

2.3 字节流写数据的3种方式

在这里插入图片描述

package com.ByteStream01;

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

/*
    构造方法：
        FileOutputStream(String name):创建文件输出流以指定的名称写入文件
        FileOutputStream(File file):创建文件输出流以写入由指定的File对象表示的文件
    写数据的3中方法：
        void write(int b):将指定的字节写入此文件输出流
            一次写一个字节数据
        void write(byte[] b):将b.length字节从指定的字节数组中写入此文件输出流
            一次写一个字节数组数据
        void write(byte[] b,int off,int len):将len字节从指定的字节数组开始，从偏移量off开始写入此文件输出流
            一次写一个字节数组的部分数据
 */
public class FileOutputStreamDemo02 {
    public static void main(String[] args) throws IOException {
        //FileOutputStream(String name):创建文件输出流以指定的名称写入文件
        FileOutputStream fos = new FileOutputStream("myByteStream\\fos.txt");
        //new File(name)(FileOutputStream的内部自动完成)
//        FileOutputStream fos= new FileOutputStream(new File("myByteStream\\fos.txt"));

//        //FileOutputStream(File file):创建文件输出流以写入由指定的File对象表示的文件
//        File file = new File("myByteStream\\\\fos.txt");
//        FileOutputStream fos2 = new FileOutputStream(file);
//        //上两步合成一步
//        FileOutputStream fos2 = new FileOutputStream(new File("myByteStream\\\\fos.txt"));
        //这两个构造方法做的事情其实是一样的

        //void write(int b):将指定的字节写入此文件输出流
//        fos.write(97);
//        fos.write(98);
//        fos.write(99);
//        fos.write(100);
//        fos.write(101);     //abcde
        //void write(byte[] b):将b.length字节从指定的字节数组中写入此文件输出流
//        byte[] bys = {97,98,99,100,101};
        //byte[] getBytes():返回字符串对应的字节数组
//        byte[] bys = "abcde".getBytes();
//        fos.write(bys);
        //void write(byte[] b,int off,int len):
        // 将len字节从指定的字节数组开始，从偏移量off开始写入此文件输出流
        byte[] bys = "abcdefghijk".getBytes();
        fos.write(bys,9,2);

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

2.4 字节流写数据的两个小问题

  1. 字节流写数据如何实现换行？
  2. 字节流写数据如何实现追加写入？
package com.ByteStream01;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

/*
     字节流写数据的两个小问题:
        1.字节流写数据如何实现换行？
            windows:\r\n
            linux:\n
            mac:\r
        2.字节流写数据如何实现追加写入？
            public FileOutputStream(String name,boolean append):
                创建文件输出流以指定的名称写入文件。
                如果第二个参数为true，则字节将写入文件的末尾而不是开头
 */
public class FileOutputStreamDemo03 {
    public static void main(String[] args) throws IOException {
        //创建字节输出流对象
//        FileOutputStream fos = new FileOutputStream("myByteStream\\fos.txt");
        FileOutputStream fos = new FileOutputStream("myByteStream\\fos.txt",true);

        //写数据
        for(int i=0;i<5;i++){
            fos.write("bug".getBytes());
            fos.write("\n".getBytes());
        }
        //释放资源
        fos.close();
    }
}

2.5 字节流写数据加入异常处理

  • finally ：在异常处理时提供 finally 块来执行所有的清楚操作。
    比如说 IO 流中的资源释放

  • 特点：被 finally 控制的语句一定会执行，除非 JVM 退出

  • 格式：

try{
	可能出现异常的代码;
}catch(异常类名 变量名){
	异常的处理代码;
}finally{
	执行所有清除操作;
}

package com.ByteStream01;

import java.io.FileOutputStream;
import java.io.IOException;

/*
    字节流写入数据加入异常处理
    本程序中：如果在执行fos.write()动作的时候出现了IO异常，
    然后程序会走到e.printStackTrace()，那么释放资源的动作
    fos.close()就没有执行到，资源就一直被占用着
    为了保证资源一定能够被释放，Java提供了关键字finally
 */
public class FileOutputStreamDemo04 {
    public static void main(String[] args){
//        try {
//            FileOutputStream fos = new FileOutputStream("myByteStream\\fos.txt");
//            fos.write("bug".getBytes());
//            fos.close();
//        }catch (IOException e){
//            e.printStackTrace();
//        }

        //加入finally来实现释放资源
        FileOutputStream fos = null;
        try {
            fos = new FileOutputStream("myByteStream\\fos.txt");
            fos.write("bug".getBytes());
            fos.close();
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            if(fos != null) {  //程序的健壮性，只有fos不为空时才需要释放资源
                try {
                    fos.close();//如果前面没有加健壮性的判断，当创建对象失败时（比如路径不存在），这里会报空指针异常
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

2.6 字节流读数据（一次读一个字节数据）

FileInputStream：从文件系统中的文件获取输入字节

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

  • 使用字节输入流读数据的步骤：

    1. 创建字节输入流对象
    2. 调用字节输入流对象的读数据方法
    3. 释放资源
package com.ByteStream02;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

/*
    需求：
        把文件fos.txt中的内容读取出来在控制台输出

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

    使用字节输入流读数据的步骤：
        1.创建字节输入流对象
        2.调用字节输入流对象的读数据方法
        3.释放资源
 */
public class FileInputStreamDemo01 {
    public static void main(String[] args) throws IOException {
        //1.创建字节输入流对象
        //FileInputStream(String name)
        FileInputStream fis = new FileInputStream("myByteStream\\fos.txt");

        //2.调用字节输入流对象的读数据方法
        //int read():从该输入流读取一个字节的数据

        /*
        //第1次读取数据
        int read = fis.read();
        System.out.println(read);
        System.out.println((char)read);

        //第2次读取数据
        read = fis.read();
        System.out.println(read);
        System.out.println((char)read);

        //第3次读取数据
        read = fis.read();
        System.out.println(read);
        System.out.println((char)read);

        //第4次读取数据
        read = fis.read();
        System.out.println(read);  // fos.txt中内容为bug，第4次读取数据的返回值为 -1
        System.out.println((char)read);

        //如果读到文件末尾，则返回 -1

         */

        /*
        int by = fis.read();
        while(by != -1){
            System.out.print((char)by);
            by= fis.read();
        }

         */

        //优化上面的循环
        /*
            fis.read():读数据
            by=fis.read():把读取到的数据赋值给by
            by ！= -1:判断读取到的数据是否是 -1
         */
        int by;
        while((by=fis.read()) != -1){
            System.out.print((char)by);
        }

        //3.释放资源
        fis.close();
    }
}
  • 案例（文件复制）
package com.ByteStream02;

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

/*
    需求：
        把"D:\(F)\IDEA\IO\bug.txt"复制到模块目录下的"bug.txt"

        数据源：
            D:\(F)\IDEA\IO\bug.txt -- 读数据 -- InputStream -- FileInputStream
        目的地：
            myByteStream\bug.txt -- 写数据 -- OutputStream -- FileOutputStream

        思路：
            1.根据数据源创建字节输入流对象
            2.根据目的地创建字节输出流对象
            3.读写数据，复制文件（一次读取一个字节，一次写入一个字节）
            4.释放资源
 */
public class CopyTxtDemo {
    public static void main(String[] args) throws IOException {
        //1.根据数据源创建字节输入流对象
        FileInputStream fis = new FileInputStream("D:\\(F)\\IDEA\\IO\\bug.txt");
        //2.根据目的地创建字节输出流对象
        FileOutputStream fos = new FileOutputStream("myByteStream\\bug.txt");
        //3.读写数据，复制文件（一次读取一个字节，一次写入一个字节）

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

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

2.6 字节流读数据（一次读一个字节数组数据）

package com.ByteStream02;

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

/*
    需求：
        把文件fos.txt中的内容读取出来在控制台输出
    使用字节流读数据的步骤：
        1.创建字节输入流对象
        2.调用字节输入路对象的读数据方法
        3.释放资源
 */
public class FileInputStreamDemo02 {
    public static void main(String[] args) throws IOException {
        //1.创建字节输入流对象
        FileInputStream fis = new FileInputStream("myByteStream\\fos.txt");
        //2.调用字节输入路对象的读数据方法
        /*
        byte[] bys = new byte[5];

        //第1次读取数据
        int len = fis.read(bys);
        System.out.println(len);
        //String (byte[] bytes):该构造方法将指定的字节数组变成一个字符串
        System.out.println(new String(bys));

        //第2次读取数据
        len = fis.read(bys);
        System.out.println(len);
        System.out.println(new String(bys));

        //第3次读取数据
        len = fis.read(bys);
        System.out.println(len);
//        System.out.println(new String(bys));
        //第3次只读取了4个字节，那也应该只把字节数组中的前4个转换成字符串
        //String (byte[] bytes,int offset,int length)
        System.out.println(new String(bys,0,len));

        //再多读取1次
        len = fis.read(bys);
        System.out.println(len);//说明到达末尾的时候会返回 -1

         */

        /*
            fos.txt内容：
                hello\r\n
                world\r\n

            第1次：hello
            第2次：\r\nwor
            第3次：ld\r\nr
            第3次只读取到了4个字节，只将第2次的结果的前4个替换了，最后那个"r"会保留下来
         */

        byte[] bys = new byte[1024];//一般为1024及其整数倍
        int len;
        while ((len=fis.read(bys)) != -1){
            System.out.print(new String(bys,0,len));
        }

        //3.释放资源
        fis.close();
    }
}
  • 案例（复制图片）
package com.ByteStream02;

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

/*
    需求：
        把"D:\(F)\IDEA\IO\lazy.jpg"复制到模块目录下的"lazy.jpg"

        思路：
            1.根据数据源创建字节输入流对象
            2.根据目的地创建字节输出流对象
            3.读写数据，复制图片（一次读取一个字节数组，一次写入一个字节数组）
            4.释放资源
 */
public class CopyJpgDemo {
    public static void main(String[] args) throws IOException {
        //1.根据数据源创建字节输入流对象
        FileInputStream fis = new FileInputStream("D:\\(F)\\IDEA\\IO\\lazy.jpg");
        //2.根据目的地创建字节输出流对象
        FileOutputStream fos = new FileOutputStream("myByteStream\\lazy.jpg");
        //3.读写数据，复制图片（一次读取一个字节数组，一次写入一个字节数组）
        byte[] bys = new byte[1024];
        int len;
        while((len=fis.read(bys)) != -1){
            fos.write(bys,0,len);
        }
        
        //4.释放资源
        fis.close();
        fos.close();

    }
}

在这里插入图片描述

2.7 字节缓冲流

  • 字节缓冲流：

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

  • 构造方法：

    1. 字节缓冲输出流：BufferedOutputStream(OutputStream out)
    2. 字节缓冲输入流：BufferedInputStream(InputStream in)

  • 为什么构造方法需要的是字节流，而不是具体的文件或者路径呢？
    字节缓冲流 仅仅提供缓冲区 ，而真正的读取数据还得依靠基本的字节流对象进行操作

package com.BufferedStream01;

import java.io.*;

/*
    字节缓冲流:
        BufferedInputStream
        BufferedOutputStream
    构造方法:
        1.字节缓冲输出流：BufferedOutputStream(OutputStream out)
        2.字节缓冲输入流：BufferedInputStream(InputStream in)
 */
public class BufferedStreamDemo01 {
    public static void main(String[] args) throws IOException {
        //1.字节缓冲输出流：BufferedOutputStream(OutputStream out)
//        FileOutputStream fos = new FileOutputStream("myByteStream\\bos.txt");
//        BufferedOutputStream bos = new BufferedOutputStream(fos);
        /*
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("myByteStream\\bos.txt"));
        //写数据
        bos.write("hnist\r\n".getBytes());
        bos.write("njust\r\n".getBytes());
        //释放资源
        bos.close();

         */

        //2.字节缓冲输入流：BufferedInputStream(InputStream in)
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("myByteStream\\bos.txt"));
        //读数据

        //一次读取一个字节数据
//        int by;
//        while((by=bis.read()) != -1){
//            System.out.print((char)by);
//        }

        //一次读取一个字节数组数据
        byte[] bys = new byte[1024];
        int len;
        while((len=bis.read(bys)) != -1){
            System.out.print(new String(bys,0,len));
        }


        //释放资源
        bis.close();

    }
}
  • 案例（复制视频）
package com.BufferedStream01;

import java.io.*;

/*
    需求：
        把"D:\(F)\IDEA\IO\懒羊羊.mp4"复制到模块目录下的"懒羊羊.mp4"

    思路：
        1.根据数据源创建字节输入流对象
        2.根据目的地创建字节输出流对象
        3.读写数据，复制视频
        4.释放资源
    4种方式实现复制视频，并记录每种方式复制视频的时间
        1.基本字节流一次读写一个字节          共耗时:74291毫秒
        2.基本字节流一次读写一个字节数组       共耗时:115毫秒
        3.字节缓冲流一次读写一个字节          共耗时:267毫秒
        4.字节缓冲流一次读写一个字节数组       共耗时:26毫秒
 */
public class CopyMp4Demo {
    public static void main(String[] args) throws IOException{
        //记录开始时间
        long startTime = System.currentTimeMillis();

        //复制视频
//        method1();
//        method2();
//        method3();
        method4();

        //记录结束时间
        long endTime = System.currentTimeMillis();
        System.out.println("共耗时:" + (endTime-startTime) + "毫秒");
    }
    //1.基本字节流一次读写一个字节
    public static void method1() throws IOException {
        FileInputStream fis = new FileInputStream("D:\\(F)\\IDEA\\IO\\懒羊羊.mp4");
        FileOutputStream fos = new FileOutputStream("myByteStream\\懒羊羊.mp4");
        int by;
        while((by=fis.read()) != -1){
            fos.write(by);
        }
        fis.close();
        fos.close();
    }

    //2.基本字节流一次读写一个字节数组
    public static void method2() throws IOException {
        FileInputStream fis = new FileInputStream("D:\\(F)\\IDEA\\IO\\懒羊羊.mp4");
        FileOutputStream fos = new FileOutputStream("myByteStream\\懒羊羊.mp4");
        byte[] bys = new byte[1024];
        int len;
        while((len=fis.read(bys)) != -1){
            fos.write(bys,0,len);
        }
        fis.close();
        fos.close();
    }

    //3.字节缓冲流一次读写一个字节
    public static void method3() throws IOException{
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:\\(F)\\IDEA\\IO\\懒羊羊.mp4"));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("myByteStream\\懒羊羊.mp4"));
        int by;
        while((by=bis.read()) != -1){
            bos.write(by);
        }
        bis.close();
        bos.close();
    }

    //4.字节缓冲流一次读写一个字节数组
    public static void method4() throws IOException{
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:\\(F)\\IDEA\\IO\\懒羊羊.mp4"));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("myByteStream\\懒羊羊.mp4"));
        byte[] bys = new byte[1024];
        int len;
        while ((len=bis.read(bys)) != -1) {
            bos.write(bys,0,len);
        }
        bis.close();
        bos.close();
    }
}

3.字符流

3.1 为什么会出现字符流

由于字节流操作中文不是特别方便，所以Java就提供了字符流

  • 字符流 = 字节流 + 编码表

用字节流复制文本文件时，文本文件也会有中文，但是没有问题，原因是最终底层操作会自动进行字节拼接成中文，如何识别是中文的呢？

  • 汉字在存储的时候，无论选择哪一种编码存储，第一个字节都是负数
  • 然后看是GBK编码还是UTF-8编码：
    如果是GBK编码那就把第二个拼上来（2个）；
    如果是UTF-8编码那就再把后面两个拼上来（3个）
package com.CharStream01;

import java.io.FileInputStream;
import java.io.IOException;
import java.util.Arrays;

/*
    需求：
        字节流读文本文件数据
    一个汉字的存储：
        如果是GBK编码，占用2个字节
        如果是UTF-8编码，占用3个字节
 */
public class FileInputStreamDemo01 {
    public static void main(String[] args) throws IOException {
//        FileInputStream fis = new FileInputStream("myCharStream\\a.txt");
//        int by;
//        while((by=fis.read()) != -1){       //每个汉字占用3个字节，而现在拿到一个字节就把它转换成对应
//                                            // 的字符，所以就出问题了
//            System.out.print((char)by);
//        }
//        fis.close();
//        String s = "njust";         //[110, 106, 117, 115, 116] 每一个字符对应着一个字节的数据
        String s = "苦瓜";             //[-24, -117, -90, -25, -109, -100]
//        byte[] bys = s.getBytes();
//        byte[] bys = s.getBytes("UTF-8");         //[-24, -117, -90, -25, -109, -100]
        byte[] bys = s.getBytes("GBK");  //[-65, -32, -71, -49]
        System.out.println(Arrays.toString(bys));
    }
}

3.2 编码表

基础知识：

  • 计算机中存储的信息都是用 二进制数 表示的；我们在屏幕上看到的英文、汉字等字符是二进制数转换之后的结果
  • 按照某种规则，将字符存储到计算机中，称为 编码 。反之，将存储在计算机中的二进制数按照某种规则解析显示出来，称为 解码 。
    注意：按照A编码存储，必须按照A编码解析，这样才能显示正确的文本符号，否则就会导致乱码的现象。
    字符编码：就是一套自然语言的字符与二进制数之间的对应规则。例如：(A , 65)

字符集：

  • 字符集是一个系统支持的所有字符的集合，包括各国文字、标点符号、图形符号、数字等
  • 计算机要准确的存储和识别各种字符集符号，就需要进行字符编码，一套字符集必然至少有一套字符编码。
    常见的字符集有ASCII字符集，GBXXX字符集，Unicode字符集等

ASCII字符集：

  • ASCII （American Standard Code for Information Interchange，美国信息交换标准码）：是基于拉丁字母的一套电脑编码系统，用于显示现代英语，只要包括控制字符（回车键，退格，换行键等）和可显示字符（英文大小写字符，阿拉伯数字和西文符号）。
  • 基本的ASCII字符集，使用7位表示一个字符，共128字符。ASCII扩展字符集使用8位表示一个字符，共256字符。是一个系统支持的所有字符的集合，包括各国文字，标点符号，图形符号，数字等

GBXXX字符集：

  • GB2312：简体中文码表。一个小于127的字符的意义与原来的相同，但两个大于127的字符连在一起时，就表示一个汉字，这样大约可以组合7000多个简体汉字。此外，数字符号、罗马希腊的字母、日文的假名等都编进去了，连在ASCII本来就有的数字，标点，字母都全部重新编了两个字节长的编码，这就是常说的“全角”字符，而原来在127号以下的那些都叫“半角”字符了
  • GBK ：最常用的中文码表。是在GB2312标准基础上的扩展规范，使用了双字节编码方案，共收录了21003个汉字，完全兼容GB2312标准，同时支持繁体汉字以及日韩汉字等
  • GB18030：最新的中文码表。收录汉字70244个，采用多字节编码，每个字可以由1个、2个或4个字节组成。支持中国国内少数名族的文字，同时支持繁体汉字以及日韩汉字等

Unicode字符集：

  • 为表达任意语言的任意字符而设计，是业界的一种标准，也称为统一码、标准万国码。它最多使用4个字节的数字来表达字母，符号或者文字。有3中编码方案，UTF-8，UTF-16和UTF32，最常用的是UTF-8编码。
  • UTF-8 编码：可以用来表示Unicode标准中任意字符，它是电子邮件网页以及其他存储或者传送文字的应用中，优先采用的编码。互联网工程工作小组（IETF）要求所有互联网协议都必须支持UTF-8编码。它使用1个至4个字节为每个字符编码
    • 编码规则：
      128个US-ASCII字符，只需1个字节编码
      拉丁文等字符，需要2个字节编码
      大部分常用字（包括中文），使用3个字节编码
      其他极少使用的Unicode辅助字符，使用4字节编码

3.3 字符串中的编码解码问题

编码：

  • byte[ ] getBytes():使用平台的默认字符集将该String编码为一系列字节，将结果存储到新的字节数组中
  • byte[ ] getBytes(String charsetName):使用指定的字符集将该String编码为一系列字节，将结果存储到新的字节数组中

解码：

  • String(byte[ ] bytes):通过使用平台的默认字符集解码指定的字节数组来构造新的String
  • String(byte[ ] bytes,String charsetName):通过指定的字符集解码指定的字节数组来构造新的String
package com.CharStream01;

import java.io.UnsupportedEncodingException;
import java.util.Arrays;

/*
    编码：
        byte[ ] getBytes():使用平台的默认字符集将该String编码为一系列字节，将结果存储到新的字节数组中
        byte[ ] getBytes(String charsetName):使用指定的字符集将该String编码为一系列字节，将结果存储到新的字节数组中
    解码：
        String(byte[ ] bytes):通过使用平台的默认字符集解码指定的字节数组来构造新的String
        String(byte[ ] bytes,String charsetName):通过指定的字符集解码指定的字节数组来构造新的String
 */
public class StringDemo {
    public static void main(String[] args) throws UnsupportedEncodingException {
        //定义一个字符串
        String s = "苦瓜";

        //byte[ ] getBytes():使用平台的默认字符集将该String编码为一系列字节，将结果存储到新的字节数组中
        byte[] bys = s.getBytes();//[-24, -117, -90, -25, -109, -100]

        //byte[ ] getBytes(String charsetName):使用指定的字符集将该String编码为一系列字节，将结果存储到新的字节数组中
//        byte[] bys = s.getBytes("UTF-8");//[-24, -117, -90, -25, -109, -100]
//        byte[] bys = s.getBytes("GBK");//[-65, -32, -71, -49]

        //String(byte[ ] bytes):通过使用平台的默认字符集解码指定的字节数组来构造新的String
//        String ss = new String(bys);//苦瓜

        //String(byte[ ] bytes,String charsetName):通过指定的字符集解码指定的字节数组来构造新的String
//        String ss = new String(bys,"UTF-8");//苦瓜
        String ss = new String(bys,"GBK");//鑻︾摐


        System.out.println(Arrays.toString(bys));
        System.out.println(ss);

    }
}

3.4 字符流中的编码解码问题

字符流抽象基类：

  • Reader：字符输入流的抽象类
  • Writer：字符输出流的抽象类

字符流中和编码解码相关的两个类：

  • InputStreamReader
  • OutputStreamWriter
package com.CharStream02;

import java.io.*;

/*
    InputStreamReader:是从字节流到字符流的桥梁
        它读取字节，并使用指定的编码将其解码为字符
        它使用的字符集可以由名称指定，也可以被明确指定，或者可以接受平台的默认字符集
    OutputStreamWriter:是从字符流到字节流的桥梁
        使用指定的编码将写入的字符编码为字节
        它使用的字符集可以由名称指定，也可以被明确指定，或者可以接受平台的默认字符集
 */
public class ConversionStreamDemo {
    public static void main(String[] args) throws IOException {
        //OutputStreamWriter(OutputStream out) 创建一个使用默认字符编码的OutputStreamWriter
        //OutputStreamWriter(OutputStream out,String charsetName) 创建一个使用命名字符集OutputStreamWriter
//        FileOutputStream fos = new FileOutputStream("myCharStream\\osw.txt");
//        OutputStreamWriter osw = new OutputStreamWriter(fos);
//        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("myCharStream\\osw.txt"));
//        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("myCharStream\\osw.txt"),"UTF-8");
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("myCharStream\\osw.txt"),"GBK");
        //��� 乱码

        osw.write("苦瓜");
        osw.close();

        //InputStreamReader(InputStream in):创建一个使用默认字符集的InputStreamReader
        //InputStreamReader(InputStream in,String charsetName):创建一个使用命名字符集的InputStreamReader
//        InputStreamReader isr = new InputStreamReader(new FileInputStream("myCharStream\\osw.txt"));
        InputStreamReader isr = new InputStreamReader(new FileInputStream("myCharStream\\osw.txt"),"GBK");
        //一次读取一个字符数据
        int ch;
        while((ch=isr.read()) != -1){
            System.out.print((char)ch);
        }
        isr.close();
    }
}

3.5 字符流写数据的5种方式

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

package com.CharStream02;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;

/*
    构造方法：
        OutputStreamWriter(OutputStream out):创建一个使用默认字符编码的OutputStreamWriter
    字符流写数据的5种方式：
        1.void write(int c):写一个字符
        2.void write(char[] cbuf):写一个字符数组
        3.void write(char[] cbuf,int off,int len):写入字符数组的一部分
        4.void write(String str):写一个字符串
        5.void write(String str,int off,int len):写一个字符串的一部分
 */
public class OutputStreamWriterDemo01 {
    public static void main(String[] args) throws IOException{
        //OutputStreamWriter(OutputStream out):创建一个使用默认字符编码的OutputStreamWriter
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("myCharStream\\osw.txt"));
        //1.void write(int c):写一个字符
//        osw.write(97);
        /*
            这里我们采用字符流写数据，而字符流写数据并不能直接写到文件里面来，因为它最终要
            通过字节流去写，它现在还在缓冲区里面。为了让数据能够直接进到文件里面，需要刷新
         */
        //void flush():刷新流
//        osw.flush();
        /*
            如果不刷新，数据一开始是进不来的，因为真正写数据用的还是底层的字节流，
            而字符流相对于字节流来说它是有缓冲的
         */

        //2.void write(char[] cbuf):写一个字符数组
        char[] chs = {'a','b','c','d','e'};
        osw.write(chs);
        //3.void write(char[] cbuf,int off,int len):写入字符数组的一部分
        osw.write(chs,2,2);

        //4.void write(String str):写一个字符串
        osw.write("半仙儿努力考研");
        //5.void write(String str,int off,int len):写一个字符串的一部分
        osw.write("苦瓜的粉色匡威",3,4);
        
        
        //如果忘了刷新，关闭流之前也会刷新
        osw.close();
    }
}

3.6 字符流读数据的2种方式

在这里插入图片描述

package com.CharStream02;

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

/*
    构造方法：
        InputStreamReader(InputStream in):创建一个使用默认字符集的InputStreamReader
    字符流读数据的2种方式：
        1.int read():一次读一个字符数据
        2.int read(char[] cbuf):一次读一个字符数组数据
 */
public class InputStreamReaderDemo01 {
    public static void main(String[] args) throws IOException{
        //InputStreamReader(InputStream in):创建一个使用默认字符集的InputStreamReader
        InputStreamReader isr = new InputStreamReader(new FileInputStream("myCharStream\\osw.txt"));
        //1.int read():一次读一个字符数据
//        int ch;
//        while((ch=isr.read()) != -1){
//            System.out.print((char)ch);
//        }

        //2.int read(char[] cbuf):一次读一个字符数组数据
        char[] chs = new char[1024];
        int len;
        while((len=isr.read(chs)) != -1){
            System.out.println(new String(chs,0,len));
        }

        isr.close();
    }
}
  • 案例：字符流复制Java文件
package com.CharStream03;

import java.io.*;

/*
    需求：
        把模块下的ConversionStreamDemo.java复制到模块目录下的Copy.java
    思路：
        1.根据数据源创建字符输入流对象
        2.根据目的地创建字符输出流对象
        3.读写数据，复制文件
        4.释放资源
 */
public class CopyJavaDemo01 {
    public static void main(String[] args) throws IOException {
        //1.根据数据源创建字符输入流对象
        InputStreamReader isr = new InputStreamReader(new FileInputStream("myCharStream\\ConversionStreamDemo.java"));
        //2.根据目的地创建字符输出流对象
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("myCharStream\\Copy.java"));
        //3.读写数据，复制文件
        //一次读写一个字符数据
//        int ch;
//        while ((ch = isr.read()) != -1){
//            osw.write(ch);
//        }

        //一次读写一个字符数组数据
        char[] chs = new char[1024];
        int len;
        while((len=isr.read(chs)) != -1){
            osw.write(chs,0,len);
        }

        //4.释放资源
        isr.close();
        osw.close();
    }
}
  • 案例：字符流复制Java文件（改进版）
package com.CharStream03;

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

/*
    需求：
        把模块下的ConversionStreamDemo.java复制到模块目录下的Copy.java
    分析：
        1.转换流的名字比较长，而我们常见的操作都是按照本地默认编码实现的，所以，为了简化书写，转换流提供了对应的子类
        2.FileReader:用于读取字符文件的便捷类
            FileReader(String fileName)
        3.FileWriter:用于写入字符文件的便捷类
            FileWriter(String fileName)
        4.数据源：myCharStream\ConversionStreamDemo.java --- 读数据 --- Reader --- InputStreamReader --- FileReader
        5.目的地：myCharStream\Copy2.java --- 写数据 --- Writer --- OutputStreamWriter --- FileWriter
    思路：
        1.根据数据源创建字符输入流对象
        2.根据目的地创建字符输出流对象
        3.读写数据，复制文件
        4.释放资源
 */
public class CopyJavaDemo02 {
    public static void main(String[] args) throws IOException{
        //1.根据数据源创建字符输入流对象
        FileReader fr = new FileReader("myCharStream\\ConversionStreamDemo.java");
        //2.根据目的地创建字符输出流对象
        FileWriter fw = new FileWriter("myCharStream\\Copy2.java");
        //3.读写数据，复制文件
        //一次读取一个字符数据
//        int ch;while((ch=fr.read()) != -1){
//            fw.write(ch);
//        }
        //一次读写一个字符数组数据
        char[] chs = new char[1024];
        int len;
        while((len=fr.read(chs)) != -1){
            fw.write(chs,0,len);
        }

        //4.释放资源
        fr.close();
        fw.close();

    }
}

3.7 字符缓冲流

字符缓冲流：

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

构造方法：

  • BufferedWriter(Writer out)
  • BufferedReader(Reader in)
package com.CharStream04;

import java.io.*;

/*
    字符缓冲流：
        BufferedWriter:将文本写入字符输出流，缓冲字符，以提供单个字符，数组和字符串的高效写入，
        可以指定缓冲区大小，或者接受默认大小。默认值足够大，可用于大多数用途。
        BufferedReader:从字符输入流读取文本，缓冲字符，以提供字符，数组和行的高效读取，
        可以指定缓冲区大小，或者接受默认大小。默认值足够大，可用于大多数用途。
    构造方法：
        BufferedWriter(Writer out)
        BufferedReader(Reader in)
 */
public class BufferedStreamDemo01 {
    public static void main(String[] args) throws IOException {
        //BufferedWriter(Writer out)
//        FileWriter fw = new FileWriter("myCharStream\\bw.txt");
//        BufferedWriter bw = new BufferedWriter(fw);

//        BufferedWriter bw = new BufferedWriter(new FileWriter("myCharStream\\bw.txt"));
//        bw.write("苦瓜\r\n");
//        bw.write("半仙儿\r\n");
//        bw.close();

        //BufferedReader(Reader in)
        BufferedReader br = new BufferedReader(new FileReader("myCharStream\\bw.txt"));
        //一次读取一个字符
//        int ch;
//        while((ch=br.read()) != -1){
//            System.out.print((char)ch);
//        }
        //一次读取一个字符数组
        char[] chs = new char[1024];
        int len;
        while((len=br.read(chs)) != -1){
            System.out.print(new String(chs,0,len));
        }
        br.close();
    }
}
  • 案例：字符缓冲流复制Java文件
package com.CharStream04;

import java.io.*;

/*
    需求：
        把模块下的ConversionStreamDemo.java复制到模块目录下的Copy3.java
    思路：
        1.根据数据源创建字符缓冲输入流对象
        2.根据目的地创建字符缓冲输出流对象
        3.读写数据，复制文件
        4.释放资源
 */
public class CopyJavaDemo01 {
    public static void main(String[] args) throws IOException{
        BufferedReader br = new BufferedReader(new FileReader("myCharStream\\ConversionStreamDemo.java"));
        BufferedWriter bw = new BufferedWriter(new FileWriter("myCharStream\\copy3.java"));
//        int ch;
//        while((ch=br.read()) != -1){
//            bw.write(ch);
//        }

        char[] chs = new char[1024];
        int len;
        while((len=br.read(chs)) != -1){
            bw.write(chs,0,len);
        }


        br.close();
        bw.close();
    }
}

3.8 字符缓冲流的特有功能

BufferedWriter:

  • void newLine():写一个行分隔符，行分隔符字符串由系统属性定义

BufferedReader:

  • public String readLine():读一行文字。结果包含行的内容的字符串，不包括任何行终止符，如果流的结尾已经到达，则为null
package com.CharStream04;

import java.io.*;

/*
    字符缓冲流的特有功能：
        BufferedWriter:
            void newLine():写一行行分隔符，行分隔符字符串由系统属性定义
        BufferedReader:
            public String readLine();读一行文字。结果包含行的内容的字符串，不包括任何行终止符，如果流的结尾已经到达，则为null
 */
public class BufferedStreamDemo02 {
    public static void main(String[] args) throws IOException{
        /*
        //创建字符缓冲输出流
        BufferedWriter bw = new BufferedWriter(new FileWriter("myCharStream\\bw.txt"));
        //写数据
        for(int i=0;i<10;i++){
            bw.write("hello" + i);
//            bw.write("\r\n");//这种写法只适用于Windows系统
            bw.newLine();
            bw.flush();
        }

        bw.close();

         */
        //创建字符缓冲输入流对象
        BufferedReader br = new BufferedReader(new FileReader("myCharStream\\bw.txt"));
        //public String readLine();读一行文字。
        /*
        //第1次读取数据
        String line = br.readLine();
        System.out.println(line);

        //第2次读取数据
        line = br.readLine();
        System.out.println(line);

        //第3次读取数据
        line = br.readLine();
        System.out.println(line);

         */

        String line;
        while((line=br.readLine()) != null){
            System.out.println(line);
        }
        br.close();

    }
}
  • 案例（字符缓冲流特有功能改进版）
package com.CharStream04;

import java.io.*;

/*
    需求：
        把模块下的ConversionStreamDemo.java复制到模块目录下的Copy4.java
    思路：
        1.根据数据源创建字符缓冲输入流对象
        2.根据目的地创建字符缓冲输出流对象
        3.读写数据，复制文件
        4.释放资源
 */
public class CopyJavaDemo02 {
    public static void main(String[] args) throws IOException{
        //1.根据数据源创建字符缓冲输入流对象
        BufferedReader br = new BufferedReader(new FileReader("myCharStream\\ConversionStreamDemo.java"));
        //2.根据目的地创建字符缓冲输出流对象
        BufferedWriter bw = new BufferedWriter(new FileWriter("myCharStream\\copy4.java"));
        //3.读写数据，复制文件
        String line;
        while((line=br.readLine()) != null){
            bw.write(line);
            bw.newLine();
            bw.flush();
        }
        br.close();
        bw.close();
    }
}

3.9 IO 小结

在这里插入图片描述

小结：字节流可以复制任意文件数据，有4种方式，一般采用字节缓冲流一次读写一个字节数组的方式

在这里插入图片描述

小结：字符流只能复制文本数据，有5种方式，一般采用字符缓冲流的特有功能（一次读写一个字符串）。如果在字符流中涉及到编码问题的时候，只能使用 InputStreamReader 和 OutputStreamWriter。

3.10 案例：集合到文件

package com.CharStream05;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;

/*
    需求：
        把ArrayList集合中的字符串数据写入到文本文件
    要求：
        每一个字符串元素作为文件中的一行数据
    思路：
        1.创建ArrayList集合
        2.往集合中存储字符串元素
        3.创建字符缓冲输出流对象
        4.遍历集合，得到每一个字符串数据
        5.调用字符缓冲输出流对象的方法写数据
        6.释放资源
 */
public class ArrayListToTxtDemo {
    public static void main(String[] args) throws IOException {
        //1.创建ArrayList集合
        ArrayList<String> array = new ArrayList<String>();

        //2.往集合中存储字符串元素
        array.add("苦瓜");
        array.add("半仙儿");
        array.add("研");

        //3.创建字符缓冲输出流对象
        BufferedWriter bw = new BufferedWriter(new FileWriter("myCharStream\\array.txt"));

        //4.遍历集合，得到每一个字符串数据
        for(String s : array){
            //5.调用字符缓冲输出流对象的方法写数据
            bw.write(s);
            bw.newLine();
            bw.flush();
        }
        //6.释放资源
        bw.close();
    }
}

3.11 案例：文件到集合

package com.CharStream05;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;

/*
    需求：
        把文本文件中的数据读取到集合中，并遍历集合。
    要求：
        文件中每一行数据时一个集合元素
    思路：
        1.创建字符缓冲输入流对象
        2.创建ArrayList集合对象
        3.调用字符缓冲输入流对象的方法读取数据
        4.把读取到的字符串数据存储到集合中
        5.释放资源
        6.遍历集合
 */
public class TxtToArrayListDemo {
    public static void main(String[] args) throws IOException {
        //1.创建字符缓冲输入流对象
        BufferedReader br = new BufferedReader(new FileReader("myCharStream\\array.txt"));
        //2.创建ArrayList集合对象
        ArrayList<String> array = new ArrayList<String>();
        //3.调用字符缓冲输入流对象的方法读取数据
        String line;
        while((line = br.readLine()) != null){
            //4.把读取到的字符串数据存储到集合中
            array.add(line);
        }
        //5.释放资源
        br.close();
        //6.遍历集合
        for(String s : array){
            System.out.println(s);
        }
    }
}

3.12 案例：点名器

package com.CharStream05;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Random;

/*
    需求：
        一个文件里面存储了班级同学的姓名，每一个姓名占一行，要求通过程序实现随机点名器
    思路：
        1.创建字符缓冲输入流对象
        2.创建ArrayList集合对象
        3.调用字符缓冲输入流对象的方法读取数据
        4.将读取到的数据存储到集合中
        5.释放资源
        6.使用Random产生一个随机数，随机数的范围是[0,集合的长度)
        7.把第6步产生的随机数作为索引到ArrayList集合中去获取值
        8.把第7步得到的数据输出在控制台
 */
public class CallNameDemo {
    public static void main(String[] args) throws IOException {
        //1.创建字符缓冲输入流对象
        BufferedReader br = new BufferedReader(new FileReader("myCharStream\\names.txt"));

        //2.创建ArrayList集合对象
        ArrayList<String> array = new ArrayList<String>();

        //3.调用字符缓冲输入流对象的方法读取数据
        String line;
        while((line = br.readLine()) != null){
            //4.将读取到的数据存储到集合中
            array.add(line);
        }

        //5.释放资源
        br.close();

        //6.使用Random产生一个随机数，随机数的范围是:[0,集合的长度)
        Random random = new Random();
        int index = random.nextInt(array.size());

        //7.把第6步产生的随机数作为索引到ArrayList集合中去获取值
        String name = array.get(index);

        //8.把第7步得到的数据输出在控制台
        System.out.println("幸运者是：" + name);
    }
}

3.13 案例：集合到文件（改进版）

package com.CharStream06;

public class Student {
    private String id;
    private String name;
    private int age;
    private String address;
    public Student(){

    }

    public Student(String id, String name, int age, String address) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.address = address;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }
}


package com.CharStream06;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;

/*
    集合到文件（改进版）
    需求：
        把ArrayList集合中的学生数据写入到文本文件
    要求：
        每一个学生对象的数据作为文件中的一行数据
    格式：
        学号，姓名，年龄，居住地
    举例：
        18001，苦瓜，22，益阳
    思路：
        1.定义学生类
        2.创建ArrayList集合对象
        3.创建学生对象
        4.把学生对象添加到集合
        5.创建字符缓冲输出流对象
        6.遍历集合，得到每一个学生对象
        7.把学生对象的数据拼接成指定格式的字符串
        8.调用字符缓冲输出流对象的方法写数据
        9.释放资源
 */
public class ArrayListToFileDemo {
    public static void main(String[] args) throws IOException {
        //2.创建ArrayList集合对象
        ArrayList<Student> array = new ArrayList<Student>();

        //3.创建学生对象
        Student s1 = new Student("18001","苦瓜",22,"益阳");
        Student s2 = new Student("18002","半仙儿",23,"南京");
        Student s3 = new Student("18003","bug",25,"上海");

        //4.把学生对象添加到集合
        array.add(s1);
        array.add(s2);
        array.add(s3);

        //5.创建字符缓冲输出流对象
        BufferedWriter bw = new BufferedWriter(new FileWriter("myCharStream\\students.txt"));

        //6.遍历集合，得到每一个学生对象
        for(Student s : array){

            //7.把学生对象的数据拼接成指定格式的字符串
            StringBuilder sb = new StringBuilder();
            sb.append(s.getId()).append(",").append(s.getName()).append(",").append(s.getAge()).append(",").append(s.getAddress());

            //8.调用字符缓冲输出流对象的方法写数据
            bw.write(sb.toString());
            bw.newLine();
            bw.flush();
        }

        //9.释放资源
        bw.close();
    }
}

3.14 案例：文件到集合（改进版）

package com.CharStream06;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;

/*
    文件到集合（改进版）
    需求：
        把文本文件中的数据读取到集合中，并遍历集合
    要求：
        文件中每一行数据时一个学生对象的成员变量值
    格式：
        学号，姓名，年龄，居住地
    举例：
        18001，苦瓜，22，益阳
    思路；
        1.定义学生类
        2.创建字符缓冲输入流对象
        3.创建ArrayList集合对象
        4.调用字符缓冲输入流对象的方法读取数据
        5.把读取到的字符串数据用split()进行分割，得到一个字符串数组
        6.创建学生对象
        7.把字符串数组中的每一个元素取出来，对应的值赋值给学生对象的成员变量值
        8.把学生对象添加到集合
        9.释放资源
        10.遍历集合
 */
public class FileToArrayListDemo {
    public static void main(String[] args) throws IOException {
        //2.创建字符缓冲输入流对象
        BufferedReader br = new BufferedReader(new FileReader("myCharStream\\students.txt"));

        //3.创建ArrayList集合对象
        ArrayList<Student> array = new ArrayList<Student>();

        //4.调用字符缓冲输入流对象的方法读取数据
        String line;
        while ((line = br.readLine()) != null) {

            //5.把读取到的字符串数据用split()进行分割，得到一个字符串数组
            String[] student = line.split(",");

            //6.创建学生对象
            Student s = new Student();

            //7.把字符串数组中的每一个元素取出来的值赋值给学生对象的成员变量值
            s.setId(student[0]);
            s.setName(student[1]);
            s.setAge(Integer.parseInt(student[2]));
            s.setAddress(student[3]);

            //8.把学生对象添加到集合
            array.add(s);

        }
        //9.释放资源
        br.close();

        //10.遍历集合
        for(Student s : array){
            System.out.println(s.getId() + "," + s.getName() + "," + s.getAge() + "," + s.getAddress());
        }

    }
}

3.15 集合到文件（数据排序改进版）

package com.CharStream07;

public class Student {
    private String name;
    private int chinese;
    private int math;
    private int english;

    public Student() {
    }

    public Student(String name, int chinese, int math, int english) {
        this.name = name;
        this.chinese = chinese;
        this.math = math;
        this.english = english;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getChinese() {
        return chinese;
    }

    public void setChinese(int chinese) {
        this.chinese = chinese;
    }

    public int getMath() {
        return math;
    }

    public void setMath(int math) {
        this.math = math;
    }

    public int getEnglish() {
        return english;
    }

    public void setEnglish(int english) {
        this.english = english;
    }
    public int getSum(){
        return this.chinese + this.math + this.english;
    }
}


package com.CharStream07;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Comparator;
import java.util.Scanner;
import java.util.TreeSet;

/*
    集合到文件（数据排序改进版）
    需求：
        键盘录入3个学生信息（姓名，语文成绩，数学成绩，英语成绩）。
    要求:
        按照总成绩从高到低写入文本文件
    格式：
        姓名，语文成绩，数学成绩，英语成绩
    举例：
        苦瓜，94,95,96
    思路：
        1.定义学生类
        2.创建TreeSet集合，通过比较器排序进行排序
        3.键盘录入学生数据
        4.创建学生对象，把键盘录入的数据对应赋值给学生对象的成员变量
        5.把学生对象添加到TreeSet集合
        6.创建字符缓冲输出流对象
        7.遍历集合，得到每一个学生对象
        8.把学生对象的数据拼接成指定格式的字符串
        9.调用字符缓冲输出流对象的方法写数据
        10.释放资源
 */
public class TreeSetToFileDemo {
    public static void main(String[] args) throws IOException {
        //2.创建TreeSet集合，通过比较器排序进行排序
        TreeSet<Student> ts = new TreeSet<>(new Comparator<Student>() {
            @Override
            public int compare(Student s1, Student s2) {
                //主要条件：总分从高到低
                int num1 = s1.getSum() - s2.getSum();
                //次要条件(需要自己分析)
                int num2 = num1 == 0 ? s1.getChinese() - s2.getChinese() : num1;
                int num3 = num2 == 0 ? s1.getMath() - s2.getMath() : num2;
                int num4 = num3 == 0 ? s1.getEnglish() - s2.getEnglish() : num3;
                return num4;
            }
        });

        //3.键盘录入学生数据
        for (int i = 0; i < 3; i++) {
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入第" + (i + 1) + "个学生的信息");
            System.out.println("姓名：");
            String name = sc.nextLine();
            System.out.println("语文成绩：");
            int chinese = sc.nextInt();
            System.out.println("数学成绩：");
            int math = sc.nextInt();
            System.out.println("英语成绩：");
            int english = sc.nextInt();

            //4.创建学生对象，把键盘录入的数据对应赋值给学生对象的成员变量
            Student s = new Student();
            s.setName(name);
            s.setChinese(chinese);
            s.setMath(math);
            s.setEnglish(english);

            //5.把学生对象添加到TreeSet集合
            ts.add(s);
        }
        //6.创建字符缓冲输出流对象
        BufferedWriter bw = new BufferedWriter(new FileWriter("myCharStream\\ts.txt"));

        //7.遍历集合，得到每一个学生对象
        for (Student s : ts) {

            //8.把学生对象的数据拼接成指定格式的字符串
            StringBuilder sb = new StringBuilder();
            sb.append(s.getName()).append(",").append(s.getChinese()).append(",").append(s.getMath()).append(",").append(s.getEnglish()).append(",").append(s.getSum());

            //9.调用字符缓冲输出流对象的方法写数据
            bw.write(sb.toString());
            bw.newLine();
            bw.flush();
        }
        //10.释放资源
        bw.close();
    }
}

3.16 复制文件的异常处理

  1. try…catch…finally 的标准做法
    在这里插入图片描述

  2. JDK7的改进方案
    在这里插入图片描述

  3. JDK9的改进方案
    在这里插入图片描述

package com.CharStream08;

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

public class CopyDemo {
    public static void main(String[] args){

    }

    //抛出处理
    private static void method1() throws IOException {
        FileReader fr = new FileReader("fr.txt");
        FileWriter fw = new FileWriter("fw.txt");

        char[] chs = new char[1024];
        int len;
        while((len=fr.read(chs)) != -1){
            fw.write(chs,0,len);
        }
        fr.close();
        fw.close();
    }

    //try...catch...finally
    private static void method2(){
        FileReader fr = null;
        FileWriter fw = null;
        try{
            fr = new FileReader("fr.txt");
            fw = new FileWriter("fw.txt");

            char[] chs = new char[1024];
            int len;
            while((len=fr.read(chs)) != -1){
                fw.write(chs,0,len);
            }
        }catch(IOException e){
            e.printStackTrace();
        }finally{
            if(fr != null) {
                try {
                    fr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(fw != null) {
                try {
                    fw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    //JDK7改进方案
    private static void method3(){
        try(FileReader fr = new FileReader("fr.txt");
            FileWriter fw = new FileWriter("fw.txt");){
            char[] chs = new char[1024];
            int len;
            while((len=fr.read(chs)) != -1){
                fw.write(chs,0,len);
            }
        }catch (IOException e){
            e.printStackTrace();
        }
    }

    //JDK9改进方案
    /*
    private static void method4() throws IOException{
        FileReader fr = new FileReader("fr.txt");
        FileWriter fw = new FileWriter("fw.txt");
        try(fr;fw){
            char[] chs = new char[1024];
            int len;
            while((len=fr.read(chs)) != -1){
                fw.write(chs,0,len);
            }
        }catch (IOException e){
            e.printStackTrace();
        }
    }
    */
}

4.特殊操作流

4.1 标准输入输出流

  • System 类中有两个静态的成员变量：
    • public static final InputStream in: 标准输入流。通常该流对应于键盘输入或由主机环境或用户指定的另一个输入源
    • public static final PrintStream out: 标准输出流。通常该流对应于显示输出或由主机环境或用户指定的另一个输出目标
package OtherStream01;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.Scanner;

/*
    public static final InputStream in: 标准输入流。
    通常该流对应于键盘输入或由主机环境或用户指定的另一个输入源
 */
public class SystemInDemo01 {
    public static void main(String[] args) throws IOException {
        //public static final InputStream in: 标准输入流
        InputStream is = System.in;

        //读取的数据来自键盘输入
//        int by;
//        while((by=is.read()) != -1){
//            System.out.print((char)by);
//        }

        //使用转换流将字节流转换成字符流
//        InputStreamReader isr = new InputStreamReader(is);

        //将字符流包装成字符缓冲输入流
//        BufferedReader br = new BufferedReader(isr);

        //将上面3步换成1步完成
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        System.out.println("请输入一个字符串：");
        String line = br.readLine();
        System.out.println("你输入的字符串是：" + line);

        System.out.println("请输入一个整数：");
        int i = Integer.parseInt(br.readLine());
        System.out.println("你输入的整数是：" + i);

        //自己实现键盘录入数据太麻烦，所以Java就提供了一个类供我们使用
        Scanner sc = new Scanner(System.in);
        //Scanner底层也是包装的System.in
    }
}

  • 自己实现键盘录入数据：

    • BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

  • 自己写起来太麻烦，所有Java提供了一个类实现键盘录入

    • Scanner sc = new Scanner(System.in);`

  • 输出语句的本质：是一个标准的输出流

    • PrintStream ps = System.out;
    • PrintStream类有的方法，System.out都可以使用
package OtherStream01;

import java.io.PrintStream;

/*
    public static final PrintStream out: 标准输出流。
    通常该流对应于显示输出或由主机环境或用户指定的另一个输出目标
 */
public class SystemOutDemo01 {
    public static void main(String[] args){
        //public static final PrintStream out: 标准输出流
        PrintStream ps = System.out;

        //能够方便地打印各种数据值
//        ps.print("半仙儿");
//        ps.print(367);
//        ps.println("半仙儿");
//        ps.println(367);

        //将 ps 用 System.out 替换
        //System.out的本质是一个字节输出流
        System.out.println("半仙儿");
        System.out.println(367);

    }
}

4.2 打印流

  • 打印流分类

    • 字节打印流：PrintStream
    • 字符打印流：PrintWriter

  • 打印流特点：

    • 只负责输出数据，不负责读取数据
    • 有自己的特有方法

  • 字节打印流

    • PrintStream(String fileName):使用指定的文件名创建新的打印流
    • 使用继承父类的方法写数据，查看的时候回转码；使用自己的特有方法写数据，查看的数据原样输出
package OtherStream02;

import java.io.IOException;
import java.io.PrintStream;

/*
    打印流特点：
        只负责输出数据，不负责读取数据
        有自己的特有方法
    字节打印流
        PrintStream(String fileName):使用指定的文件名创建新的打印流
 */
public class PrintStreamDemo {
    public static void main(String[] args) throws IOException {
        //PrintStream(String fileName):使用指定的文件名创建新的打印流
        PrintStream ps = new PrintStream("myOtherStream\\ps.txt");

        //写数据
        //字节输出流有的方法
        ps.write(97); //输出: a

        //使用特有方法写数据
        ps.print(97);
        ps.println(98);
        ps.println(367);
        
        /*
            输出结果：
            a9798
            367
         */


        //释放资源
        ps.close();
    }
}
  • 字符打印流PrintWriter的构造方法
    在这里插入图片描述
package OtherStream02;

import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;

/*
    字符打印流的构造方法：
        PrintWriter(String fileName):使用指定的文件名创建一个新的PrintWriter，而不需要自动执行刷新

        PrintWriter(Writer out,boolean autoFlush):创建一个新的PrintWriter
            out：字符输出流
            autoFlush：一个布尔值，如果为真，则println,printf,或format方法将刷新输出缓冲区
 */
public class PrintWriterDemo {
    public static void main(String[] args) throws IOException {
        //PrintWriter(String fileName):使用指定的文件名创建一个新的PrintWriter，而不需要自动执行刷新
        PrintWriter pw = new PrintWriter("myOtherStream\\pw.txt");

//        pw.write("半仙儿");
//        pw.write("\r\n");
//        pw.write("苦瓜");
//        pw.write("\r\n");
//        pw.flush();

//        pw.println("苦瓜");
//        pw.println("半仙儿");
//        pw.flush();


        // PrintWriter(Writer out,boolean autoFlush):创建一个新的PrintWriter
        PrintWriter pw2 = new PrintWriter(new FileWriter("myOtherStream\\pw.txt"),true);
        pw2.println("hnist");
        pw2.println("njust");
    }
}

4.3 案例：复制Java文件（打印流改进版）

package OtherStream02;

import java.io.*;

/*
    需求：
        把模块目录下的PrintStreamDemo.java复制到模块目录下的Copy.java
    思路：
        1.根据数据源创建字符输入流对象
        2.根据目的地创建字符输出流对象
        3.读写数据，复制文件
        4.释放资源
 */
public class CopyJavaDemo {
    public static void main(String[] args) throws IOException {
       /*
       //1.根据数据源创建字符输入流对象
        BufferedReader br = new BufferedReader(new FileReader("myOtherStream\\PrintStreamDemo.java"));

        //2.根据目的地创建字符输出流对象
        BufferedWriter bw = new BufferedWriter(new FileWriter("myOtherStream\\Copy.java"));

        //3.读写数据，复制文件
        String line;
        while ((line = br.readLine()) != null) {
            bw.write(line);
            bw.newLine();
            bw.flush();
        }

        //4.释放资源
        br.close();
        bw.close();
        */

        //1.根据数据源创建字符输入流对象
        BufferedReader br = new BufferedReader(new FileReader("myOtherStream\\PrintStreamDemo.java"));
        //2.根据目的地创建字符输出流对象
        PrintWriter pw = new PrintWriter(new FileWriter("myOtherStream\\Copy.java"),true);
        //3.读写数据，复制文件
        String line;
        while((line=br.readLine()) != null){
            pw.println(line);
        }
        //4.释放资源
        br.close();
        pw.close();
    }
}

4.4 对象序列化流

对象序列化：就是将对象保存到磁盘中，或者在网络中传输对象
这种机制就是使用一个字节序列表示一个对象，该字节序列包含：对象的类型，对象的数据和对象中存储的属性等信息
字节序列写到文件以后，相当于文件中持久保存了一个对象的信息
反之，该字节序列还可以从文件中读取出来，重构对象，对它进行 反序列化

要实现序列化和反序列化就要使用 对象序列化流 和 对象反序列化流 ：

  • 对象序列化流：ObjectOutputStream
  • 对象反序列化流：ObjectInputStream

对象序列化流：ObjectOutputStream

  • 将Java对象的原始数据类型和图形写入OutputStream。可以使用ObjectInputStream读取（重构）对象。可以通过使用流的文件来实现对象的持久存储。如果流是网络套接字流，则可以在另一个主机或另一个进程中重构对象

构造方法：

  • ObjectOutputStream(OutputStream out):创建一个写入指定OutputStream的ObjectOutputStream

序列化对象的方法：

  • void writeObject(Object obj): 将指定的对象写入ObjectOutputStream
package OtherStream03;

import java.io.Serializable;

public class Student implements Serializable {
    private String name;
    private int age;
    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}


package OtherStream03;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;

/*
    对象序列化流
    构造方法：
        ObjectOutputStream(OutputStream out):创建一个写入指定OutputStream的ObjectOutputStream
    序列化对象的方法：
        void writeObject(Object obj): 将指定的对象写入ObjectOutputStream
    NotSerializableException:抛出一个实例需要一个Serializable接口。序列化运行时或实例的可能会抛出此异常

    类的序列化由实现java.io.Serializable接口的类启用。不实现此接口的类将不会使任何状态序列化或反序列化
 */
public class ObjectOutputStreamDemo {
    public static void main(String[] args) throws IOException {
        //ObjectOutputStream(OutputStream out):创建一个写入指定OutputStream的ObjectOutputStream
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("myOtherStream\\oos.txt"));

        //创建对象
        Student s = new Student("苦瓜",22);

        //void writeObject(Object obj): 将指定的对象写入ObjectOutputStream
        oos.writeObject(s);

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

在这里插入图片描述

注意：

  • 一个对象要想被序列化，该对象所属的类必须实现 Serializable 接口
  • Serializable 是一个 标记接口 ，实现该接口，不需要重写任何方法

对象反序列化流：ObjectInputStream

  • ObjectInputStream反序列化先前使用ObjectOutputStream编写的原始数据和对象

构造方法：

  • ObjectInputStream(InputStream in): 创建从指定的InputStream读取的ObjectInputStream

反序列化对象的方法：

  • Object readObject(): 从ObjectInputStream读取一个对象
package OtherStream03;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;

/*
    对象反序列化流
    构造方法：
        ObjectInputStream(InputStream in): 创建从指定的InputStream读取的ObjectInputStream
    反序列化对象的方法：
        Object readObject(): 从ObjectInputStream读取一个对象
 */
public class ObjectInputStreamDemo {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //ObjectInputStream(InputStream in): 创建从指定的InputStream读取的ObjectInputStream
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("myOtherStream\\oos.txt"));

        //Object readObject(): 从ObjectInputStream读取一个对象
        Object obj = ois.readObject();

        //向下转型
        Student s = (Student)obj;
        System.out.println(s.getName() + "," + s.getAge());

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

对象序列化中的3个问题：

  1. 用对象序列化流序列化了一个对象后，如果修改了对象所属的类文件，读取数据会不会出现问题？
  • 会出问题，抛出 InvalidClassException 异常
  1. 如果出现了问题，如何解决？
  • 给对象所属的类加一个 serialVersionUID
    private static final long serialVersionUID = 42L;
  1. 如果一个对象中的某个成员变量的值不想被序列化，该如何实现？
  • 给该成员变量添加 transient 修饰，该关键字标记的成员变量不参与序列化过程

4.5 Properties

Properties 概述

  • 是一个map体系的集合类
  • Properties可以保存到流中或从流中加载
package OtherStream04;

import java.util.Properties;
import java.util.Set;

/*
    Properties作为Map集合的使用
 */
public class PropertiesDemo01 {
    public static void main(String[] args){
        //创建集合对象
        Properties prop = new Properties();
        //存储元素
        prop.put("18001","苦瓜");
        prop.put("18002","半仙儿");
        prop.put("18003","bug");
        //遍历集合
        Set<Object> keySet = prop.keySet();
        for(Object key : keySet){
            Object value = prop.get(key);
            System.out.println(key + "," + value);
        }
    }
}

Properties 作为集合的特有方法：
在这里插入图片描述

package OtherStream04;

import java.util.Properties;
import java.util.Set;

/*
    Properties作为集合的特有方法：
        Object setProperty(String key,String value):设置集合的键和值，都是String类型，底层调用Hashtable方法put
        String getProperty(String key):使用此属性列表中指定的键搜索属性
        Set<String> stringPropertyNames():从该属性列表中返回一个不可修改的键集，其中键及其对应的值是字符串
 */
public class PropertiesDemo02 {
    public static void main(String[] args){
        //创建集合对象
        Properties prop = new Properties();

        //Object setProperty(String key,String value):设置集合的键和值，都是String类型，底层调用Hashtable方法put
        prop.setProperty("苦瓜","hnist");
        prop.setProperty("半仙儿","njust");
        prop.setProperty("bug","njust");

        //String getProperty(String key):使用此属性列表中指定的键搜索属性
        System.out.println(prop.getProperty("半仙儿"));
        System.out.println(prop);

        //Set<String> stringPropertyNames():从该属性列表中返回一个不可修改的键集，其中键及其对应的值是字符串
        Set<String> names = prop.stringPropertyNames();
        for(String key : names){
            String value = prop.getProperty(key);
            System.out.println(key + "," + value);
        }
    }
}

Properties 和 IO 流结合的方法：
在这里插入图片描述

package OtherStream04;

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Properties;
import java.util.Set;

/*
    Properties和IO流结合的方法：
        void load(Reader reader):
            从输入字符流读取属性列表（键和元素对）
        void store(Writer writer,String comments):
            将此属性列表（键和元素对）写入此Properties表中，
            以适合使用load(Reader)方法的格式写入输出字符流
 */
public class PropertiesDemo03 {
    public static void main(String[] args) throws IOException{
        //把集合中的数据保存到文件
        myStore();

        //把文件中的数据加载到集合
        myLoad();
    }

    private static void myLoad() throws IOException{
        Properties prop = new Properties();
        //void load(Reader reader)
        FileReader fr = new FileReader("myOtherStream\\fw.txt");
        prop.load(fr);
        fr.close();
        System.out.println(prop);
    }

    private static void myStore() throws IOException {
        Properties prop = new Properties();

        prop.setProperty("苦瓜","hnist");
        prop.setProperty("半仙儿","njust");
        prop.setProperty("bug","njust");

        //void store(Writer writer,String comments)
        FileWriter fw = new FileWriter("myOtherStream\\fw.txt");
        prop.store(fw,null);
        fw.close();
    }
}

4.6 猜数字小游戏

game.txt
在这里插入图片描述

package OtherStream04;

import java.util.Random;
import java.util.Scanner;

/*
    猜数字小游戏
 */
public class GuessNumber {
    private GuessNumber(){

    }
    public static void play(){
        Random r = new Random();
        int number = r.nextInt(100) + 1;
        while(true){
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入你要猜的数字：");
            int guessNumber = sc.nextInt();
            if(guessNumber > number){
                System.out.println("你猜的数字大了");
            }else if(guessNumber < number){
                System.out.println("你猜的数字小了");
            }else{
                System.out.println("恭喜你猜中了");
                break;
            }
        }
    }
}


package OtherStream04;

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Properties;

/*
    需求：
        编写程序实现猜数字小游戏，只能试玩3次，如果还想玩，提示“余额不足，请先充值！”
    思路：
        1.写一个游戏类
        2.写一个测试类，测试类中main()方法按下面步骤完成
            A:从文件中读取数据到Properties集合，用load()方法实现
                文件已存在：game.txt
                文件里有一个数据值:count=0(注意这是键值对)
            B:通过Properties集合获取到玩游戏的次数
            C:判断次数是否达到3次
                如果到了，提示“余额不足，请先充值！”
                如果不到3次
                    玩游戏
                    次数+1，重新写回文件，用Properties的store()方法实现
 */
public class PropertiesTest {
    public static void main(String[] args) throws IOException {
        //A:从文件中读取数据到Properties集合，用load()方法实现
        Properties prop = new Properties();
        FileReader fr = new FileReader("myOtherStream\\game.txt");
        prop.load(fr);
        fr.close();

        //B:通过Properties集合获取到玩游戏的次数
        String count = prop.getProperty("count");
        int number = Integer.parseInt(count);

        //C:判断次数是否达到3次
        if(number >= 3){
            System.out.println("余额不足，请先充值！");
        }else{
            GuessNumber.play();
            number++;
            prop.setProperty("count",String.valueOf(number));
            FileWriter fw = new FileWriter("myOtherStream\\game.txt");
            prop.store(fw,null);
            fw.close();
        }
    }
}
苦瓜bug
关注
专栏目录
JavaSE IO流概述
Lv Zejiang
08-31 375
Java自我学习路线一、什么是IO二、IO流的分类三、四大Java IO流四、java.io包下16个掌握的流 一、什么是IO I : Input O : Output 通过IO可以完成硬盘文件的读和写 二、IO流的分类 一种方式是按照流的方向进行分类： 以内存作为参照物 往内存中去，叫做输入(Input)，或者叫做读(Read)，是输入流（InputStream） 从内存中出来，叫做输出(Output)，或者叫做写(Write)，是输出流（OutputStream） 一种方式是按照读取数据方式不同进
javaSE------5.IO流
L15122698902的博客
04-06 1075
1.File 类 1.1 File类概述和构造方法 File 类介绍： 它是文件和目录路径名的抽象表示 文件和目录是可以通过 File封装成对象的 对于 File而言，其封装的并不是一个真正存在的文件，仅仅是一个路径名而已。 它可以是存在的，也可以是不存在的。将来是要通过具体的操作把这个路径的内容转换为具体存在的 File 类的构造方法： File(String pathname) 通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例 File(String parent, String
JavaSE基础笔记——IO流2：缓冲流；转换流；序列化与反序列化对象；打印流；补充知识：Properties、IO框架
weixin_62993347的博客
08-21 801
缓冲流：概述、字节缓冲流作用、性能分析、字符缓冲流；转换流：字符输入转换流、字符输出转换流；序列化与反序列化对象；打印流：printStream、PrintWriter、输出语句的重定向；补充知识：Properties、IO框架
javaSE（5）IO流
weixin_43230682的博客
07-19 548
目录 ## 5. IO流 ### 5.1 File类 #### 5.1.1 文件对象的构造 #### 5.1.2 文件和文件夹的常用方法 #### 5.1.3 文件过滤器 ### 5.2 流的分类 ### 5.3 字节流 ### 5.4 字符流 ### 5.5 转换流 ### 5.6 缓冲流 ### 5.7 序列化和反序列化流 ### 5.8 标准输入输出流 ### 5.9 打印流 ### 5.10 Properties类 ### 5.11 NIO和NIO.2 ## 5...
Javase IO流小总结
m0_60439135的博客
01-29 486
Javase IO流小总结
【JavaSE】IO流
最新发布
m0_64098804的博客
03-19 807
【学习记录】Java后端路线，Java核心语法，关于IO的那些事儿。
JavaSE IO流 Vol.1 基础 入门
ke1494057235的博客
04-12 296
JavaSE IO流 Vol.1 基础 入门
JavaSE IO流体系分类
Hilary_Wilson的博客
04-23 199
IO流体系及其分类 IO流体系分类 1.体系 2.分类 2.1按流向分： 2.2按数据类型分： 由于InputStream、OutputStream、Reander、Writer等都是抽象类，无法创建对象，所以我们会使用他们的子类来创建对象。
JavaSE IO流day14
呆呆小哥的秘密基地
08-21 87
JavaSE IO流day14 第一章 缓冲流 1.1 概述 1.2字节缓冲流 ：BufferedInputStream , BufferedOutputStream 1.3 字符缓冲流 ： BufferedReader , BufferedWriter [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8et3OrHV-1597999067830)()] 1.4 文本排序 第二章 转换流 2.1 转换流原理 2.2 OutputStreamWriter类
JAVASE，IO流部分模块导图
01-13
Java SE的IO流部分是Java编程中的重要模块，主要用于数据的输入输出操作。IO流分为字节流（Byte Stream）和字符流（Character Stream），两者分别处理字节数据和字符数据。 1. 字节流： - **字节输入流...
JavaSe基于IO流的用户管理系统
02-19
本项目"JavaSe基于IO流的用户管理系统"就是利用Java的IO流技术来处理文本数据，实现用户信息的存储与管理。这个系统尤其适合大学生作为大作业或课程设计的实践项目，因为它的设计既简单易懂，又包含了Java 8的新特性...
JavaSE文件IO流详解.pptx
06-08
JavaSE文件IO流详解
JavaSE专题-IO流重点总结(必读).doc
06-03
Java SE专题中的IO流是Java编程中非常重要的一个部分，主要用于数据的输入和输出操作。在Java中，异常处理是程序稳定性和健壮性的重要保障。对于IO流操作，异常处理通常采用`try-catch-finally`结构。当在`try`块中...
JavaSE 方法
苦瓜的博客
10-31 3974
JavaSE 方法方法概述方法的定义方法的定义和调用方法的定义方法的调用带参数方法的定义和调用带参数方法定义带参数方法的调用带返回值带返回值方法的定义和调用方法的注意事项方法重载方法的参数传递 方法概述 方法的定义 方法 是将具有独立功能的 代码块 组织成为一个整体，使其具有特殊功能的 代码集。 注意： 方法必须先创建才可以使用，该过程称为 方法定义。 方法创建后并不是直接运行的，需要手动使用后才执行，该过程称为 方法调用。 方法的定义和调用 方法的定义 格式： public static void
JavaSE 面向对象基础
苦瓜的博客
11-06 2972
JavaSE类和对象对象内存图成员变量和局部变量封装构造方法 类和对象 对象内存图 成员变量和局部变量 封装 构造方法
JavaSE运算符
苦瓜的博客
10-28 2406
运算符算术运算符运算符和表达式算术运算符字符的 " + " 操作字符串的 " + " 操作赋值运算符赋值运算符自增自减运算符自增自减运算符关系运算符逻辑运算符三元运算符 算术运算符 运算符和表达式 运算符：对常量或者变量进行操作的符号。 表达式：用运算符把常量或者变量连接起来符合Java语法的式子称为表达式。不同运算符连接的表达式体现的是不同类型的表达式。 算术运算符 加（＋） 减（－） 乘（×） 除（/） 取余（%） int a = 6; int b = 4; System.out.println
JavaSE基础语法
苦瓜的博客
10-27 2153
基础语法注释注释概述注释分类关键字关键字概述关键字特点常量常量的概述常量的分类数据类型计算机存储单元数据类型变量标识符类型转换 注释 注释概述 注释是在程序指定位置添加的说明性信息 注释不参与程序运行，仅起到说明作用 注释分类 单行注释 格式：//注释信息 多行注释 格式：/* 注释信息 */ 文档注释 格式：/** 注释信息 */ 关键字 关键字概述 关键字：关键字就是被Java语言赋予了特定含义的单词 关键字特点 关键字的字母全部小写 常用的代码编辑器，对关键字有特殊的颜色标记，非常直观 常
JavaSE 形参和返回值（引用类型）
苦瓜的博客
11-28 2145
JavaSE 形参和返回值形参和返回值类名作为形参和返回值 形参和返回值 类名作为形参和返回值
JavaSE 继承
苦瓜的博客
11-12 1883
JavaSE 继承继承继承概述继承的好处与弊端继承中变量的访问特点super 关键字继承中构造方法的访问特点继承中成员方法的访问特点方法重写 继承 继承概述 继承是面向对象三大特征之一。可以使得子类拥有父类的属性和方法，还可以在子类中重新定义、追加属性和方法。 继承的格式 格式：public class 子类名 extends 父类名 { } 范例：public class Zi extends Fu { } Fu ：父类，也称为基类、超类 Zi：子类，也称为派生类 继承中子类的特点： 子类可以有父类
JavaSE基础精粹：从IO流到Lambda表达式
本压缩包内的文档详细讲解了Java中的IO流、多线程、网络编程和Lambda表达式等高级特性。以下是各个知识点的详细解析： 1. Java基础知识点查漏补缺.pdf： Java基础知识点是学习Java语言的根基，包括变量、数据类型、...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值