Java - IO

Erzbir

2023-05-26

java 笔记

介绍:

Input Output Stream

狭义: 数据在内存中输入和输出, 本地进程间的数据流动

广义: 不同电脑之间的数据流动, 远程进程间的数据流动

流的流动方式(数据的传输方向) :

输入流
输出流

流的数据格式:

字节流
字符流

File对象:

Java封装的一个操作文件及文件夹的对象

返回值	方法	描述
	File(String pathname)	构造方法
	File(String parent, String child)	构造方法
	File(File parent, String child)	构造方法
	File(URI uri)	构造方法, 用于网络
boolean	createNewFile() throws IOException	创建文件, 已存在就返回 `false`, 不存在就新建, 需要处理异常
boolean	exists()	是否存在
boolean	canExecute()	是否有执行权限
boolean	canWrite()	是否有写权限
boolean	canRead()	是否有读权限
boolean	delete()	删除文件
void	deleteOnExit()	在JVM退出时删除文件
File	getAbsoluteFile()	返回绝对路径对象
String	getAbsolutePath()	返回绝对路径
long	getFreeSpace()	空闲空间
long	getUsableSpace()	可用空间
long	getTotalSpace()	总空间
long	length()	返回文件大小
String	getName()	获取文件名
String	getParent()	获取父级路径, 必须使用绝对路径对象
String	getPath()	返回全路径
String	getParentFile()
boolean	isHidden()	是否为隐藏文件
long	lastModified()	返回最后修改时间戳
boolean	isDirectory()	是否为一个文件夹
boolean	mkdir()	创建文件夹, 只能创建一个不能递归创建
boolean	mkdirs()	递归创建文件夹
boolean	renameTo(File dest)	剪切, 移动文件
String[]	list()	将文件夹下的文件返回成一个字符串数组
File[]	listFiles()	将文件夹下的文件返回成一个 `File` 对象数组
String[]	list(FilenameFilter filter)	过滤文件
File[]	listFiles(FilenameFilter filter)	过滤文件

IO流分类:

InputStream 字节输入流
OutputStream 字节输出流
Reader 字符输入流
Writer 字符输出流

字节流:

InputStream(抽象类):

直接子类:

AudioStream
ByteArrayInputStream
FileStream
FilterInputStream
ObjectInputStream
PipedInputStream
SequenceInputStream
StringBufferInputStream

write() 写文件

int read() 读文件

close() 关闭流

flush() 刷新缓冲区

FileInputStream:

FileInputStream(String name)

FileInputStream(File file)

read() 读取文件

class Test {
    void test() {
        InputStream file = null;
        try {
            file = new FileInputStream(new File("./a.txt")); // 创建一个输入流对象
            byte[] buf = new byte[1024]; // 用于缓冲, 大小用2的整数倍, 最好用4k(4k对齐)
            int len = 0;
            while ((len = file.read(buf)) != -1) {
                // System.out.write(buf); // 此方法可能导致读取内容超出
                System.out.write(buf, 0, len);
                String str = new String(buf, 0, len);
                System.out.println(str);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (file != null) {
                try {
                    file.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

OutputStream(抽象类):

FileOutputStream

FileOutputStream:

class Test {
    void test() {
        String msg = "你好";
        FileOutputStream file = null;
        try {
            file_out = new FileOutputStream(new File("b.txt"));
            file_in = new FileInputStream(new File("a.txt"));
            byte[] buf = new byte[1024];
            int len = 0;
            while ((len = file_in.read(buf)) != -1) {
                file_out = write(buf, 0, len);
            }
            System.out.ptintln("写入数据成功");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (file_in != null) {
                try {
                    file_in.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (file_out != null) {
                try {
                    file_out.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

FilterInputStream & FilterOutputStream:

装饰流, 又称为过滤流

不能直接使用, 主要的作用就是用来装饰节点流

本质是一种装饰者设计模式的体现. 对原有对象的功能进一步的装饰增强

GOF 23 设计模式:

单例设计模式
装饰者设计模式

子类:

BufferedInputStream
BufferedOutputStream
DataInputStream
DataOutputStream

BufferedInputStream & BufferedOutputStream:

class Test {
    void test() {
        BufferedInputStream bis = null; // 缓冲池
        BufferedOutputStream bos = null;
        try {
            bis = new BufferedInputStream(new FileInputStream("a.txt")); // 建议把字节流写在里面, 这样不用单独关闭
            bos = new BufferedOutputStream(new FileOutputStream("b.txt"));
            byte[] buf = new byte[1024 * 8];
            int len = 0;
            while ((len = bis.read(buf)) != -1) {
                bos, write(buf, 0, len);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 缓存流必须关闭, 因为JVM
            if (bis != null) {
                try {
                    bis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (bos != null) {
                try {
                    bos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

DataOutputStream:

可以不用转换成字节数组直接就进行写入

class Test {
    void test() {
        BufferedOutputStream bos = null;
        int msg = 1000000;
        try {
            dos = new DataOutputStream(new FileOutputStream("b.txt"));
            dos, writeInt(msg);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (dos != null) {
                try {
                    dos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

DataInputStream:

class Test {
    void test() {
        BufferedOutputStream bos = null;
        try {
            dis = new DataInputStream(new FileInputStream("a.txt"));
            System.out.println(dis.readInt());
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (dis != null) {
                try {
                    dis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

字符流:

计算机底层使用的二进制数据(字节数据)

字符流是为了加快流的操作, 而设计的专门用来操作字符串的一种流

注意: 字符串存在编码问题, 需要保证在读取和写入编码一致

建议使用装饰流按行读取

Reader(输入流):

class Test {
    void test() {
        Reader reader = null;
        try {
            reader = new FileReader(new File("/Users/erzbir/Desktop/IntelliJ Java/JavaTest/a.txt"));
            char[] buf = new char[1024];
            int len = 0;
            while ((len = reader.read(buf)) != -1) {
                writer.write(buf, 0, len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (reader != null) {
                try {
                    reader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

Writer(输出流):

class Test {
    void test() {
        Reader reader = null;
        Writer writer = null;
        try {
            writer = new FileWriter("/Users/erzbir/Desktop/IntelliJ Java/JavaTest/b.txt");
            reader = new FileReader(new File("/Users/erzbir/Desktop/IntelliJ Java/JavaTest/a.txt"));
            char[] buf = new char[1024];
            int len = 0;
            while ((len = reader.read(buf)) != -1) {
                writer.write(buf, 0, len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (reader != null) {
                try {
                    reader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (writer != null) {
                try {
                    writer.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

BufferedReader & BufferedWriter:

class Test {
    void test() {
        BufferedReader reader = null;
        BufferedWriter writer = null;
        try {
            writer = new BufferedWriter(new FileWriter("/Users/erzbir/Desktop/IntelliJ Java/JavaTest/b.txt"));
            reader = new BufferedReader(new FileReader(new File("/Users/erzbir/Desktop/IntelliJ Java/JavaTest/a.txt")));
            char[] buf = new char[1024];
            int len = 0;
            while (reader.readLine(buf) != null) {
                writer.write(buf + "\n");
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (reader != null) {
                try {
                    reader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (writer != null) {
                try {
                    writer.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

PrintWriter(打印输出流):

可以直接操作文件, 也可以操作对象

关闭时不会抛出异常

class Test {
    void test() {
        Reader reader = null;
        PrintWriter writer = null;
        try {
            PtintWriter = new PrintWriter("/Users/erzbir/Desktop/IntelliJ Java/JavaTest/b.txt");
            reader = new BufferedReader(new FileReader(new File("/Users/erzbir/Desktop/IntelliJ Java/JavaTest/a.txt")));
            char[] buf = new char[1024];
            while (reader.readLine(buf) != null) {
                writer.println(buf, 0, len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (reader != null) {
                try {
                    reader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (writer != null) {
                try {
                    writer.close();
                } catch (IOExcetion e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

转换流:

将字节流转换为字符流操作

当操作的是文本数据的时候使用

InputStreamReader:

可以将字节输入流转换为字符输入流

class Test {
    void test() throws IOException {
        BufferedReader br = null;
        br = new BufferedReader(new InputStreamReader(System.in));
        String str = null;
        while ((str = br.readLine()) != null) {
            System.out.println(str);
        }
        br.close();
    }
}

OutputStreamWriter:

字节输出流转换成字符输入流

class Test {
    void test() throws IOException {
        BufferedReader br = null;
        PrintWriter out = null;
        br = new BufferedReader(new InputStreamReader(System.in));
        out = new PrintWriter(new OutputStreamWriter(new FileOutputStream("b.txt")));
        String str = null;
        while ((str = br.readLine()) != null) {
            out.println(str);
        }
        br.close();
        out.close();
    }
}

对象流:

ObjectInputStream:

class Test {
    void test() {
        String msg;
        ObjectOutputStream ois = null;
        try {
            ois = new ObjectOutputStream(new FileOutputStream("a.txt"));
            msg = ois.readObject();
            System.out.ptintln(msg);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (ois != null) {
                try {
                    ois.close();
                } catch (IOException e) {
                    e.ptintStackTrace();
                }
            }
        }
    }
}

ObjectOutputStream

class Test {
    void test() {
        String msg = "1asda";
        ObjectOutputStream oos = null;
        try {
            oos = new ObjectOutputStream(new FileOutputStream("a.txt"));
            oos.writeObject(msg);
            System.out.ptintln("保存成功");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (oos != null) {
                try {
                    oos.close();
                } catch (IOException e) {
                    e.ptintStackTrace();
                }
            }
        }
    }
}

序列化:

如果一个类没有实现 Serializable 接口,那么它就不能被序列化,写入文件的时候会报异常.如果一个类实现了 Serializable 接口,那么这个类的所有属性和方法都可以自动被序列化

对象序列化:

Serialize: 将虚拟对象转换为一种可以直接传输或者保存的数据(字节, 字符)的过程

对象反序列化:

将序列化后的字节或者字符数据源重新转换为对象

对象持久化:

transient关键字:

被这个关节字修饰的属性, 无法持久化

将数据永久保存(存到磁盘)

java官方提供的序列化, 是将java对象转换为字节数据

注意: java对象序列化必须实现可序列化接口(Serializable), 这是一个标记接口自动调用底层

try-with-resources:

jdk7的新特性, 如果使用这种结构, 打开的资源会自动完成关闭

class Test {
    void test() {
        try (InputStream is = new FileInputStream("a.txt")) {
            byte[] buf = new byte[1024];
            int len = 0;
            while ((len = is.read(buf)) != -1) {
                System.out.println(new String(buf, 0, len));
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

开发中的问题:

在开发过程中, 如果直接将一些确定的值写在代码中, 代码的设计可能有问题, 如果生产环境, 要再次修改值会非常麻烦, 需要重新编译. 这种叫做硬编码

开发环境: development environment

测试环境: test environment

生产环境: product environment

如果值永久不变:

做成常量
做成枚举

如果有可能变:

可以做成配置文件

Java配置文件:

xml
json
yaml
properties