Java-IO流

JavaSE

发布日期: 2022-02-27

更新日期: 2022-07-04

文章字数: 6.3k

阅读次数:

前言

哈喽！大家好，我是小简。今天开始学习《Java-IO流》，此系列是我做的一个 “Java 从 0 到 1 ” 实验，给自己一年左右时间，按照我自己总结的 Java-学习路线，从 0 开始学 Java 知识，并不定期更新所学笔记，期待一年后的蜕变吧！<有同样想法的小伙伴，可以联系我一起交流学习哦！>

🚩时间安排：预计一周更新完
🎯开始时间：02-27
🎉结束时间：03-03
🍀总结：用时 5 天，提前两天完成任务，继续下一个 🚩

IO流简介

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

流分类

按操作数据单位不同分为
- 字节流(8 bit) –适合操作二进制文件
- 字符流(按字符) –适合操作文本文件
按数据流的流向不同分为
- 输入流
- 输出流
按流的角色的不同分为
- 节点流
- 处理流/包装流

体系图

文件操作

创建文件

new File(String pathname) //根据路径构建一个File对象
new File(File parent. String child) //根据父目录文件+子路径构建
new File(String parent,String child) //根据父目录+子路径构建
createNewFile() //文件创建

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

public class FileCreate {
  
    //new File(String pathname) //根据路径构建一个File对象
    @Test
    public void create01(){
        String pathname = "/Users/jianjian/Downloads/test1.txt";
        File file = new File(pathname);
        try {
            file.createNewFile();
            System.out.println("文件创建成功");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
  
    //new File(File parent. String child) //根据父目录文件+子路径构建
    @Test
    public void create02(){
        File parentFile = new File("/Users/jianjian/Downloads/");
        String fileName = "test2.txt";
        File file = new File(parentFile, fileName);
        try {
            file.createNewFile();
            System.out.println("文件创建成功");
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
  
    //new File(String parent,String child) //根据父目录+子路径构建
    @Test
    public void create03(){
        String parentFile = "/Users/jianjian/Downloads/";
        String fileName = "test3.txt";
        File file = new File(parentFile, fileName);
        try {
            file.createNewFile();
            System.out.println("文件创建成功");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

获取文件信息

getName() 文件名字
getAbsolutePath() 文件绝对路径
file.getParent() 文件父级目录
file.length() 文件大小(字节)
file.exists() 文件是否存在
file.isFile() 是不是一个文件
file.isDirectory() 是不是一个目录

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

public class FileInfomation {
    //获取文件的信息
    @Test
    public void info() {
        //先创建文件对象
        File file = new File("/Users/jianjian/Downloads/test.txt");
        //调用相应的方法，得到对应信息
        System.out.println("文件名字=" + file.getName());
        System.out.println("文件绝对路径=" + file.getAbsolutePath());
        System.out.println("文件父级目录=" + file.getParent());
        System.out.println("文件大小(字节)=" + file.length());//中文字符3个字节，英文字符1个字节
        System.out.println("文件是否存在=" + file.exists());//T
        System.out.println("是不是一个文件=" + file.isFile());//T
        System.out.println("是不是一个目录=" + file.isDirectory());//F
    }
}

目录操作

实例：

判断 /Users/jianjian/Downloads/test.txt 文件是否存在，如果存在就删除。
判断 /Users/jianjian/Downloads/test 目录是否存在，如果存在就提示已经存在，否则就创建。
判断 /Users/jianjian/Downloads/test/a/b 目录是否存在，如果存在就提示已经存在，否则就创建。

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

public class Directory_ {

    //1) 判断 /Users/jianjian/Downloads/test.txt 文件是否存在如果存在就删除。
    @Test
    public void Q1(){
        String fileName = "/Users/jianjian/Downloads/test.txt";
        File file = new File(fileName);
        if (file.exists()) {
            System.out.println(file.getName()+"文件存在");
            if (file.delete()) {
                System.out.println(file.getName()+"删除成功");
            }
        } else {
            System.out.println(file.getName()+"文件不存在");
        }
    }

    //2) 判断 /Users/jianjian/Downloads/test 目录是否存在，如果存在就提示已经存在，否则就创建。
    @Test
    public void Q2(){
        String fileName = "/Users/jianjian/Downloads/test";
        File file = new File(fileName);
        if (file.exists()) {
            System.out.println(file.getName()+"文件存在");
        } else{
            System.out.println(file.getName()+"文件不存在");
            if (file.mkdir()) {
                System.out.println(file.getName()+"文件创建成功");
            } else{
                System.out.println(file.getName()+"文件创建失败");
            }
        }
    }

    //3) 判断 /Users/jianjian/Downloads/test/a/b  目录是否存在，如果存在就提示已经存在，否则就创建。
    @Test
    public void Q3(){
        String fileName = "/Users/jianjian/Downloads/test/a/b";
        File file = new File(fileName);
        if (file.exists()) {
            System.out.println(file.getName()+"文件存在");
        } else{
            System.out.println(file.getName()+"文件不存在");
            if (file.mkdirs()) {
                System.out.println(file.getName()+"文件创建成功");
            } else{
                System.out.println(file.getName()+"文件创建失败");
            }
        }
    }
}

字节流

FileInputStream

read() //单字节读取
read(byte[] b) //多字节读取

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

单字节读取

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

public class FileInputStream_ {
    @Test
    public void readFile01() {
        String filePath = "/Users/jianjian/Downloads/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();
            }
        }
    }
}

多字节读取

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

public class FileInputStream_ {
    @Test
    public void readFile02() {
        String filePath = "/Users/jianjian/Downloads/hello.txt";
        int readLen = 0;
        byte[] buf = new byte[8];//一次读取8个字节.
        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

创建方式
new FileOutputStream(filePath) //当写入内容时，会覆盖原来的内容
new FileOutputStream(filePath, true) //当写入内容时，是追加到原来的内容后面
写入方式
- write(byte[] b); //单字节写入
- write(byte[] b, int off, int len) //将 len字节从位于偏移量off 的指定字节数组写入此文件输出流

例子1🌰：请使用 FileOutputStream 在 a.txt 文件中写入 “hello，world”，如果文件不存在，会创建文件(注意：前提是目录已经存在)

package com.jwt.outputstream_;

import org.junit.Test;

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

public class FileOutputStream_ {

    @Test
    public void writeFile01(){
        String filePath = "/Users/jianjian/Downloads/a.txt";
        FileOutputStream fileOutputStream = null;
        try {
            fileOutputStream = new FileOutputStream(filePath);//覆盖
            fileOutputStream.write('J');
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    @Test
    public void writeFile02(){
        String filePath = "/Users/jianjian/Downloads/a.txt";
        FileOutputStream fileOutputStream = null;
        String str = "Hello,jwt";
        try {
            fileOutputStream = new FileOutputStream(filePath,true);//追加
            //str.getBytes() 可以把字符串-> 字节数组
            fileOutputStream.write(str.getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    @Test
    public void writeFile03(){
        String filePath = "/Users/jianjian/Downloads/a.txt";
        FileOutputStream fileOutputStream = null;
        String str = "Hello,jwt";
        try {
            fileOutputStream = new FileOutputStream(filePath);
            fileOutputStream.write(str.getBytes(), 0, str.length());
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}

例子1🌰：编程完成图片的拷贝，将 /Users/jianjian/Downloads/a.jpg 拷贝到 /Users/jianjian/Downloads/test/a.jpg，即输入流和输出流同时使用

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

public class FileCopy {
    public static void main(String[] args) {
        String srcFilePath = "/Users/jianjian/Downloads/a.jpeg";
        String destFilePath = "/Users/jianjian/Downloads/test/a.jpeg";
        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);//一定要使用这个方法
            }
            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

new FileReader(File/String)
read()：每次读取单个字符，返回该字符，如果到文件末尾返回-1
read(char[])：批量读取多个字符到数组，返回读取到的字符数，如果到文件末尾返回-1
相关API:
- new String(char[]):将char[]转换成String
- new String(char[],off,len):将char[]的指定部分转换成String

例子🌰：使用 FileReader 从 hello.txt 读取内容，并显示

import org.junit.Test;
import java.io.FileReader;
import java.io.IOException;

public class FileReader_ {
    /**
     * 单个字符读取文件
     */
    @Test
    public void readFile01() {
        String filePath = "/Users/jianjian/Downloads/hello.txt";
        FileReader fileReader = null;
        int data = 0;
        try {
            //创建FileReader 对象
            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() {
        String filePath = "/Users/jianjian/Downloads/hello.txt";
        FileReader fileReader = null;
        int readLen = 0;
        char[] buf = new char[8];
        try {
            //创建FileReader 对象
            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();
            }
        }
    }
}

FileWriter

创建
- newFileWriter(File/String)：覆盖模式，相当于流的指针在首端
- new FileWriter(File/String,true)：追加模式，相当于流的指针在尾端
写入
- write(int);写入单个宇符
- write(char[])：写入指定数组
- write(char[],off,len):写入指定数组的指定部分
- write (string)：写入整个字符串
- write(string,off,len):写入字符串的指定部分
相关APl：
- String类：toCharArray:将String转换成char[]
注意：FileWriter使用后，必须要关闭(close)或刷新(flush)，否则写入不到指定的文件！

例子🌰：使用 FileWriter 将 “Hello,World” 写入到 hello.txt 文件中

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

public class FileWriter_ {
    public static void main(String[] args) {
        String filePath = "/Users/jianjian/Downloads/hello.txt";
        //创建FileWriter 对象
        FileWriter fileWriter = null;
        char[] chars = {'a', 'b', 'c'};
        try {
            fileWriter = new FileWriter(filePath);//默认是覆盖写入
            // 1) write(int):写入单个字符
            fileWriter.write('H');
            // 2) write(char[]):写入指定数组
            fileWriter.write(chars);
            // 3) write(char[],off,len):写入指定数组的指定部分
            fileWriter.write("加油啊小简".toCharArray(), 0, 3);
            // 4) write（string）：写入整个字符串
            fileWriter.write(" 你好啊~");
            // 5)write(string, off, len):写入字符串的指定部分
            fileWriter.write("一起学Java", 0, 2);
        //在数据量大的情况下，可以使用循环操作.
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //对于FileWriter , 一定要关闭流，或者flush 才能真正的把数据写入到文件
            try {
                //fileWriter.flush();
                //关闭文件流，等价flush() + 关闭
                fileWriter.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        System.out.println("程序结束...");
    }
}

节点流&处理流

节点流可以从一个特定的数据源读写数据，如FileReader、 FileWriter
处理流(也叫包装流)是”连接”在已存在的流(节点流或处理流)之上，为程序提供更为强大的读写功能，也更加灵活，如BufferedReader、BufferedWriter

节点流和处理流一览图

节点流和处理流区别

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

处理流之缓冲流

BufferedReader

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

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

public class BufferedReader_ {
    public static void main(String[] args) throws IOException {
        String filePath = "/Users/jianjian/Downloads/hello.txt";
        //创建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 ，因为底层会自动的去关闭节点流
        bufferedReader.close();
    }
}

关闭流时，只需要关闭外层流(处理流)即可，因为底层会自动的去关闭节点流

BufferedWriter

使用 BufferedWriter 将 ”hello, World”，写入到文件中

package com.jwt.writer_;

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

public class BufferedWriter_ {
    public static void main(String[] args) throws IOException {
        String filePath = "/Users/jianjian/Downloads/hello.txt";
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(filePath,true));//以追加的方式写入
        bufferedWriter.write("Hello,World");
        bufferedWriter.newLine();//插入一个和系统相关的换行
        bufferedWriter.write("Hi,World");
        bufferedWriter.newLine();
        //关闭外层流即可， 传入的new FileWriter(filePath) ,会在底层关闭
        bufferedWriter.close();
    }
}

例子🌰：综合使用 BufferedReader 和 BufferedWriter 完成文本文件拷贝，注意文件编码

BufferedReader 和 BufferedWriter 是按照字符操作
不要去操作二进制文件[声音，视频，doc, pdf ], 可能造成文件损坏

package com.jwt.writer_;

import java.io.*;

public class BufferedCopy_ {
    public static void main(String[] args) {
        String srcFilePath = "/Users/jianjian/Downloads/hello.txt";
        String destFilePath = "/Users/jianjian/Downloads/test/hello.txt";
        BufferedReader bufferedReader = null;
        BufferedWriter bufferedWriter = null;
        String data;
        try {
            bufferedReader = new BufferedReader(new FileReader(srcFilePath));
            bufferedWriter = new BufferedWriter(new FileWriter(destFilePath));
            //说明: readLine 读取一行内容，但是没有换行
            while ((data=bufferedReader.readLine()) != null) {
                //每读取一行，就写入
                bufferedWriter.write(data);
                //插入一个换行
                bufferedWriter.newLine();
            }
            System.out.println("拷贝完毕...");
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                //关闭流
                if (bufferedReader != null){
                    bufferedReader.close();
                }
               if (bufferedWriter != null){
                   bufferedWriter.close();
               }

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

BufferedInputStream & BufferedOutputStream

BufferedInputStream 是字节流，在创建 BufferedInputStream时，会创建一个内部缓冲区数组
BufferedOutputStream 是字节流，实现缓冲的输出流，可以将多个字节写入底层输出流中，而不必对每次字节写入调用底层系统

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

package com.jwt.writer_;

import java.io.*;

public class BufferedCopy02 {
    public static void main(String[] args) {
        String srcFilePath = "/Users/jianjian/Downloads/a.jpeg";
        String destFilePath = "/Users/jianjian/Downloads/test/a.jpeg";
        BufferedInputStream bufferedInputStream = null;
        BufferedOutputStream bufferedOutputStream = null;
        int data;
        try {
            bufferedInputStream = new BufferedInputStream(new FileInputStream(srcFilePath));
            bufferedOutputStream = new BufferedOutputStream(new FileOutputStream(destFilePath));
            //循环的读取文件，并写入到destFilePath
            byte[] buff = new byte[1024];
            int readLen = 0;
            //当返回-1 时，就表示文件读取完毕
            while ((readLen=bufferedInputStream.read(buff)) != -1) {
                //每读取一行，就写入
                bufferedOutputStream.write(buff,0,readLen);
            }
            System.out.println("拷贝完毕...");
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                //关闭流
                if (bufferedInputStream != null){
                    bufferedInputStream.close();
                }
                if (bufferedOutputStream != null){
                    bufferedOutputStream.close();
                }

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

处理流之对象流

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

看一个需求

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

序列化和反序列化

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

注意事项和细节说明

1)读写顺序要一致
2)要求序列化或反序列化对象，需要实现 Serializable 接口
3)序列化的类中建议添加SerialVersionUID,为了提高版本的兼容性
4)序列化对象时，默认将里面所有属性都进行序列化，但除了static或transient修饰的成员
5)序列化对象时，要求里面属性的类型也需要实现序列化接口
6)序列化具备可继承性，也就是如果某类已经实现了序列化，则它的所有子类也已经默认实现了序列化

ObjectOutputStream

ObjectOutputStream 提供序列化功能
序列化对象，需要实现Serializable

例子🌰：使用 ОbjесtОutрutЅtrеаm 序列化基本数据类型和一个 Dоg 对象(nаmе, аgе), 并保存到 data.dat 文件中

package com.jwt.outputstream_;

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

public class ObjectOutStream_ {
    public static void main(String[] args) throws Exception {
        //序列化后，保存的文件格式，不是存文本，而是按照他的格式来保存
        String filePath = "/Users/jianjian/Downloads/b.dat";
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(filePath));
        //序列化数据到filePath
        oos.writeInt(100);// int -> 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("数据保存完毕(序列化形式)");
    }
static class Dog implements Serializable {
    String name;
    int age;
    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }
}
}

ObjectInputStream

ObjectInputStream 提供反序列化功能
反序列化对象，需要实现Serializable

例子🌰：使用 ObjectInputStream 读取 data.dat 并反序列化恢复数据

package com.jwt.inputstream_;

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

public class ObjectInputStream_ {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        // 1.创建流对象
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("/Users/jianjian/Downloads/b.dat"));
        // 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());
        System.out.println(ois.readObject());
        // 3.关闭
        ois.close();
        System.out.println("以反序列化的方式读取(恢复)ok~");
    }
}

标准输入输出流

名称	类型	默认设备
System.in 标准输入流	InputStream	键盘
System.out 标准输出流	OutputStream	显示器

package com.jwt.standard;

import java.util.Scanner;

public class InputOutput {
    public static void main(String[] args) {
        //1.源码：public final static Inputstream in = null;
        //2.System.in 编译类型 Inputstream
        //3.System.in 运行类型 BufferedInputstream
        //4.表示的是标准输入 键盘
        System.out.println(System.in.getClass());
        Scanner scanner = new Scanner(System.in);
        System.out.println("输入：");
        System.out.println("输出：" + scanner.next());

        //1.源码：public final static PrintStream out = null;
        //2.编译类型 Printstream
        //3.运行类型 Printstream
        //4.表示标准输出 显示器
        System.out.println(System.out.getClass());
        System.out.println("hello，你好～");
    }
}

转换流

InputStreamReader:Reader的子类，可以将InputStream(字节流)包装成(转换)Reader(字符流), 它读取字节，并使用指定的字符集将其解码为字符。
OutputStreamWriter:Writer的子类，实现将OutputStream(字节流)包装成Writer(字符流)
当处理纯文本数据时，如果使用字符流效率更高，并且可以有效解决中文问题，所以建议将字节流转换成字符流
可以在使用时指定编码格式(比如utf- 8, gbk，gb2312, IS08859-1等)

InputStreamReader

例子🌰：编程将字节流 FileInputStream 包装成(转换成)字符流 InputStreamReader，对文件进行读取(按照utf-8/gbk格式)，进而在包装成BufferedReader

package com.jwt.transformation;

import java.io.*;

public class InputStreamReader_ {
    public static void main(String[] args) throws IOException {
        String filePath = "/Users/jianjian/Downloads/a.txt";
        //1. 把FileInputStream 转成InputStreamReader,指定编码gbk
        InputStreamReader isr = new InputStreamReader(new FileInputStream(filePath),"gbk");
        //2. 把InputStreamReader 传入BufferedReader
        BufferedReader br = new BufferedReader(isr);
        //将1和2合在一起
        //BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(filePath), "gbk"));
        //3. 读取
        String s = br.readLine();
        System.out.println("读取内容=" + s);
        //4. 关闭外层流
        br.close();
    }
}

OutputStreamWriter

例子🌰：编程将字节流 FileOutputStream 包装成(转换成)字符流 OutputStreamWriter，对文件进行写入(按照gbk格式，可以指定其他，比如utf-8)

package com.jwt.transformation;

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

public class OutputStreamWriter_ {
    public static void main(String[] args) throws IOException {
        // 1.创建流对象
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("/Users/jianjian/Downloads/a.txt"), "gbk");
        // 2.写入
        osw.write("hello,你好呀~");
        // 3.关闭
        osw.close();
        System.out.println("保存成功~");
    }
}

打印流

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

PrintStream

package com.jwt.transformation;

import org.junit.Test;

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

public class PrintStream_ {
    @Test
    //标准输出到屏幕
    public void write01() throws IOException {
        PrintStream printStream = new PrintStream(System.out);
        printStream.print("hello,你好");
        //printStream.write("hello,你好".getBytes());
        printStream.close();
    }
    @Test
    //修该打印流输出位置
    public void write02() throws FileNotFoundException {
        System.setOut(new PrintStream("/Users/jianjian/Downloads/a.txt"));
        System.out.println("你好呀");
    }
}

PrintWriter

package com.jwt.transformation;

import org.junit.Test;

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

public class PrintWriter_ {
    @Test
    //标准输出到屏幕
    public void write01(){
        PrintWriter printWriter = new PrintWriter(System.out);
        printWriter.print("hello,你好");
        printWriter.close();
    }

    @Test
    //输出到文件
    public void write02() throws IOException {
        PrintWriter printWriter = new PrintWriter(new FileWriter("/Users/jianjian/Downloads/a.txt"));
        printWriter.print("hello,你好");
        printWriter.close();
    }
}

Properties类

问题引出

如下一个配置文件 mysql.properties

user=root
password=12345

请问编程读取 user 和 password 的值是多少？

传统方法

package com.jwt.io.properties_;
import org.junit.Test;
import java.io.*;
import java.util.Properties;

public class Properties01 {
    //传统的方法
    @Test
    public void traditionRead() throws IOException {
        BufferedReader bufferedReader = new BufferedReader(new FileReader("src//mysql.properties"));
        String line = "";
        while ((line = bufferedReader.readLine()) != null){
            String[] split = line.split("=");
            //如果我们要求指定的值
            if("user".equals(split[0])) {
                System.out.println("用户名=" + split[1]);
            }
            if("password".equals(split[0])) {
                System.out.println("密码=" + split[1]);
            }
        }
        bufferedReader.close();
    }
}

使用Properties类

package com.jwt.io.properties_;
import org.junit.Test;
import java.io.*;
import java.util.Properties;

public class Properties01 {
    @Test
    public void propertiesRead() throws IOException {
        //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("password");
        System.out.println("用户名=" + user);
        System.out.println("密码是=" + pwd);
    }
}

Properties 介绍

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

配置文件的格式:

键=值
键=值

注意:键值对不需要有空格，值不需要用引号引起来，默认类型是String

Properties的常见方法

load()：加载配置文件的键值对到Properties对象
list()：将数据显示到指定设备
getProperty(key)：根据键获取值
setProperty(key,value)：设置键值对到Properties对象
store(arg0,arg1)：将Properties中的键值对存储到配置文件，在idea中，保存信息到配置文件，如果含有中文，会存储为unicode码
- 第一个参数为 OutputStream/Writer 用来指向加载的配置文件
- 第二个参数为 String 用来给配置文件添加注释。
http://tool.chinaz.com/tools/unicode.aspx unicode码查询工具

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

要点：使用Properties 类来创建配置文件, 修改配置文件内容

1.如果该文件没有key就是创建
2.如果该文件有key就是修改

package com.jwt.io.properties_;

import org.junit.Test;

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

public class Properties01 {
    @Test
    public void insertProperties() throws IOException {
        Properties properties = new Properties();
        //添加
        properties.setProperty("test","123");
        properties.setProperty("user", "汤姆");//保存时，是中文的unicode 码值
        properties.store(new FileWriter("src//mysql.properties2"), null);
//        properties.store(new FileOutputStream("src//mysql.properties2"),null);
        System.out.println("保存配置文件成功~");
        //读取
        Properties properties2 = new Properties();
        properties2.load(new FileReader("src//mysql.properties2"));
        properties2.list(System.out);
        //修改
        properties2.setProperty("test","456");
        properties2.store(new FileWriter("src//mysql.properties2"),"测试一下下");
        System.out.println("修改成功~");
    }
}

IO练习

1.编程题Homework01.java

(1)在判断是否有文件夹mytemp ,如果没有就创建mytemp
(2)在mytemp目录下，创建文件hello.txt
(3)如果hello.txt已经存在，提示该文件已经存在，就不要再重复创建了
(4)并且在hello.txt文件中，写入hello,world~

package com.jwt.io.homework;
import java.io.*;

public class Homework01
{
    public static void main(String[] args) throws IOException {
        String directory = "/Users/jianjian/Downloads/mytemp";
        File file = new File(directory);
        if (!file.exists()) {
            file.mkdirs();
            System.out.println("目录创建成功");
        } else {
            System.out.println("目录已存在");
        }
        String filePath = directory + "/hello.txt";
        File file2 = new File(filePath);
        if (!file2.exists()){
            file2.createNewFile();
            System.out.println("文件创建成功");
            FileWriter fileWriter = new FileWriter(filePath);
            fileWriter.write("hello,world~");
            System.out.println("文本写入成功");
            fileWriter.close();
        } else{
            System.out.println("文件已存在");
        }
    }
}

2.编程题Homework02.java

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

如果把文件的编码改成了gbk ,出现中文乱码，如何解决？
1.默认是按照utf-8处理，开始没有乱码
2.提示:使用转换流，将FilelnputStream -> InputStreamReader[指定编码] -> BufferedReader

package com.jwt.io.homework;

import java.io.*;

public class Homework02 {
    public static void main(String[] args){
        String filePath = "/Users/jianjian/Downloads/hello.txt";
        BufferedReader bufferedReader = null;
        String line = "";
        int linenum = 0;
        try {

            bufferedReader = new BufferedReader(new FileReader(filePath));
            while ((line = bufferedReader.readLine()) != null) {
                System.out.println(++linenum + line);
            }

            //1. 把FileInputStream转成InputStreamReader,指定编码gbk
            InputStreamReader isr = new InputStreamReader(new FileInputStream(filePath),"gbk");
            //2. 把InputStreamReader 传入BufferedReader
            BufferedReader br = new BufferedReader(isr);
            while ((line = br.readLine()) != null) {
                System.out.println(++linenum + line);
            }
            
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (bufferedReader != null) {
                try {
                    bufferedReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

}

3.编程题Homework03.java

(1)编写一个 dog.properties

name=tom
age=5
color=red

(2)编写 Dog 类 (name,age,color) 创建一个 dog 对象，读取 dog.properties 用相应的内容完成属性初始化，并输出
(3)将创建的Dog对象,序列化到文件dog.dat文件
(4)再读取 dog.dat 并反序列化恢复数据

package com.jwt.io.homework;

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

public class Homework03 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        Properties properties = new Properties();
        properties.load(new FileReader("src//dog.properties"));
        String name = properties.getProperty("name");
        int age = Integer.parseInt(properties.getProperty("age"));
        String color = properties.getProperty("color");
        Dog dog = new Dog(name, age, color);
        System.out.println(dog);
        
        //将创建的Dog对象,序列化到文件dog.dat文件
        String filePath = "/Users/jianjian/Downloads/dog.dat";
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(filePath));
        oos.writeObject(dog);
        oos.close();
        System.out.println("数据保存完毕(序列化形式)");

        // 反序列化dog
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(filePath));
        System.out.println(ois.readObject());
        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 + '\'' +
                '}';
    }
}

❤️Sponsor

您的支持是我不断前进的动力，如果您恰巧财力雄厚，又感觉本文对您有所帮助的话，可以考虑打赏一下本文，用以维持本博客的运营费用，拒绝白嫖，从你我做起！🥰🥰🥰

支付宝支付	微信支付

简简

https://jwt1399.top/posts/52970.html

本博客所有文章除特別声明外，均采用 CC BY 4.0 许可协议。转载请注明来源简简 !

IO流

评论填上邮箱会收到评论回复提醒哦!!!

牛客-SQL练习

小简计划入门篇：【题数：39道题】【难度：🌟🌟｜用时：3☀️】必会篇：【题数：50道题】【难度：🌟｜用时：3☀️】进阶篇：【题数：46道题】【难度：🌟🌟🌟｜用时：7☀️】真题篇：【题数：3

2022-02-28 SQL

MySQL

Java-线程

前言哈喽！大家好，我是小简。今天开始学习《Java-线程》，此系列是我做的一个 “Java 从 0 到 1 ” 实验，给自己一年左右时间，按照我自己总结的 Java-学习路线，从 0 开始学 Java 知识，并不定期更新所学笔记，期待一年后

2022-02-22 JavaSE

多线程

前言

IO流简介

流分类

体系图

文件操作

创建文件

获取文件信息

目录操作

字节流

FileInputStream

单字节读取

多字节读取

FileOutputStream

字符流

FileReader

FileWriter

节点流&处理流

节点流和处理流一览图

节点流和处理流区别

处理流之缓冲流

BufferedReader

BufferedWriter

BufferedInputStream & BufferedOutputStream

处理流之对象流

ObjectOutputStream

ObjectInputStream

标准输入输出流

转换流

InputStreamReader

OutputStreamWriter

打印流

PrintStream

PrintWriter

Properties类

问题引出

传统方法

使用Properties类

Properties 介绍

IO练习

1.编程题Homework01.java

2.编程题Homework02.java

3.编程题Homework03.java

❤️Sponsor

你的赏识是我前进的动力