关于java:Java-IO流详解

文章和代码曾经归档至【Github 仓库：https://github.com/timerring/java-tutorial】或者公众号【AIShareLab】回复 java 也可获取。

文件，对咱们并不生疏, 文件是保留数据的中央。文件在程序中是以流的模式来操作的。

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

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

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

new File(String pathname) // 依据门路构建一个 File 对象
new File(File parent, String child) // 依据父目录文件 + 子门路构建 new
File(String parent, String child) // 依据父目录 + 子门路构建

package com.hspedu.file;

import org.junit.jupiter.api.Test;

import java.io.*;

/**
 * 演示创立文件
 */
public class FileCreate {public static void main(String[] args) { }

    // 形式 1 new File(String pathname)
    @Test
    public void create01() {
        String filePath = "e:\\news1.txt";
        File file = new File(filePath);

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

    }
    // 形式 2 new File(File parent,String child) // 依据父目录文件 + 子门路构建
    //e:\\news2.txt
    @Test
    public  void create02() {File parentFile = new File("e:\\");
        String fileName = "news2.txt";
        // 这里的 file 对象，在 java 程序中，只是一个对象
        // 只有执行了 createNewFile 办法，才会真正的，在磁盘创立该文件
        File file = new File(parentFile, fileName);

        try {file.createNewFile();
            System.out.println("创立胜利~");
        } catch (IOException e) {e.printStackTrace();
        }
    }

    // 形式 3 new File(String parent,String child) // 依据父目录 + 子门路构建
    @Test
    public void create03() {
        //String parentPath = "e:\\";
        String parentPath = "e:\\";
        String fileName = "news4.txt";
        File file = new File(parentPath, fileName);

        try {file.createNewFile();
            System.out.println("创立胜利~");
        } catch (IOException e) {e.printStackTrace();
        }
    }

    // 上面四个都是抽象类
    //InputStream
    //OutputStream
    //Reader // 字符输出流
    //Writer  // 字符输入流
}

getName、getAbsolutePath、getParent、length、exists、isFile、isDirectory

package com.hspedu.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("e:\\news1.txt");

        // 调用相应的办法，失去对应信息
        System.out.println("文件名字 =" + file.getName());
        // getName、getAbsolutePath、getParent、length、exists、isFile、isDirectory
        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 删除空目录或文件

利用案例演示

1) 判断 d:\\news1.txt是否存在，如果存在就删除
2) 判断 D:\\ldemo02 是否存在，存在就删除, 否则提醒不存在.
3) 判断 D:\\demo\\a\\b\\c目录是否存在，如果存在就提醒曾经存在，否则就创立

package com.hspedu.file;

import org.junit.jupiter.api.Test;

import java.io.File;
import java.io.InputStream;
import java.io.OutputStream;

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

    // 判断 d:\\news1.txt 是否存在，如果存在就删除
    @Test
    public void m1() {

        String filePath = "e:\\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("该文件不存在...");
        }

    }

    // 判断 D:\\demo02 是否存在，存在就删除，否则提醒不存在
    // 这里咱们须要领会到，在 java 编程中，目录也被当做文件
    @Test
    public void m2() {

        String filePath = "D:\\demo02";
        File file = new File(filePath);
        if (file.exists()) {if (file.delete()) {System.out.println(filePath + "删除胜利");
            } else {System.out.println(filePath + "删除失败");
            }
        } else {System.out.println("该目录不存在...");
        }

    }

    // 判断 D:\\demo\\a\\b\\c 目录是否存在，如果存在就提醒曾经存在，否则就创立
    @Test
    public void m3() {

        String directoryPath = "D:\\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 + "创立失败...");
            }
        }


    }
}

I/O 是 Input/Output 的缩写，I/ O 技术是十分实用的技术，用于解决数据传输。
如读 / 写文件, 网络通讯等。
Java 程序中，对于数据的输出 / 输入操作以”流(stream)”的形式进行。
java.io 包下提供了各种“流”类和接口，用以获取不同品种的数据, 并通过办法输出或输入数据
输出 input: 读取内部数据 (磁盘、光盘等存储设备的数据) 到程序 (内存) 中。
输入 output: 将程序 (内存) 数据输入到磁盘、光盘等存储设备中

按操作数据单位不同分为：字节流(8 bit)（二进制文件例如声音视频 word 等能够无损操作），字符流(按字符)（文本文件）。
按数据流的流向不同分为：输出流，输入流。
按流的角色的不同分为：节点流，解决流 / 包装流。

1) Java 的 IO 流共波及 40 多个类，实际上十分规定，都是从如上 4 个形象基类派生的。
2) 由这四个类派生进去的子类名称都是以其父类名作为子类名后缀。

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

当然，留神一个汉字通常是由 3 个 bytes 形成的，而 read 只会读取一个 byte 的数据，因而如果用 read 则会乱码，倡议文本文件用字符流解决。

package com.hspedu.inputstream_;

import org.junit.jupiter.api.Test;

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

/**
 * 演示 FileInputStream 的应用(字节输出流 文件 --> 程序)
 */
public class FileInputStream_ {public static void main(String[] args) { }

    /**
     * 演示读取文件...
     * 单个字节的读取，效率比拟低
     * -> 应用 read(byte[] b)
     */
    @Test
    public void readFile01() {
        String filePath = "e:\\hello.txt";
        int readData = 0;
        FileInputStream fileInputStream = null;
        try {
            // 创立 FileInputStream 对象，用于读取 文件
            fileInputStream = new FileInputStream(filePath);
            // 从该输出流读取一个字节的数据。如果没有输出可用，此办法将阻止。// 如果返回 -1 , 示意读取结束
            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 = "e:\\hello.txt";
        // 字节数组
        byte[] buf = new byte[8]; // 一次读取 8 个字节.
        int readLen = 0;
        FileInputStream fileInputStream = null;
        try {
            // 创立 FileInputStream 对象，用于读取 文件
            fileInputStream = new FileInputStream(filePath);
            // 从该输出流读取最多 b.length 字节的数据到字节数组。此办法将阻塞，直到某些输出可用。// 如果返回 -1 , 示意读取结束
            // 如果读取失常, 返回理论读取的字节数
            while ((readLen = fileInputStream.read(buf)) != -1) {System.out.print(new String(buf, 0, readLen));// 显示
            }

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

    }
}

请应用 FileOutputStream 在 a.txt 文件，中写入“hello，world”. 如果文件不存在，会创立文件(留神：前提是目录曾经存在.)

package com.hspedu.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 writeFile() {

        // 创立 FileOutputStream 对象
        String filePath = "e:\\a.txt";
        FileOutputStream fileOutputStream = null;
        try {
            // 失去 FileOutputStream 对象 对象
            // 老师阐明
            //1. new FileOutputStream(filePath) 创立形式，当写入内容是，会笼罩原来的内容
            //2. new FileOutputStream(filePath, true) 创立形式，当写入内容是，是追加到文件前面
            fileOutputStream = new FileOutputStream(filePath, true);
            // 写入一个字节
            //fileOutputStream.write('H');//
            // 写入字符串
            String str = "hello,world!";
            //str.getBytes() 能够把 字符串 -> 字节数组
            //fileOutputStream.write(str.getBytes());
            /*
            write(byte[] b, int off, int len) 将 len 字节从位于偏移量 off 的指定字节数组写入此文件输入流
             */
            fileOutputStream.write(str.getBytes(), 0, 3);

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

编程实现图片 / 音乐的拷贝.

package com.hspedu.outputstream_;

import com.hspedu.inputstream_.FileInputStream_;

import java.io.*;

public class FileCopy {public static void main(String[] args) {
        // 实现 文件拷贝，将 e:\\Koala.jpg 拷贝 c:\\
        // 思路剖析
        //1. 创立文件的输出流 , 将文件读入到程序
        //2. 创立文件的输入流，将读取到的文件数据，写入到指定的文件.
        String srcFilePath = "e:\\Koala.jpg";
        String destFilePath = "e:\\Koala3.jpg";
        FileInputStream fileInputStream = null;
        FileOutputStream fileOutputStream = null;

        try {fileInputStream = new FileInputStream(srcFilePath);
            fileOutputStream = new FileOutputStream(destFilePath);
            // 定义一个字节数组, 进步读取成果
            byte[] buf = new byte[1024];
            int readLen = 0;
            while ((readLen = fileInputStream.read(buf)) != -1) {
                // 读取到后，就写入到文件 通过 fileOutputStream
                // 即，是一边读，一边写
                fileOutputStream.write(buf, 0, readLen);// 肯定要应用这个办法
                // 不能用 fileOutputStream.write(buf) 因为最初有可能读不够而出错
            }
            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();
            }
        }
    }
}

1) new FileReader(File/String)
2) read: 每次读取 单个字符，返回该字符，如果到文件开端返回 -1
3) read(charD): 批量读取多个字符到数组，返回读取到的字符数，如果到文件未尾返回 -1

相干 API:

1) new String(charD): 将 char[]转换成 String
2) new String(charl,off,len): 将 char[]的指定局部转换成 String

1) new FileWriter(File/String): 笼罩模式，相当于流的指针在首端
2) new FileWriter(File/String,true): 追加模式，相当于流的指针在尾端
3) write(int): 写入单个字符
4) write(char): 写入指定数组
5) write(charl.off,.len): 写入指定数组的指定局部 6) write (string): 写入整个字符串
6) write(string,off,len): 写入字符串的指定局部

相干 APl: String 类: toCharArray: 将 String 转换成 char[]

留神: FileWriter 应用后，必须要敞开 (close) 或刷新 (flush)，否则写入不到指定的文件! 因为仅仅到了 Java 程序内存中。

1) 应用 FileReader 从 story.txt 读取内容，并显示

package com.hspedu.reader_;

import org.junit.jupiter.api.Test;

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

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

    /**
     * 单个字符读取文件
     */
    @Test
    public void readFile01() {
        String filePath = "e:\\story.txt";
        FileReader fileReader = null;
        int data = 0;
        //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 {if (fileReader != null) {fileReader.close();
                }
            } catch (IOException e) {e.printStackTrace();
            }
        }
    }

    /**
     * 字符数组读取文件
     */
    @Test
    public void readFile02() {System.out.println("~~~readFile02 ~~~");
        String filePath = "e:\\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 {if (fileReader != null) {fileReader.close();
                }
            } catch (IOException e) {e.printStackTrace();
            }
        }
    }
}

2) 应用 FileWriter 将“风雨之后，定见彩虹”写入到 note.txt 文件中, 留神细节.

package com.hspedu.writer_;

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

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

        String filePath = "e:\\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); // 输入上海，因为从 offset0 开始，写入两个字符
            // 在数据量大的状况下，能够应用循环操作.


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

            // 对应 FileWriter , 肯定要敞开流，或者 flush 能力真正的把数据写入到文件
            // 看源码就晓得起因.
            /*
                看看代码
                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

节点流是底层流 / 低级流, 间接跟数据源相接。
解决流 ( 包装流 ) 包装节点流，既能够打消不同节点流的实现差别，也能够提供更方
便的办法来实现输入输出。
解决流 (也叫包装流) 对节点流进行包装，应用了润饰器设计模式，不会间接与数据
源相连[模仿润饰器设计模式]

package com.hspedu;

public class StringReader_ extends Reader_ {public void readString() {System.out.println("读取字符串..");
    }
}

package com.hspedu;

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

package com.hspedu;

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

    // 在 Reader_ 抽象类，应用 read 办法对立治理.
    // 前面在调用时，利于对象动静绑定机制，绑定到对应的实现子类即可.
    //public abstract void read();}

package com.hspedu;

/**
 * 做成解决流 / 包装流
 */
public class BufferedReader_ extends Reader_{

    private Reader_ reader_; // 属性是 Reader_类型

    // 接管 Reader_ 子类对象
    public BufferedReader_(Reader_ reader_) {this.reader_ = reader_;}

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

    // 让办法更加灵便，屡次读取文件, 或者加缓冲 byte[] ....
    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.hspedu;

import java.io.*;

public class Test_ {public static void main(String[] args) {BufferedReader_ bufferedReader_ = new BufferedReader_(new FileReader_());
        bufferedReader_.readFiles(10);
        //bufferedReader_.readFile();
        //Serializable
        //Externalizable
        //ObjectInputStream
        //ObjectOutputStream
        // 这次心愿通过 BufferedReader_ 屡次读取字符串
        BufferedReader_ bufferedReader_2 = new BufferedReader_(new StringReader_());
        bufferedReader_2.readStrings(5);
    }
}

性能的进步: 次要以减少缓冲的形式来进步输入输出的效率。
操作的便捷: 解决流可能提供了一系列便捷的办法来一次输入输出大批量的数据, 应用更加灵便不便。

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

敞开时解决流，只须要敞开外层流即可（因为真正工作的是内层流，敞开时只须要敞开外层解决流，会主动敞开内层流）【源码】

应用 BufferedReader 读取文本文件，并显示在控制台

package com.hspedu.reader_;

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

/**
 * 演示 bufferedReader 应用
 */
public class BufferedReader_ {public static void main(String[] args) throws Exception {

        String filePath = "e:\\a.java";
        // 创立 bufferedReader
        BufferedReader bufferedReader = new BufferedReader(new FileReader(filePath));
        // 读取
        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();}
}

应用 BufferedWriter 将”hello，教育”，写入到文件中

package com.hspedu.writer_;

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

/**
 * 演示 BufferedWriter 的应用
 */
public class BufferedWriter_ {public static void main(String[] args) throws IOException {
        String filePath = "e:\\ok.txt";
        // 创立 BufferedWriter
        // 阐明:
        //1. new FileWriter(filePath, true) 示意以追加的形式写入
        //2. new FileWriter(filePath) , 示意以笼罩的形式写入
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(filePath));
        bufferedWriter.write("hello, 教育!");
        bufferedWriter.newLine();// 插入一个和零碎相干的换行
        bufferedWriter.write("hello2, 教育!");
        bufferedWriter.newLine();
        bufferedWriter.write("hello3, 教育!");
        bufferedWriter.newLine();
        // 阐明：敞开外层流即可，传入的 new FileWriter(filePath) , 会在底层敞开
        bufferedWriter.close();}
}

3) 综合应用 BufferedReader 和 BufferedWriter 实现文本文件拷贝，留神文件编码。

package com.hspedu.writer_;

import java.io.*;

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


        //1. BufferedReader 和 BufferedWriter 是依照字符操作
        //2. 不要去操作 二进制文件[声音，视频，doc, pdf], 可能造成文件损坏
        //BufferedInputStream
        //BufferedOutputStream
        String srcFilePath = "e:\\a.java";
        String destFilePath = "e:\\a2.java";
//        String srcFilePath = "e:\\0245_零根底学 Java_引出 this.avi";
//        String destFilePath = "e:\\a2.avi";
        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();
            }
        }


    }
}

BufferedInputStream 是字节流在创立 BufferedInputStream 时，会创立一个外部缓冲区数组。

BufferedOutputStream 是字节流, 实现缓冲的输入流, 能够将多个字节写入底层输入流中，而不用对每次字节写入调用底层零碎。

要求: 编程实现图片 / 音乐的拷贝(要求应用 Buffered.. 流).

package com.hspedu.outputstream_;

import java.io.*;

/**
 * 演示应用 BufferedOutputStream 和 BufferedInputStream 应用
 * 应用他们，能够实现二进制文件拷贝.
 * 思考：字节流能够操作二进制文件，能够操作文本文件吗？当然能够
 */
public class BufferedCopy02 {public static void main(String[] args) {

//        String srcFilePath = "e:\\Koala.jpg";
//        String destFilePath = "e:\\hsp.jpg";
//        String srcFilePath = "e:\\0245_零根底学 Java_引出 this.avi";
//        String destFilePath = "e:\\hsp.avi";
        String srcFilePath = "e:\\a.java";
        String destFilePath = "e:\\a3.java";

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

        }
    }
}

看一个需要：不仅须要保留值，还须要保留数据类型。

将 int num = 100 这个 int 数据保留到文件中, 留神不是 100 数字，而是 int 100，并且，可能从文件中间接复原 int 100
将 Dog dog = new Dog(“小黄”，3)这个 dog 对象保留到文件中，并且可能从文件复原.
下面的要求，就是可能将根本数据类型或者对象进行序列化和反序列化操作

序列化和反序列化

序列化就是在保留数据时，保留数据的值和数据类型
反序列化就是在复原数据时，复原数据的值和数据类型
须要让某个对象反对序列化机制，则必须让其类是可序列化的，为了让某个类是可序列化的，该类必须实现如下两个接口之一:
- Serializable // 这是一个标记接口, 没有办法
- Externalizable // 该接口有办法须要实现，因而咱们个别实现下面的接口

性能：提供了对根本类型或对象类型的序列化和反序列化的办法

ObjectOutputStream 提供序列化性能
ObjectInputStream 提供反序列化性能

应用 ObjectOutputStream 序列化根本数据类型和一个 Dog 对象 (name, age), 并
保留到 data.dat 文件中。

package com.hspedu.outputstream_;

import java.io.Serializable;

// 如果须要序列化某个类的对象，实现 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.color = color;
        this.nation = nation;
    }

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

package com.hspedu.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 = "e:\\data.dat";

        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(filePath));

        // 序列化数据到 e:\data.dat
        oos.writeInt(100);// int -> Integer (Integer 实现了 Serializable)
        oos.writeBoolean(true);// boolean -> Boolean (实现了 Serializable)
        oos.writeChar('a');// char -> Character (实现了 Serializable)
        oos.writeDouble(9.5);// double -> Double (实现了 Serializable)
        oos.writeUTF("教育");//String
        // 保留一个 dog 对象
        oos.writeObject(new Dog("旺财", 10, "日本", "红色"));
        oos.close();
        System.out.println("数据保留结束(序列化模式)");
    }
}

应用 ObjectlnputStream 读取 data.dat 并反序列化复原数据

package com.hspedu.inputstream_;



import com.hspedu.outputstream_.Dog;

import java.io.*;

public class ObjectInputStream_ {public static void main(String[] args) throws IOException, ClassNotFoundException {

        // 指定反序列化的文件
        String filePath = "e:\\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());


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

        // 这里是特地重要的细节:

        //1. 如果咱们心愿调用 Dog 的办法, 须要向下转型
        //2. 须要咱们将 Dog 类的定义，放在到能够援用的地位
        Dog dog2 = (Dog)dog;
        System.out.println(dog2.getName()); // 旺财..

        // 敞开流, 敞开外层流即可，底层会敞开 FileInputStream 流
        ois.close();}
}

package com.hspedu.outputstream_;

import java.io.Serializable;

// 如果须要序列化某个类的对象，实现 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.color = color;
        this.nation = nation;
    }

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

注意事项和细节阐明

读写程序要统一。
要求序列化或反序列化对象，须要实现Serializable。
序列化的类中倡议增加SerialVersionUID，为了进步版本的兼容性。当退出新属性时，序列化和反序列化会认为是原来的修改版，而不会认为是一个全新的类。
```
private static final long serialVersionUID = 1L;
```
序列化对象时，默认将外面所有属性都进行序列化，但除了 static 或 transient 润饰的成员。也就是序列化并不保留 static 或transient润饰的信息。
序列化对象时，要求外面属性的类型也须要实现序列化接口。
序列化具备可继承性，也就是如果某类曾经实现了序列化，则它的所有子类也曾经默认实现了序列化。

传统办法 System.out.println(“”); 是应用 out 对象将数据输入到显示器

传统的办法, Scanner 是从规范输出键盘接收数据

package com.hspedu.standard;

import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.Scanner;

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

        //1. System.out public final static PrintStream out = null;
        //2. 编译类型 PrintStream
        //3. 运行类型 PrintStream
        //4. 示意规范输入 显示器
        System.out.println(System.out.getClass());

        System.out.println("hello, 教育");

        Scanner scanner = new Scanner(System.in);
        System.out.println("输出内容");
        String next = scanner.next();
        System.out.println("next=" + next);
    }
}

文件乱码问题，引出学习转换流必要性。

能够这么了解：相当于把 InputStream 转为 Reader，把 OutputStream 转为 Writer。

InputStreamReader:Reader 的子类，能够将 InputStream(字节流)包装成(转换)Reader(字符流)
OutputStreamWriter:Writer 的子类，实现将 OutputStream(字节流)
包装成 Writer(字符流)
当解决纯文本数据时，如果应用字符流效率更高，并且能够无效解决中文
问题, 所以倡议将字节流转换成字符流。
能够在应用时指定编码格局(比方 utf-8, gbk , gb2312,ISO8859- 1 等)

1. 编程将字节流 FilelnputStream 包装成 (转换成) 字符流 InputStreamReader, 对
文件进行读取(依照 utf-8/gbk 格局), 进而包装成 BufferedReader

package com.hspedu.transformation;

import java.io.*;

/**
 * 演示应用 InputStreamReader 转换流解决中文乱码问题
 * 将字节流 FileInputStream 转成字符流  InputStreamReader, 指定编码 gbk/utf-8
 */
public class InputStreamReader_ {public static void main(String[] args) throws IOException {

        String filePath = "e:\\a.txt";
        // 解读
        //1. 把 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);
        //5. 敞开外层流
        br.close();}
}

编程将字节流 FileOutputStream 包装成 (转换成) 字符流 OutputStreamWriter, 对文件进行写入(依照 gbk 格局, 能够指定其余，比方 utf-8)

package com.hspedu.transformation;

import java.io.*;

/**
 * 演示 OutputStreamWriter 应用
 * 把 FileOutputStream 字节流，转成字符流 OutputStreamWriter
 * 指定解决的编码 gbk/utf-8/utf8
 */
public class OutputStreamWriter_ {public static void main(String[] args) throws IOException {
        String filePath = "e:\\hsp.txt";
        String charSet = "utf-8";
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(filePath), charSet);
        osw.write("hi, 教育");
        osw.close();
        System.out.println("依照" + charSet + "保留文件胜利~");
    }
}

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

package com.hspedu.printstream;

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

/**
 * 演示 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.print("john, hello");
        // 因为 print 底层应用的是 write , 所以咱们能够间接调用 write 进行打印 / 输入
        out.write("你好".getBytes());
        out.close();

        // 咱们能够去批改打印流输入的地位 / 设施
        //1. 输入批改成到 "e:\\f1.txt"
        //2. "hello, 教育~" 就会输入到 e:\f1.txt
        //3. 源码：// public static void setOut(PrintStream out) {//        checkIO();
        //        setOut0(out); // native 办法，批改了 out
        //   }
        System.setOut(new PrintStream("e:\\f1.txt"));
        System.out.println("hello, 教育~");
    }
}

package com.hspedu.transformation;

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

/**
 * 演示 PrintWriter 应用形式
 */
public class PrintWriter_ {public static void main(String[] args) throws IOException {//PrintWriter printWriter = new PrintWriter(System.out); // 输入到显示器
        PrintWriter printWriter = new PrintWriter(new FileWriter("e:\\f2.txt"));
        printWriter.print("hi, 北京你好~~~~");
        printWriter.close();//flush + 敞开流, 才会将数据写入到文件..}
}

看一个需要

如下一个配置文件 mysql.properties

ip=192.168.0.13
user=root
pwd=12345

请问编程读取 ip. user 和 pwd 的值是多少

剖析

传统的办法
应用 Properties 类能够不便实现

package com.hspedu.properties_;

import java.io.BufferedReader;
import java.io.FileNotFoundException;
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("src\\mysql.properties"));
        String line = "";
        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 码
http://tool.chinaz.com/tools/unicode.aspx unicode 码查问工具

1. 应用 Properties 类实现对 mysql.properties 的读取, 看老师代码演示

package com.hspedu.properties_;

import java.io.FileNotFoundException;
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("src\\mysql.properties"));
        //3. 把 k - v 显示控制台
        properties.list(System.out);
        //4. 依据 key 获取对应的值
        String user = properties.getProperty("user");
        String pwd = properties.getProperty("pwd");
        System.out.println("用户名 =" + user);
        System.out.println("明码是 =" + pwd);
    }
}

2. 应用 Properties 类增加 key-val 到新文件 mysql2.properties 中

3. 应用 Properties 类实现对 mysq12.properties 的读取，并批改某个 key-val

package com.hspedu.properties_;

import java.io.FileNotFoundException;
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);// 如果是新 k, 就 addEntry
                return null;
            }

         */
        properties.setProperty("charset", "utf8");
        properties.setProperty("user", "汤姆");// 留神保留时，是中文的 unicode 码值
        properties.setProperty("pwd", "888888");

        // 将 k -v 存储文件中即可
        properties.store(new FileOutputStream("src\\mysql2.properties"), null);
        System.out.println("保留配置文件胜利~");

    }
}

1. 编程题

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

(2)在 e:llmytemp 目录下，创立文件 hello.txt

(3)如果 hello.txt 曾经存在，提醒该文件曾经存在, 就不要再反复创立了

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

package com.hspedu.homework;

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

public class Homework01 {public static void main(String[] args) throws IOException {
        /**
         *(1) 在判断 e 盘下是否有文件夹 mytemp , 如果没有就创立 mytemp
         *(2) 在 e:\\mytemp 目录下, 创立文件 hello.txt
         *(3) 如果 hello.txt 曾经存在，提醒该文件曾经存在，就不要再反复创立了
         *(4) 并且在 hello.txt 文件中，写入 hello,world~
         */

        String directoryPath = "e:\\mytemp";
        File file = new File(directoryPath);
        if(!file.exists()) {
            // 创立
            if(file.mkdirs()) {System.out.println("创立" + directoryPath + "创立胜利");
            }else {System.out.println("创立" + directoryPath + "创立失败");
            }
        }

        String filePath  = directoryPath + "\\hello.txt";// e:\mytemp\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~~ 教育");
                bufferedWriter.close();} else {System.out.println(filePath + "创立失败~");
            }
        } else {
            // 如果文件曾经存在，给出提示信息
            System.out.println(filePath + "曾经存在，不在反复创立...");
        }
    }
}

2. 编程题
要求: 应用 BufferedReader 读取一个文本文件，为每行加上行号，再连同内容一并输入到屏幕上。

// 如果把文件的编码改成了 gbk，呈现中文乱码，大家思考如何解决

//1. 默认是依照 utf- 8 解决, 开始没有乱码

//2. 提醒: 应用咱们的转换流，将 FilelnputStream -> InputStreamReader[能够指定编码]- >BufferedReader …

package com.hspedu.homework;

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

public class Homework02 {public static void main(String[] args) {
        /**
         * 要求:  应用 BufferedReader 读取一个文本文件，为每行加上行号，* 再连同内容一并输入到屏幕上。*/
        String filePath = "e:\\a.txt";
        BufferedReader br = null;
        String line = "";
        int lineNum = 0;
        try {br = new BufferedReader(new FileReader(filePath));
            while ((line = br.readLine()) != null) { // 循环读取
                System.out.println(++lineNum + line);
            }
        } catch (Exception e) {e.printStackTrace();
        } finally {

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

3. 编程题
(1) 要编写一个 dog.properties

name=tom
age=5
color=red

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

(3)将创立的 Dog 对象, 序列化到文件 dog.dat 文件

package com.hspedu.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 = "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") + "";//Object -> String

        Dog dog = new Dog(name, age, color);
        System.out.println("===dog 对象信息 ====");
        System.out.println(dog);

        // 将创立的 Dog 对象，序列化到 文件 dog.dat 文件
        String serFilePath = "e:\\dog.dat";
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(serFilePath));
        oos.writeObject(dog);

        // 敞开流
        oos.close();
        System.out.println("dog 对象，序列化实现...");
    }

    // 在编写一个办法，反序列化 dog
    @Test
    public void m1() throws IOException, ClassNotFoundException {
        String serFilePath = "e:\\dog.dat";
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(serFilePath));
        Dog dog = (Dog)ois.readObject();

        System.out.println("=== 反序列化后 dog====");
        System.out.println(dog);

        ois.close();}
}

class Dog implements  Serializable{
    private String name;
    private int age;
    private String color;

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

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

文件

罕用的文件操作

创立文件对象相干结构器和办法

获取文件的相干信息

目录的操作和文件删除

IO 流原理及流的分类

Java IO 流原理

流的分类

IO 流体系图 - 罕用的类

IO 流体系图

文件 VS 流

FileInputStream 介绍

FileInputStream 利用实例

FileOutputStream 介绍

FileOutputStream 利用实例

FileOutputStream 利用实例 2

FileReader 和 FileWriter 介绍

FileReader 相干办法

FileWriter 相干办法

FileReader 和 FileWriter 利用案例

节点流和解决流

根本介绍

节点流和解决流一览图

节点流和解决流的区别和分割

解决流的性能

解决流 BufferedReader 和 BufferedWriter

利用案例

解决流 BufferedInputStream 和 BufferedOutputStream

利用案例

对象流 ObjectInputStream 和 ObjectOutputStream

对象流介绍

利用案例

规范输入输出流

介绍

利用案例 1

利用案例 2

转换流 InputStreamReader 和 OutputStreamWriter

利用案例

打印流 PrintStream 和 PrintWriter

Properties 类

根本介绍

利用案例

本章作业