JavaIO流_接口返回的byte[]-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_65508929/article/details/127475778

文章目录

文件

文件是保存数据的地方，比如大家经常使用的word文档、txt文件、excel文件等等都是文件。它既可以保存一张照片，也可以保存视频，声音

文件流

文件在程序中是以流的形式来操作的

流：数据在数据源(文件)和程序(内存)之间经历的路径

输入流：数据从数据源(文件)到程序(内存)的路径

输出流：数据从程序(内存)到数据源(文件)的路径

常用的文件操作

创建文件对象相关构造器和方法

相关方法 - 用createNewFile创建新文件

new File(String pathname) //根据路径构建一个File对象

package com.zanedu.file;

import org.junit.jupiter.api.Test;

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

//演示创建文件
public class FineCreate {
    public static void main(String[] args) {

    }

    //方式一 new File(String pathname)
    @Test
    public void create01() {
        String filePath = "F:\\Java\\code\\news1.txt";
        File file = new File(filePath);

        try {
            file.createNewFile();
            System.out.println("文件创建成功");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

new File(File parent, String child) //根据父目录文件 + 子路径构建

package com.zanedu.file;

import org.junit.jupiter.api.Test;

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

//演示创建文件
public class FineCreate {
    public static void main(String[] args) {

    }

    //方式二 new File(File parent, String child) //根据父目录文件 + 子路径创建
    //F:\Java\code\news2.txt
    @Test
    public void create02() {
        File parentFile = new File("F:\\");
        String fileName = "Java\\code\\news2.txt";
        //这里的file对象，在Java程序中，只是一个对象
        //只有执行了 createNewFile方法，才会真正的在磁盘创建该文件
        File file = new File(parentFile, fileName);

        try {
            file.createNewFile();
            System.out.println("创建成功");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

new File(String parent, String child) //根据父目录 + 子路径构建

package com.zanedu.file;

import org.junit.jupiter.api.Test;

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

//演示创建文件
public class FineCreate {
    public static void main(String[] args) {

    }

   	//方式三 new File(String parent, String child) //根据父目录 + 子路径创建
    @Test
    public void create03() {
        String parentPath = "F:\\";
        String filePath = "Java\\code\\news3.txt";
        File file = new File(parentPath, filePath);
        try {
            file.createNewFile();
            System.out.println("创建成功~~~");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

获取文件的相关信息

package com.zanedu.file;

import org.junit.jupiter.api.Test;

import java.io.File;

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

    }

    //获取文件的信息
    @Test
    public void info() {
        //先创建文件对象
        File file = new File("F:\\Java\\code\\news2.txt");

        //调用相应的方法，得到对应信息
        System.out.println("文件名字=" + file.getName());
        System.out.println("绝对路径=" + file.getAbsolutePath());
        System.out.println("文件父级目录=" + file.getParent());
        System.out.println("文件大小(字节)=" + file.length());
        System.out.println("文件是否存在=" + file.exists());//T
        System.out.println("是不是一个文件=" + file.isFile());//T
        System.out.println("是不是一个目录=" + file.isDirectory());//F
    }
}

目录的操作和文件删除

mkdir() 创建一级目录

mkdirs() 创建多级目录

delete 删除空目录或文件

package com.zanedu.file;

import org.junit.jupiter.api.Test;

import java.io.File;

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

    }

    //判断 F:\Java\code\news1.txt 是否存在，如果存在就删除
    @Test
    public void m1() {
        String filePath = "F:\\Java\\code\\news1.txt";
        File file = new File(filePath);
        if (file.exists()) {
            if (file.delete()) {
                System.out.println(filePath + "删除成功");
            } else {
                System.out.println(filePath + "删除失败");
            }
        } else {
            System.out.println("该文件不存在");
        }
    }

    //判断 F:\Java\code\demo100 是否存在，存在就删除，否则提示不存在
    //这里我们需要体会到，在Java编程中，目录也被当作文件
    @Test
    public void m2() {
        String filePath = "F:\\Java\\code\\demo100";
        File file = new File(filePath);
        if (file.exists()) {
            if (file.delete()) {
                System.out.println(filePath + "删除成功");
            } else {
                System.out.println(filePath + "删除失败");
            }
        } else {
            System.out.println("该目录不存在");
        }
    }

    //判断 F:\Java\code\demo\a\b\c 目录是否存在，如果存在就提示已经存在，否则就创建
    @Test
    public void m3() {
        String directoryPath = "F:\\Java\\code\\demo\\a\\b\\c";
        File file = new File(directoryPath);
        if (file.exists()) {
            System.out.println(directoryPath + "该目录存在");
        } else {
            //没有就创建
            if (file.mkdirs()) { //创建一级目录使用mkdir()，创建多级目录使用mkdirs()
                System.out.println(directoryPath + "该目录创建成功");
            } else {
                System.out.println(directoryPath + "该目录没有创建成功，创建失败");
            }
        }
    }
}

IO流原理及流的分类

Java IO流原理

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

流的分类

**按操作数据单位不同分为：**字节流(8 bit) 二进制文件，字符流(按字符)文本文件

字节流适合二进制文件，字符流适合文本文件，就好比一个文件中有汉字，而在UTF-8的编码下，占3个字节，而字节流每次只能取出1个字节，因此就会报乱码。而字符流的效率高些

按数据流的流向不同分为：输入流、输出流
按流的角色的不同分为：节点流，处理流/包装流

(抽象基类)[顶级父类]	字节流	字符流
输入流	InputStream	Reader
输出流	OutputStream	Writer

Java的IO流共涉及40多个类，实际上非常规则，都是由如上4个抽象基类派生的
由这四个类派生出来的子类名称都是****以其父类名作为子类名后缀

IO流体系图-常用的类

IO流体系图

文件 VS 流

FileInputStream介绍

基本介绍

应用实例

需求：请使用FileInputStream读取hello.txt文件，并将文件内容显示到控制台

package com.zanedu.inputstream_;

import org.junit.jupiter.api.Test;

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

//演示FileInputStream的使用（字节输入流 文件 -> 程序）
public class FileInputStream_ {
    public static void main(String[] args) {

    }

    /*
    演示读取文件
    单个字节的读取，效率比较低
    优化：使用 read(byte[] b)
     */
    @Test
    public void readFile01() {
        String filePath = "F:\\Java\\code\\hello.txt";
        int readData = 0;
        FileInputStream fileInputStream = null;

        try {
            //创建 FileInputStream 对象，用于读取文件
            fileInputStream = new FileInputStream(filePath);

            //从该输入流读取一个字节的数据，如果没有输入可用，此方法将阻止
            //如果返回 -1，表示读取完毕
            //read()每次只能读取一个字节
            while ((readData = fileInputStream.read()) != -1) {
                System.out.print((char)readData); //转成char显示
            }

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //关闭文件流，释放资源
            try {
                fileInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /*
    使用 read(byte[] b) 读取文件，提高效率
     */
    @Test
    public void readFile02() {
        String filePath = "F:\\Java\\code\\hello.txt";

        //字节数组
        byte[] buffer = new byte[8]; //一次读取8个字节
        int readLen = 0;

        FileInputStream fileInputStream = null;

        try {
            //创建 FileInputStream 对象，用于读取文件
            fileInputStream = new FileInputStream(filePath);

            //从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中。在某些输入可用之前，此方法将阻塞
            //如果返回 -1，表示读取完毕
            //如果读取正确，返回实际读取的字节数
            while ((readLen = fileInputStream.read(buffer)) != -1) {
                System.out.print(new String(buffer, 0, readLen)); //显示
            }

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //关闭文件流，释放资源
            try {
                fileInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

当我在hello.txt文档中写入汉字，由于是UTF-8编码，占3个字节，就会产生乱码

FileOutputStream介绍

基本介绍

应用实例

**需求：请使用FileOutputStream在a.txt文件中写入"hello, world"，**如果文件不存在，会创建文件

package com.zanedu.outputstream_;

import org.junit.jupiter.api.Test;

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

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

    }

    /**
     * 演示使用FileOutputStream 将数据写到文件中
     * 如果该文件不存在，则创建该文件
     */
    @Test
    public void write() {
        //先创建 FileOutputStream对象
        String filePath = "F:\\Java\\code\\a.txt";
        FileOutputStream fileOutputStream = null;

        try {
            //得到 FileOutputStream
            /**
             * 说明：
             * 1. new FileOutputStream(filePath) 创建方式是 当写入内容时，会覆盖原来的内容
             * 2. new FileOutputStream(filePath, true) 创建方式是 当写入内容时，会追加到文件的最后
             */
//            fileOutputStream = new FileOutputStream(filePath);
            fileOutputStream = new FileOutputStream(filePath, true);
            //1. 写入一个字节
//            fileOutputStream.write('Z');//char -> int
            //2. 写入一个字符串
            String str = "hello,world";
            //str.getBytes() 可以把 字符串 -> 字符数组
//            fileOutputStream.write(str.getBytes());
            /*
              3. write(byte[] b, int off, int len) 将 len字节从位于偏移量 off的指定字节数组
                                 从 off 的位置写入 len 长度的数组
             */
//            fileOutputStream.write(str.getBytes(), 0, str.length());//等价于 fileOutputStream.write(str.getBytes());
            fileOutputStream.write(str.getBytes(), 0, 3);

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                //关闭文件流
                fileOutputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

写入字符串 - write(byte[] b)

创建一个流，将其改成true，会追加，而不是覆盖

应用实例2
需求：编程完成图片/音乐的拷贝

package com.zanedu.outputstream_;

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

public class FileCopy {
    public static void main(String[] args) {
        //完成文件拷贝，将 "F:\\Java\\code\\bg.png" 拷贝到 E:\\
        /*
        思路分析
        1. 创建文件的输入流，将文件读入到程序
        2. 创建文件的输出流，将读取到的文件数据写入到指定的位置
         */

        String srcPath = "F:\\Java\\code\\bg.png";
        String destPath = "E:\\bg.png";
        FileInputStream fileInputStream = null;
        FileOutputStream fileOutputStream = null;

        try {
            fileInputStream = new FileInputStream(srcPath);
            fileOutputStream = new FileOutputStream(destPath);
            //定义一个字节数组，提高读取效率
            byte[] buf = new byte[1024];
            int readLen = 0;
            while ((readLen = fileInputStream.read(buf)) != -1) {
                //读取到后，就写入到文件，通过 fileOutputStream
                //即：边读边写
                fileOutputStream.write(buf, 0, readLen);//一定要使用这个方法
            }
            System.out.println("拷贝ok~");

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //关闭输入流和输出流，释放资源
            try {
                if (fileInputStream != null) {
                    fileInputStream.close();
                }
                if (fileOutputStream != null) {
                    fileOutputStream.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}

FileReader 和 FileWriter介绍

FileReader相关方法

new FileReader(File/String)
read：每次读取单个字符，返回该字符，如果到文件末尾返回-1
read(char[])：批量读取多个字符到数组，返回读取到的字符数，如果到文件末尾返回-1

相关API：

1）new String(char[]) : 将char[]转换成String

2）new String(char[], off, len) : 将char[]的指定部分转换成String

FileReader应用实例

需求：从story.txt读取内容，并显示

package com.zanedu.reader_;

import org.junit.jupiter.api.Test;

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

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

    }

    /**
     * 单个字符读取文件
     */
    @Test
    public void readFile01() {
        String filePath = "F:\\Java\\code\\story.txt";
        FileReader fileReader = null;
        int data = ' ';
        //1. 创建一个FileReader对象
        try {
            fileReader = new FileReader(filePath);
            //循环读取 - 使用read
            while ((data = fileReader.read()) != -1) {
                System.out.print((char)data);
            }

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

    /**
     * 使用字符数组读取文件
     */
    @Test
    public void readFile02() {
        System.out.println("~~~readFile02~~~");
        String filePath = "F:\\Java\\code\\story.txt";
        FileReader fileReader = null;
        int readLen = 0;
        char[] buf = new char[8];
        //1. 创建一个FileReader对象
        try {
            fileReader = new FileReader(filePath);
            //循环读取 - 使用read(buf)，返回的是实际读取到的字符数
            //如果返回-1，说明到文件结束
            while ((readLen = fileReader.read(buf)) != -1) {
                System.out.print(new String(buf, 0, readLen));
            }

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

FileWriter常用方法

new FileWriter(File/String)：覆盖模式，相当于流的指针在首端
new FileWriter(File/String, true)：追加模式，相当于流的指针在尾端
write(int)：写入单个字符
write(char[])：写入指定数组
write(char[], off, len)：写入指定数组的指定部分
write(String)：写入整个字符串
write(String, off, len)：写入字符串的指定部分

相关API：String类，toCharArray：将String转换成char[]

**注意：**FileWriter使用后，必须要关闭(close)或刷新(flush)，否则写入不到指定的文件

FileWriter应用实例

需求：使用FileWriter将"风雨之后，定见彩虹"，写入到note.txt文件中

package com.zanedu.writer_;

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

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

        String filePath = "F:\\Java\\code\\note.txt";
        //创建FileWriter对象
        FileWriter fileWriter = null;
        char[] chars = {'a', 'b', 'c'};

        try {
            fileWriter = new FileWriter(filePath);
            //3. write(int)：写入单个字符
            fileWriter.write('H');
            //4. write(char[])：写入指定数组
            fileWriter.write(chars);
            //5. write(char[], off, len)：写入指定数组的指定部分
            fileWriter.write("老张教育".toCharArray(), 0, 3);
            //6. write(string)：写入整个字符串
            fileWriter.write(" 你好，老张教育~");
            fileWriter.write("风雨之后，定见彩虹");
            //7. write(string, off, len)：写入字符串的指定部分
            fileWriter.write("上海、天津", 0, 2);
            //在数据量大的情况下，可以使用循环操作



        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //对于FileWriter，一定要关闭流，或者flush，才能真正的把数据写入到文件
            //如果不关闭文件流，就会使得数据采集不进去，即H不会写入到write 文件中
            //看源码，知原因
            /*
            private void writeBytes() throws IOException {
                this.bb.flip();
                int var1 = this.bb.limit();
                int var2 = this.bb.position();

                assert var2 <= var1;

                int var3 = var2 <= var1 ? var1 - var2 : 0;
                if (var3 > 0) {
                    if (this.ch != null) {
                        assert this.ch.write(this.bb) == var3 : var3;
                    } else {
                        this.out.write(this.bb.array(), this.bb.arrayOffset() + var2, var3);
                    }
                }

                this.bb.clear();
            }
             */
            try {
                fileWriter.flush();
                //关闭文件流，等价 flush() + 关闭
//                fileWriter.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        System.out.println("程序结束");
    }
}

没有关闭文件流的情况 - 文件里不会有数据

节点流和处理流

基本介绍

节点流可以从一个特定的数据源读取数据，如FileReader、FileWriter

数据源就是存放数据的地方

处理流(包装流)是"连接"在已存在的流(节点流或处理流)之上，为程序提供更为强大的读写功能，也更加灵活。如BufferedReader、BufferedWriter

即可以对文件、数组、管道、字符串进行封装

以BufferedReader为例
BufferedReader有一个属性，Reader，即可以含有/封装一个节点流（只要是Reader的子类就可以）可以是任意的节点流

节点流和处理流一览图

节点流和处理流的区别和联系

节点流是底层流/低级流，直接跟数据源相接
处理流(包装流)包装节点流，既可以消除不同节点流的实现差异，也可以提供更方便的方法来完成输入输出
处理流(包装流)对节点流进行包装，使用了修饰器设计模式，不能直接与数据源相连[模拟修饰器设计模式]

模拟修饰器设计模式

package com.zanedu;

public abstract class Reader_ { //抽象类
    public void readFile() {
    }
    public void readString() {
    }

    //在Reader_ 抽象类，用read方法统一管理
    //后面在调用时，利用对象的动态绑定机制，来绑定要对应的实现即可
//    public abstract void read();
}
package com.zanedu;

//节点流
public class FileReader_ extends Reader_ {

    public void readFile() {
        System.out.println("对文件进行读取...");
    }

//    public void read() {
//
//    }
}
package com.zanedu;

//节点流
public class StringReader_ extends Reader_{

    public void readString() {
        System.out.println("读取字符串...");
    }
}
package com.zanedu;

//做成处理流（包装流）
public class BufferedReader_ extends Reader_{
    private Reader_ reader_;//属性是 Reader_ 类型

    //可以接受 Reader_ 的子类对象
    public BufferedReader_(Reader_ reader_) {
        this.reader_ = reader_;
    }

    public void readFile() { //封装一层
        reader_.readFile();
        reader_.readString();
    }

    //让方法更加灵活，多次读取文件，或者加缓冲 char[] ...
    public void readFiles(int num) {
        for (int i = 0; i < num; i++) {
            reader_.readFile();
        }
    }

    //扩展 readString，批量处理字符串数据
    public void readStrings(int num) {
        for (int i = 0; i < num; i++) {
            reader_.readString();
        }
    }
}
package com.zanedu;

public class Test {
    public static void main(String[] args) {
        BufferedReader_ bufferedReader_ = new BufferedReader_(new FileReader_());
//        bufferedReader_.readFiles(10);//读多次
        bufferedReader_.readFile();

        //这次希望通过 BufferedReader_ 多次读取字符串
        BufferedReader_ bufferedReader_1 = new BufferedReader_(new StringReader_());
        bufferedReader_1.readStrings(5);
    }
}

处理流的功能主要体现

BufferedReader 和 BufferedWriter属于字符流，是按照字符来读取数据的
关闭时处理流，只需要关闭外层流即可

处理流-BufferedReader和BufferedWriter

BufferedReader 和 BufferedWriter 属于字符流，是按照字符来读取数据的

案例：使用BufferedReader读取文本文件，并显示在控制台

package com.zanedu.reader_;

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

//演示bufferedReader使用
public class BufferedReader_ {
    public static void main(String[] args) throws IOException {
        String filePath = "F:\\Java\\code\\a.txt";
        //创建 BufferedReader 对象
        BufferedReader bufferedReader = new BufferedReader(new FileReader(filePath));
        //读取 - bufferedReader在读取的时候，底层是调用了 FileReader
        String line; //按行读取，效率高
        //说明：
        //1. bufferedReader.readLine() 是按行读取文件
        //2. 当返回 null时，表示文件读取完毕
        while ((line = bufferedReader.readLine()) != null) {
            System.out.println(line);
        }
        //关闭流 - 注意：只需要关闭我们的BufferedReader，因为底层会去自动的关闭 节点流 FileReader
        /*
        源码解读：
        public void close() throws IOException {
            synchronized (lock) {
                if (in == null)
                    return;
                try {
                    in.close(); //in 就是我们传入的 new FileReader(filePath)，关闭了
                } finally {
                    in = null;
                    cb = null;
                }
            }
        }
         */
        bufferedReader.close();
    }
}

readLine()换行符

关闭时，为啥只需要关闭外层流，源码解读，因为它源码内部会调用in.close()，即内部会自动关闭

案例：使用BufferedWriter将"hello, Zan教育"，写入到文件中

package com.zanedu.writer_;

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

//演示BufferedWriter的使用
public class BufferWriter_ {
    public static void main(String[] args) throws IOException {
        String filePath = "F:\\Java\\code\\ok.txt";
        //创建 BufferedWriter对象
        //说明：
        //1. new FileWriter(filePath, true) 表示以追加的方式写入
        //2. new FileWriter(filePath) 表示以覆盖的方式写入
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(filePath));
        bufferedWriter.write("hello，zan哥!");
        bufferedWriter.newLine();//插入一个和系统相关的换行
        bufferedWriter.write("hello2，zan哥!");
        bufferedWriter.newLine();//插入一个和系统相关的换行
        bufferedWriter.write("hello3，zan哥!");
        bufferedWriter.newLine();//插入一个和系统相关的换行


        //关闭外层流即可，传入的 new FileWriter(filePath) 会在底层关闭
        bufferedWriter.close();
    }
}

案例：综合使用BufferedReader 和 BufferedWriter 完成文本文件拷贝

package com.zanedu.writer_;

import java.io.*;

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

        /*
        说明：
            1. BufferedReader 和 BufferedWriter 是安装字符操作
            2. 不要去操作 二进制文件【声音、视频、doc、pdf】，可能会造成文件损坏
         */
        String srcFilePath = "F:\\Java\\code\\a.txt";
        String destFilePath = "F:\\Java\\code\\a2.txt";
        BufferedReader br = null;
        BufferedWriter bw = null;
        String line;
        try {
            br = new BufferedReader(new FileReader(srcFilePath));
            bw = new BufferedWriter(new FileWriter(destFilePath));

            //读取
            //说明：readLine() 读取一行内容，但是没有换行
            while ((line = br.readLine()) != null) {
                //每读取一行，就写入
                bw.write(line);
                //插入一个换行符
                bw.newLine();
            }
            System.out.println("拷贝完毕");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //关闭流
            try {
                if (br != null) {
                    br.close();
                }
                if (bw != null) {
                    bw.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

由于BufferedReader和BufferedWriter属于字符流，因此不要去操作二进制文件【声音、视频、doc、pdf】，可能会造成文件损坏

处理流-BufferedInputStream和BufferedOutputStream

BufferedInputStream介绍

BufferedInputStream是字节流，在创建BufferedInputStream时，会创建一个内部缓冲区数组

BufferOutputStream介绍

BufferedOutputStream是字节流，实现缓冲的输出流，可以将多个字节写入底层输出流中，而不必对每次字节写入调用底层系统

案例：编程完成图片/音乐的拷贝(要求使用Buffered…流)

package com.zanedu.outputstream_;

import java.io.*;

//演示使用BufferedOutputStream 和 BufferedInputStream 的使用
//使用他们，可以完成二进制文件的拷贝
//思考：字节流可以操作二进制文件，可以操作文本文件吗？ 可以
public class BufferedCopy02 {
    public static void main(String[] args) {

//        String srcFilePath = "F:\\Java\\code\\bg.png";
//        String destFilePath = "F:\\Java\\code\\bg2.png";
//        String srcFilePath = "F:\\Java\\code\\111.wav";
//        String destFilePath = "F:\\Java\\code\\222.wav";
        String srcFilePath = "F:\\Java\\code\\a.txt";
        String destFilePath = "F:\\Java\\code\\a3.txt";

        //创建BufferedOutputStream 和 BufferedInputStream 对象
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;
        try {
            //因为 FileInputStream 是 InputStream 的子类
            bis = new BufferedInputStream(new FileInputStream(srcFilePath));
            bos = new BufferedOutputStream(new FileOutputStream(destFilePath));

            //循环的读取文件，并写入到 destFilePath
            byte[] buff = new byte[1024];
            int readLen = 0;
            //当返回 -1 时，就表示文件读取完毕
            while ((readLen = bis.read(buff)) != -1) {
                bos.write(buff, 0, readLen);
            }
            System.out.println("文件拷贝完毕");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //关闭流 - 关闭外层的处理流即可，底层回去关闭结点流
            try {
                if (bis != null) {
                    bis.close();
                }
                if (bos != null) {
                    bos.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

对象流-ObjectInputStream和ObjectOutputStream

看一个需求：

将 int num = 100 这个 int 数据保存到文件中，注意不是 100 数字，而是 int 100，并且，能够从文件中直接恢复 int 100
将 Dog dog = new Dog(“小黄”, 3)，这个 dog 对象保存到文件中，并且能够从文件恢复
上面的要求，就是能够将基本数据类型或者对象进行序列化和反序列化****操作

序列化和反序列

序列化就是在保存数据时，保存****数据的值和数据类型
反序列化就是在恢复数据时，恢复****数据的值和数据类型
**需要让某个对象支持序列化机制，则必须让其类时可序列话的，**为了让某个类是可序列化的，该类必须实现如下两个接口之一
1. Serializable //这是一个标记接口，是没有方法的
2. Externalizable //该接口有方法需要实现，因此我们一般实现上面的 Serializable接口

Serializable接口 - 没有方法实现

Externalizable接口 - 有方法需要实现

对象流介绍 - 序列化、反序列化

功能：提供了对基本类型或对象类型的序列化和反序列化的方法
ObjectOutputStream 提供序列化功能
ObjcetInputStream 提供反序列化功能

案例分析

应用案例：1. 使用ObjectOutputStream序列化基本数据类型和一个Dog对象(name, age)，并保存到 data.dat 文件中

package com.zanedu.outputstream_;

import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

//演示 ObjectOutputStream 的使用，完成数据的序列化
public class ObjectOutStream_ {
    public static void main(String[] args) throws Exception{

        //序列化后，保存的文件格式，不是存文本的，而是按照它的格式来保存的
        String filePath = "F:\\Java\\code\\data.dat";
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(filePath));

        //序列化数据到 "F:\\Java\\code\\data.dat"
        oos.writeInt(100);// int -> Integer(实现类 Serializable)
        oos.writeBoolean(true);// boolean -> Boolean
        oos.writeChar('a');//char -> Character
        oos.writeDouble(9.5);//double -> Double
        oos.writeUTF("Zan教育");//String
        //保存一个Dog对象
        oos.writeObject(new Dog("旺财", 10, "日本", "白色"));

        oos.close();
        System.out.println("数据保存完毕(序列化形式)");

    }
}

应用案例：2. 使用ObjectInputStream读取 data.dat 并反序列化恢复数据

package com.zanedu.inputstream_;

import com.zanedu.outputstream_.Dog;

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

public class ObjectInputStream_ {
    public static void main(String[] args) throws Exception{
        //指定反序列化的文件
        String filePath = "F:\\Java\\code\\data.dat";

        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(filePath));

        //读取
        //1. 读取(反序列化)的顺序需要和你保存数据(序列化)的顺序保持一致
        //2. 否则会抛出异常
        System.out.println(ois.readInt());
        System.out.println(ois.readBoolean());
        System.out.println(ois.readChar());
        System.out.println(ois.readDouble());
        System.out.println(ois.readUTF());

        //o 的编译类型是 Object，运行类型是 Object
        Object o = ois.readObject();
        System.out.println("运行类型=" + o.getClass());//底层 Object -> Dog
        System.out.println("dog信息=" + o);

        //细节：
        //1. 如果我们希望调用Dog的方法，就需要向下转型
        //2. 向下转型，需要我们将Dog类的定义，放在可以引用的地方
        Dog dog = (Dog)o;
        System.out.println(dog.getName());//旺财

        //关闭流 - 底层会关闭 FileInputStream流
        ois.close();

    }
}

注意事项和细节说明

读写顺序要一致
要求序列化或反序列化对象，需要实现Serializable
序列化的类中建议添加SerivalVersionUID，是为了提高版本的兼容性
**序列化对象时，**默认将里面所有属性都进行序列化，但除了static或transient修饰的成员

package com.zanedu.outputstream_;

import java.io.Serializable;

public class Dog implements Serializable{

    private String name;
    private int age;
    //序列化对象时，默认将里面所有属性都进行序列化，但除了static或transient修饰的成员
    private static String nation;
    private transient String color;

    //序列化对象，要求里面属性的类型也需要实现序列化接口
    private Master master = new Master();

    //serialVersionUID 是序列化的版本号，可以提高序列化的兼容性
    private static final long serialVersionUID = 1L;

    public Dog(String name, int age, String nation, String color) {
        this.name = name;
        this.age = age;
        this.nation = nation;
        this.color = color;
    }

    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", color='" + color + '\'' +
                '}' + nation + master;
    }

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

序列化对象时，要求里面属性的类型也需要实现序列化接口

序列化具有可继承性**，也就是说如果某类已经实现了序列化，则它的所有子类也已经默认实现了序列化**

标准输入输出流

	类型	默认设备
System.in 标准输入	InputStream	键盘
System.out 标准输入	PrintStream	显示器

package com.zanedu.standard;

public class InputAndOutput {
    public static void main(String[] args) {
        //System 类的 public final static InputStream in = null;
        //System.in 编译类型 InputStream
        //System.in 运行类型 BufferedInputStream
        //表示的是标准输入 键盘
        System.out.println(System.in.getClass());

        //System.out 类的 public final static PrintStream out = null;
        //System.out 编译类型 PrintStream
        //System.out 运行类型 PrintStream
        //表示标准输出 显示器
        System.out.println(System.out.getClass());
    }
}

转换流-InputStreamReader 和 OutputStreamWriter

引入 - 看一个乱码问题

package com.zanedu.transformation;

import java.io.BufferedReader;
import java.io.FileReader;

//看一个中文乱码问题
public class CodeQuestion {
    public static void main(String[] args) throws Exception{
        //读取 F:\Java\code\a.txt
        //思路
        //1. 创建一个字符输入流 BufferedReader 【处理流】
        //2. 使用 BufferedReader 对象读取a.txt
        //3. 默认情况下，读取文件是按照 UTF-8 编码

        String filePath = "F:\\Java\\code\\a.txt";
        BufferedReader br = new BufferedReader(new FileReader(filePath));
        String s = br.readLine();
        System.out.println("读取到的内容：" + s);
        br.close();

    }
}

没有将编码改成GBK，仍然是用UTF-8读取

介绍

InputStreamReader：Reader的子类，可以将InputStream(字节流)包装成(转换成)Reader(字符流)
OutputStreamWriter：Writer的子类，实现将OutputStream(字节流)包装成Writer(字符流)
**当处理纯文本数据时，**如果使用字符流效率更高，并且可以有效解决中文问题，所以建议将字节流转换成字符流
可以在使用时指定编码格式(比如 UTF-8、GBK、GB2312、ISO8858-1等)

Charset就是指定字符编码方式

应用案例

将字节流FileInputStream包装成字符流InputStreamReader，对文件进行读取（按照UTF-8/GBK的格式）进而在包装成BufferedReader

package com.zanedu.transformation;

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.InputStreamReader;

//演示 InputStreamReader 转换流解决中文乱码问题
//将字节流 FileInputStream 转换成字符流 InputStreamReader，指定编码为 GBK / UTF-8
public class InputStreamReader_ {
    public static void main(String[] args) throws Exception{
        String filePath = "F:\\Java\\code\\a.txt";
        //解读
        //1. 把 new FileInputStream 转成 InputStreamReader
        //2. 同时指定编码GBK
//        InputStreamReader isr = new InputStreamReader(new FileInputStream(filePath), "GBK");
//        //3. 把 InputStreamReader 传入 BufferedReader
//        BufferedReader br = new BufferedReader(isr);

        //将 2 和 3 合在一起
        BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(filePath), "GBK"));

        //4. 读取
        String s = br.readLine();
        System.out.println("读取到的内容=" + s);

        br.close();
    }
}

编程将字节流FileOutputStream包装成字符流OutputStreamWriter，对文件进行写入（按照GBK格式）

package com.zanedu.transformation;

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

//演示OutputStreamWriter
//把 FileOutputStream 字节流 转成字符流 OutputStreamWriter
//指定处理的编码 GBK/UTF-8/UTF8
public class OutputStreamWriter_ {
    public static void main(String[] args) throws Exception{
        String filePath = "F:\\Java\\code\\zan.txt";
        String charSet = "UTF8";
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(filePath), charSet);
        osw.write("hi, Zan教育");
        osw.close();
        System.out.println("按照 " + charSet + " 保存文件成功~");
    }
}

打印流-PrintStream 和 PrintWriter

打印流只有输出流，没有输入流

package com.zanedu.printstream;

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

public class PrintStream_ {
    public static void main(String[] args) throws IOException {
        PrintStream out = System.out;
        //在默认情况下，PrintStream 输出数据的位置是 标准输出，即显示器
        /*
            public void print(String s) {
                if (s == null) {
                    s = "null";
                }
                write(s);
            }
         */
        out.println("john, hello");
        //因为print底层使用的是write，所以我们可以直接调用write方法进行打印/输出
        out.write("zan你好".getBytes());

        out.close();

        //我们可以去修改打印流输出的位置/设备
        //现在修改成文件中了
        //则一下的打印就会输出要f1.txt文件中
        /*
            public static void setOut(PrintStream out) {
                checkIO();
                setOut0(out);//native方法，修改了out
            }
         */
        System.setOut(new PrintStream("F:\\Java\\code\\f1.txt"));
        System.out.println("hello,Zan教育");
    }
}

Properties类

引入

如下一个配置文件 mysql.properties

ip=192.168.0.0

user=root

pwd=12345

编程读取 ip、user和pwd的值是多少

package com.zanedu.properties_;

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

public class Properties01 {
    public static void main(String[] args) throws IOException {

        //读取mysql.properties文件，并得到相应的ip，user 和 pwd
        BufferedReader br = new BufferedReader(new FileReader("F:\\Java\\code\\chapter18\\src\\mysql.properties"));
        String line = null;
        while ((line = br.readLine()) != null) {
            String[] split = line.split("=");
            //如果我们要求指定得到ip值
            if ("ip".equals(split[0])) {
                System.out.println(split[0] + "值是：" + split[1]);
            }
        }

        br.close();
    }
}

基本介绍

专门用于读写配置文件的集合类

配置文件的格式：

键 = 值

**注意：**键值对不需要有空格，值不需要用引号扩起来，因为默认类型就是String
Properties的常见方法

load：加载配置文件的键值对到Properties对象
list：将数据显示到指定设备
getProperty(key)：根据键获取值
setProperty(key, value)：设置键值对到Properties对象
store：将Properties中的键值对存储到配置文件，在idea中，保存信息到配置文件，如果含有中文，会存储为unicode码

package com.zanedu.properties_;

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

public class Properties02 {
    public static void main(String[] args) throws IOException {
        //使用Properties类 来读取mysql.properties文件
        //1. 创建Properties对象
        Properties properties = new Properties();
        //2. 加载指定配置文件
        properties.load(new FileReader("F:\\Java\\code\\chapter18\\src\\mysql.properties"));
        //3. 把键值对显示到控制台
        properties.list(System.out);
        //4. 根据 key 获取对应的值
        String user = properties.getProperty("user");
        String pwd = properties.getProperty("pwd");
        System.out.println(user);
        System.out.println(pwd);
    }
}

应用案例

使用Properties类添加key-val到新文件mysql2.properties中
使用Properties类完成对mysql2.properties的读取，并修改某个key-val

package com.zanedu.properties_;

import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Properties;

public class Properties03 {
    public static void main(String[] args) throws IOException {
        //使用Properties类 来创建 配置文件，修改配置文件内容
        Properties properties = new Properties();
        //创建配置文件
        //1. 如果该文件没有key，就是创建
        //2. 如果该文件有key，就是修改
        /* Properties 父类是 Hashtable，所以底层就是Hashtable

         public synchronized V put(K key, V value) {
            // Make sure the value is not null
            if (value == null) {
                throw new NullPointerException();
            }

            // Makes sure the key is not already in the hashtable.
            Entry<?,?> tab[] = table;
            int hash = key.hashCode();
            int index = (hash & 0x7FFFFFFF) % tab.length;
            @SuppressWarnings("unchecked")
            Entry<K,V> entry = (Entry<K,V>)tab[index];
            for(; entry != null ; entry = entry.next) {
                if ((entry.hash == hash) && entry.key.equals(key)) {
                    V old = entry.value;
                    entry.value = value;//如果key存在，就替换
                    return old;
                }
            }

            addEntry(hash, key, value, index); //如果是新的key，就addEntry
            return null;
        }
         */
        properties.setProperty("charset", "utf8");
        properties.setProperty("user", "汤姆"); //注意保存时，是中文的 unicode码值
        properties.setProperty("pwd", "88888");

        //将key-value存储到一个文件中即可
        properties.store(new FileOutputStream("F:\\Java\\code\\chapter18\\src\\mysql2.properties"), "Hello");
        //这个null代表注释
        System.out.println("保存配置文件成功");
    }
}

练习题

题一

需求：

(1) 在判断e盘下是否有文件夹mytemp ,如果没有就创建mytemp

(2) 在e:\mytemp 目录下, 创建文件 hello.txt

(3) 如果hello.txt 已经存在，提示该文件已经存在，就不要再重复创建了

(4) 并且在hello.txt 文件中，写入 hello,world~

package com.zanedu.homework;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;

public class Homework1 {
    public static void main(String[] args) throws Exception {
        /**
         * 需求：
         *(1) 在判断e盘下是否有文件夹mytemp ,如果没有就创建mytemp
         *(2) 在e:\\mytemp 目录下, 创建文件 hello.txt
         *(3) 如果hello.txt 已经存在，提示该文件已经存在，就不要再重复创建了
         *(4) 并且在hello.txt 文件中，写入 hello,world~
         */
        String directorPath = "F:\\Java\\code\\shiyan";
        File file = new File(directorPath);
        if (!file.exists()) {
            //创建目录
            if (file.mkdirs()) {
                System.out.println("创建 " + directorPath + " 成功");
            } else {
                System.out.println("创建 " + directorPath + " 失败");
            }
        }

        String filePath = directorPath + "\\hello.txt";
        file = new File(filePath);
        if (!file.exists()) {
            //创建文件
            if (file.createNewFile()) {
                System.out.println(filePath + " 创建成功");

                //如果文件存在，我们就使用BufferedWriter 字符输入流写入内容
                BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(file));
                bufferedWriter.write("hello，world，Zan教育");
                bufferedWriter.close();

            } else {
                System.out.println(filePath + " 创建失败");
            }
        } else {
            //如果文件已经存在，给出提示信息
            System.out.println(filePath + " 已经存在，不在重复创建");
        }
    }
}

题二

要求:

使用BufferedReader读取一个文本文件，为每行加上行号，再连同内容一并输出到屏幕上。

package com.zanedu.homework;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
/**
 * 要求:  使用BufferedReader读取一个文本文件，为每行加上行号，
 * 再连同内容一并输出到屏幕上。
 */

public class Homework02 {
    public static void main(String[] args) throws IOException {
        String filePath = "F:\\Java\\code\\ok.txt";
        BufferedReader bufferedReader = new BufferedReader(new FileReader(filePath));
        String line;
        int l = 0;
        while ((line = bufferedReader.readLine()) != null) { //循环读取
            l++;
            System.out.println(l + " " + line);
        }

        bufferedReader.close();
    }
}

题三

需求：

(1) 要编写一个dog.properties name=tom age=5 color=red

(2) 编写Dog 类(name,age,color) 创建一个dog对象，读取dog.properties 用相应的内容完成属性初始化, 并输出

(3) 将创建的Dog 对象，序列化到文件 e:\dog.dat 文件

package com.zanedu.homework;

import org.junit.jupiter.api.Test;

import java.io.*;
import java.util.Properties;

public class Homework03 {
    public static void main(String[] args) throws IOException {
        /**
         * (1) 要编写一个dog.properties   name=tom age=5 color=red
         * (2) 编写Dog 类(name,age,color)  创建一个dog对象，读取dog.properties 用相应的内容完成属性初始化, 并输出
         * (3) 将创建的Dog 对象 ，序列化到 文件 e:\\dog.dat 文件
         */
        String filePath = "F:\\Java\\code\\chapter18\\src\\dog.properties";
        Properties properties = new Properties();
        properties.load(new FileReader(filePath));

        String name = properties.get("name") + ""; //Object -> String
        int age = Integer.parseInt(properties.get("age") + ""); // Object -> int
        String color = properties.get("color") + "";

        Dog dog = new Dog(name, age, color);
        System.out.println(dog);

        //将创建的Dog 对象 ，序列化到 文件 F:\\dog.dat 文件
        String secFilePath = "F:\\Java\\code\\dog.dat";
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(secFilePath));
        oos.writeObject(dog);

        //关闭流
        oos.close();
        System.out.println("dog对象 序列化完成...");
    }

    //再编写一个方法反序列化dog
    @Test
    public void m1() throws IOException, ClassNotFoundException {
        String secFilePath = "F:\\Java\\code\\dog.dat";
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(secFilePath));
        Object o = ois.readObject();
        Dog dog = (Dog)o;
        System.out.println("===反序列化后信息===");
        System.out.println(dog.getName() + " " + dog.getAge() + " " + dog.getColor());
        ois.close();
    }
}