Java学习基础笔记——IO流

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

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

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

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

createNewFile 创建新文件
获取文件的相关信息

getName、getAbsolutePath、getParent、length、exists、isFile、isDirector

//应用案例演示

//如何获取到文件的大小，文件名，路径，父级File，是文件还是目录(目录本质也是文件，一种特殊的文件)，是否存在

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());
System.out.println("是不是一个文件=" + file.isFile());
System.out.println("是不是一个目录=" + file.isDirectory());

目录的操作和文件删除

mkdir 创建一级目录，mkdirs 创建多级目录，delete 删除空目录或文件

14.2 IO流原理及流的分类

14.2.1 Java IO流原理

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

14.2.2 流的分类

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

(抽象基类) 字节流字符流
输入流 InputStream Reader
输出流 OutputStream Writer
Java 的 IO 流共涉及40多个类，实际上非常规则，都是从如上4个抽象基类派生的
由这四个类派生出来的子类名称都是以其父类名作为子类名后缀

(抽象基类)	字节流	字符流
输入流	InputStream	Reader
输出流	OutputStream	Writer

14.3 FileInputStream 和 FileOutputStream

14.3.1 FileInputStream

   /**
     * 演示读取文件...
     * 单个字节的读取，效率比较低...
     */
    @Test
    public void readFile01() {
        String filePath = "e:/hello.txt";
        int readData = 0;
        FileInputStream fileInputStream = null;//放在这里是为了，扩大作用域，能够被catch {} & finally {} 访问到
        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;//放在这里是为了，扩大作用域，能够被catch {} & finally {} 访问到
        try {
            //创建 FileInputStream 对象，用于读取 文件
            fileInputStream = new FileInputStream(filePath);
            //从该输入流读取最多 buf.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();
            }
        }
    }

14.3.2 FileOutputStream

//得到 FileOutputStream 对象
//1. new FileOutputStream(filePath) 创建方式，当写入内容时，会覆盖原来的内容
//2. new FileOutputStream(filePath , true) 创建方式，当写入内容时，是追加到文件后面
fileOutputStream = new FileOutputStream(filePath , true);
//写入一个字节
//fileOutputStream.write('a');
//写入字符串
String str = "hello,world!";
//str.getBytes()  可以把  字符串 -> 字符数组
//fileOutputStream.write(str.getBytes());
fileOutputStream.write(str.getBytes(), 2, 3);

14.4 FileReader 和 FileWriter

14.4.1 FileReader相关方法

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

14.4.2 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)，否则写入不到指定的文件！

14.5 节点流和处理流

14.5.1 基本介绍

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

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

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

14.5.3 处理流的功能主要体现在以下两个方面

性能的提高：主要以增加缓冲的方式来提高输入输出的效率
操作的便捷：处理流可能提供了一系列的方法来一次输入输出大批量的数据，使用方法更加灵活方便

14.5.4 注意事项和使用细节

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

14.5.5 标准输入输出流

14.5.5.1 介绍

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

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

        //1. System 类的 public final static InputStream in = null;
        //2. System.in  编译类型  InputStream
        //3. System.in  运行类型  BufferedInputStream
        //4.表示标准输入  键盘
        System.out.println(System.in.getClass());

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

    }
}

14.6 BufferedInputStream 和 BufferedOutputStream

14.6.1 BufferedInputStream

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

14.6.2 BufferedOutputStream

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

14.7 BufferedReader 和 BufferedWriter

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

关闭处理流时，只需关闭外层流即可

14.7.1 BufferedReader

public class BufferedReader_ {
    public static void main(String[] args) throws Exception {

        String filePath = "e:/a.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();
    }
}

14.7.2 BufferedWriter

public class BufferedWriter_ {
    public static void main(String[] args) throws Exception {

        String filePath = "e:/ok.txt";
        //创建 bufferedWriter 对象
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(filePath));
        bufferedWriter.write("Andy & Wink");

        //插入一个和系统相关的换行
        bufferedWriter.newLine();

        bufferedWriter.write("Java Die~");

        //关闭流
        bufferedWriter.close();
    }
}

14.8 对象流-ObjectInputStream 和 ObjectOutputStream

14.8.1 序列化和反序列化

序列化就是在保存数据时，保存数据的值和数据类型
反序列化就是在回复数据时，恢复数据的值和数据类型
需要让某个对象支持序列化机制，则必须让其是可序列化的，为了让某个类是可序列化的，该类必须实现如下两个接口之一：

*Serializable //这是一个标记接口

*Externalizable

14.8.2 基本介绍

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

public class ObjectOutputStream_ {
    public static void main(String[] args) throws Exception {

        //序列化后，保存的文件格式，不是纯文本，而是按照它的格式来保存
        String filePath = "e:\\data.dat";

        //创建 ObjectOutputStream 对象
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(filePath));

        //序列化数据到  "e:\\data.dat" 中
        oos.writeInt(100);// int -> Integer (实现了 Serializable)
        oos.writeBoolean(true);// boolean -> Boolean (实现了 Serializable)
        oos.writeChar('a');// char -> Character (实现了 Serializable)
        oos.writeDouble(3.7);// double -> Double (实现了 Serializable)
        oos.writeUTF("Andy");// String (实现了 Serializable)
        //保存一个 dog 对象
        oos.writeObject(new Dog("小黄", 3));

        //关闭流
        oos.close();

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

    }
}

ObjectInputStream 提供反序列化功能

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());
        Object dog = ois.readObject();
        System.out.println("运行类型=" + dog.getClass());
        System.out.println("dog的信息=" + dog);
        //这里是特别重要的细节：
        //1. 如果我们希望调用 Dog 的方法，需要向下转型
        //2. 需要我们将 Dog 类的定义，放到可以引用的位置
        Dog dog2 = (Dog) dog;
        System.out.println(dog2.getName());
        System.out.println(dog2.getAge());
        //关闭流,外层流
        ois.close();
    }
}

14.9 转换流-InputStreamReader 和 OutputStreamWriter

14.9.1 基本介绍

//InputStreamReader: Reader的子类，可以将InputStream(字节流)包装成Reader(字符流)

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

        String filePath = "e:/a.txt";

        //指定编码 gbk
//        InputStreamReader isr = new InputStreamReader(new FileInputStream(filePath), "gbk");
//        BufferedReader br = new BufferedReader(isr);

        BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(filePath),"gbk"));
        String s = br.readLine();
        System.out.println("读取内容=" + s);

        //关闭外层流
        br.close();
    }
}

//OutputStreamWriter: Writer的子类，可以将OutputStream(字节流)包装成Writer(字符流)

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

        String filePath = "e:/kk.txt";
        String charSet = "gbk";

        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(filePath), "gbk");

        osw.write("Andy& kk~");

        osw.close();

        System.out.println("按照 " + charSet + " 编码方式保存文件成功");

    }
}

当处理纯文本数据时，如果使用字符流效率更高，并且可以有效解决中文问题，所以建议将字节流转换成字符流
可以在使用时指定编码格式(比如 utf-8, gbk, gb2312, ISO8859-1 等)

14.10 打印流-PrintStream 和 PrintWriter

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

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

        PrintStream out = System.out;

        //在默认情况下，PrintStream  输出数据的位置是 标准输出， 即 显示器
        out.println("hello,world~");
        out.write("人工智能".getBytes());

        out.close();

        //修改输出位置/设备
        System.setOut(new PrintStream("e:/ff.txt"));
        System.out.println("我亦无他,唯手熟尔");

    }
}

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:/tt.txt"));
        printWriter.println("java fff!");
        printWriter.close();
    }
}

14.11 Properties 类

14.11.1 基本介绍

专门用于读写配置文件的集合类
- 配置文件的格式
  - 键=值
  - 键=值
注意：键值对不需要有空格，值不需要用引号引起来，默认类型是String
Properties 的常见方法

*load：加载配置文件的键值对到Properties对象

*list：将数据显示到指定设备

*getProperty(key)：根据键获取值

*setProperty(key,value)：设置键值对到Properties对象

*store：将Properties中的键值对存储到配置文件，在IDEA中，保存信息到配置文件，如果含有中文，会存储为unicode码