java学习笔记

java-保姆级IO流详解

2020-09-24  本文已影响0人  吾乃零陵上将军邢道荣是也

一、File类

1.1 概述

java.io.File类是文件和目录路径名的抽象表示，主要用于文件和目录的创建、查找和删除等操作。

抽像：

1.2 构造方法

// 文件路径名
        String pathname1 = "/Users/abc/a.txt";
        File file1 = new File(pathname1);

        // 文件路径名
        String pathname2 = "/Users/abc/b.txt";
        File file2 = new File(pathname2);

        // 通过父路径和子路径字符串
        String parent = "/Users/abc";
        String child1 = "c.txt";
        File file3 = new File(parent, child1);

        // 通过父级File对象和子路径字符串
        File parentDir = new File("/Users/abc");
        String child2 = "d.txt";
        File file4 = new File(parentDir, child2);

提示：

1.3 常用方法

获取功能的方法

方法演示，代码如下：

// 文件路径名
        String pathname = "/Users/abc/a.txt";
        File file = new File(pathname);

        System.out.println("文件绝对路径:"+file.getAbsolutePath());
        System.out.println("文件构造路径:"+file.getPath());
        System.out.println("文件名称："+file.getName());
        System.out.println("文件长度"+file.length()+"字节");

        System.out.println("-----------------------------");
        // 目录路径名
        String pathname2="/Users/abc";
        File file2=new File(pathname2);
        System.out.println("目录绝对路径:"+file2.getAbsolutePath());
        System.out.println("目录构造路径:"+file2.getPath());
        System.out.println("目录名称："+file2.getName());
        System.out.println("目录长度"+file2.length()+"字节");

输出结果：
文件绝对路径:/Users/abc/a.txt
文件构造路径:/Users/abc/a.txt
文件名称：a.txt
文件长度100字节
-----------------------------
目录绝对路径:/Users/abc
目录构造路径:/Users/abc
目录名称：abc
目录长度608字节

判断功能的方法

方法演示，代码如下：

File f = new File("/Users/abc/a.txt");
        File f2 = new File("/Users/abc");
        // 判断是否存在
        System.out.println("/Users/abc/a.txt 是否存在:"+f.exists());
        System.out.println("/Users/abc 是否存在:"+f2.exists());
        // 判断是文件还是目录
        System.out.println("/Users/liudonghui/abc 文件?:"+f2.isFile());
        System.out.println("/Users/abc 目录?:"+f2.isDirectory());

输出结果:
/Users/abc/a.txt 是否存在:true
/Users/abc 是否存在:true
/Users/abc 文件?:false
/Users/abc 目录?:true

创建删除功能的方法

方法演示，代码如下：

        // 文件的创建
        File f = new File("aaa.txt");
        System.out.println("是否存在:"+f.exists());// false
        System.out.println("是否创建:"+f.createNewFile()); // true
        System.out.println("是否存在:"+f.exists()); // true

        // 目录的创建
        File f2= new File("newDir");
        System.out.println("是否存在:"+f2.exists());// false
        System.out.println("是否创建:"+f2.mkdir()); // true
        System.out.println("是否存在:"+f2.exists());// true

        // 创建多级目录
        File f3= new File("newDira\\newDirb");
        System.out.println(f3.mkdir());// false
        File f4= new File("newDira\\newDirb");
        System.out.println(f4.mkdirs());// true

        // 文件的删除
        System.out.println(f.delete());// true

        // 目录的删除
        System.out.println(f2.delete());// true
        System.out.println(f4.delete());// false

说明：delete方法，如果此File表示的是目录，则此目录必须为空才能删除。

1.4 目录的遍历

例子：递归打印多级目录
代码如下：

public class RecursionDemo {
    public static void main(String[] args) {
        File dir=new File("/Users/abc");

        getDirAndFiles(dir);
    }

    private static void getDirAndFiles(File dir) {
        File[] files = dir.listFiles();
        for (File file:files) {
            if (file.isFile()){
                System.out.println("文件名："+file.getAbsolutePath());
            }else{
                System.out.println("目录："+file.getAbsolutePath());
                getDirAndFiles(file);
            }
        }

    }
}

二、字节流和字符流

2.1 什么是IO

I:Input即输入。
O:Output即输出。
这里的输入输出以内存为基准,即流向内存的是输入流，流出内存的是输出流。
java中的I/O操作主要是指使用java.io包下的内容，进行输入输出操作。

2.2 IO的分类

根据数据的流向分为：输入流和输出流。

根据数据的类型分为：字节流和字符流。

javaIO中有40多个类，但他们之间关系精密，都是从下面四个抽象基类派生出来的。

javaIO的顶级父类们.png

按照操作方式分类结构图：

按照操作对象分类结构图：

摘自 JavaGuide v2.0突击版 p50

2.3 字节流

首先要明白对于一切文件数据(文本、图片、视频等)在存储时，都是以二进制数字的形式保存，都一个一个的字节，那么传输时一样如此。所以，字节流可以传输任意文件数据。在操作流的时候，我们要时刻明确，无论使用什么样的流对象，底层传输的始终为二进制数据。

2.3.1 字节输出流【OutputStream】

java.io.OutputStream抽象类是表示字节输出流的所有类的超类，将指定的字节信息写出到目的地。它定义了字节输出流的基本共性方法。

FileOutputStream类

FileOutputStream是OutputStream最常用的一个子类。
java.io.FileOutputStream类是文件输出流，用于将数据写出到文件。

构造方法：

当你创建一个流对象时，必须传入一个文件路径。该路径下，如果没有这个文件，会创建该文件。如果有这个文 件，会清空这个文件的数据。

其他常用方法：

public class FOSWrite {
    public static void main(String[] args) throws IOException {
       // 使用文件名称创建流对象       
       FileOutputStream fos = new FileOutputStream("fos.txt"); 
       // 写出数据 
       fos.write(97); 
       // 写出第1个字节
       fos.write(98); 
       // 写出第2个字节 
       fos.write(99); 
       // 写出第3个字节 
       // 关闭资源 
       fos.close(); 
    }
}
输出结果： 
abc

public class FOSWrite { 
        public static void main(String[] args) throws IOException { 
            // 使用文件名称创建流对象 
            FileOutputStream fos = new FileOutputStream("fos.txt"); 
            // 字符串转换为字节数组 
            byte[] b = "你好".getBytes(); 
            // 写出字节数组数据 
            fos.write(b); 
            // 关闭资源 
            fos.close();
        } 
    }
    输出结果：你好

public class FOSWrite { 
    public static void main(String[] args) throws IOException { 
        // 使用文件名称创建流对象 
        FileOutputStream fos = new FileOutputStream("fos.txt"); 
        // 字符串转换为字节数组 
        byte[] b = "abcde".getBytes(); 
        // 写出从索引2开始，2个字节。索引2是c，两个字节，也就是cd。 
        fos.write(b,2,2); 
        // 关闭资源 
        fos.close(); 
    } 
}
输出结果： cd

数据追加写
上面的方法，每次创建输出流，都会情况目标文件中的数据。下面介绍能够保留目标文件中的数据，并能继续添加新数据的方法。

只有在这两个构造方法中传入一个boolean类型的参数值，其中true表示追加数据，false表示清空原有数据。其余实现步骤与上面一样。

写出换行
代码演示：

public class FOSWrite { 
    public static void main(String[] args) throws IOException { 
        // 使用文件名称创建流对象 
        FileOutputStream fos = new FileOutputStream("fos.txt"); 
        // 定义字节数组 
        byte[] words = {97,98,99,100,101}; 
        // 遍历数组 
        for (int i = 0; i < words.length; i++) { 
            // 写出一个字节 
            fos.write(words[i]); 
            // 写出一个换行, 换行符号转成数组写出 
            fos.write("\r".getBytes()); 
        }
        // 关闭资源 
        fos.close(); 
    } 
}
输出结果：
a
b
c
d
e

提示：

2.3.2 字节输入流【InputStream】

java.io.InputStream抽象类是表示字节输入流的所有类的超类，可以读取字节信息到内存中。它定义了字节输入流的基本共性功能方法。

FileInputStream类

java.io.FileInputStream类是文件输入流，从文件中读取字节。

构造方法：

当你创建一个文件输入流对象是，必须传入一个文件路径。该路径下，如果没有该文件，会抛出FileNotFoundException

常用方法

public class FISRead { 
    public static void main(String[] args) throws IOException{ 
        // 使用文件名称创建流对象 
        FileInputStream fis = new FileInputStream("read.txt"); 
        // 定义变量，保存数据
        int b; 
        // 循环读取
        while((b=fis.read())!=-1){
            System.out.println((char)b);
        }
        // 关闭资源 
        /fis.close(); 
    } 
}
输出结果：
a
b
c
d
e
-1

public class FISRead {
    public static void main(String[] args) throws IOException{
        // 使用文件名称创建流对象.
        FileInputStream fis = new FileInputStream("read.txt");// 文件中为abcde
        // 定义变量，作为有效个数
        int len ；
        // 定义字节数组，作为装字节数据的容器
        byte[] b = new byte[2];
        // 循环读取
        while (( len= fis.read(b))!=‐1) {
            // 每次读取后,把数组变成字符串打印
            System.out.println(new String(b));
        }
        // 关闭资源
        fis.close();
    }
}

输出结果：
ab
cd
ed

这段代码有个问题，最后一个数据ed是错误的，这是由最后一次读取时，只读取了一个字节e，数组中，上次读取的数据没有被完全替换。所以我们应该通过len，获取有效的字节，代码改进如下:

public class FISRead {
    public static void main(String[] args) throws IOException{
        // 使用文件名称创建流对象.
        FileInputStream fis = new FileInputStream("read.txt");// 文件中为abcde
        // 定义变量，作为有效个数
        int len ；
        // 定义字节数组，作为装字节数据的容器
        byte[] b = new byte[2];
        // 循环读取
        while (( len= fis.read(b))!=‐1) {
            // 每次读取后,把数组变成字符串打印
            System.out.println(new String(b,0,len));
        }
        // 关闭资源
        fis.close();
    }
}

输出结果：
ab
cd
e

使用数组读取可以每次读取多个字节，这减少了io的操作次数，提高了读写的效率，所以要常用数组读取。

2.4 字符流

当使用字节流读取文本文件时，可能会有一个小问题。就是遇到中文字符时，可能不会显示完整的字符，那是因为 一个中文字符可能占用多个字节存储。所以Java提供一些字符流类，以字符为单位读写数据，专门用于处理文本文件。

2.4.1 字符输入流【Reader】

java.io.Reader抽象类是表示用于读取字符流的所有类的超类，可以读取字符信息到内存中。它定义了字符输入 流的基本共性功能方法。

FileReader类

java.io.FileReader`类是读取字符文件的便利类。构造时使用系统默认的字符编码和默认字节缓冲区。

构造方法

类似于FileInputStream,当你要创建一个流对象是，必须传入一个文件路径。

其他方法

public class FRRead {
    public static void main(String[] args) throws IOException {
        // 使用文件名称创建流对象
        FileReader fr = new FileReader("read.txt");
        // 定义变量，保存数据 
        int b;
        // 循环读取 
        while ((b = fr.read())!=‐1) { 
            System.out.println((char)b); 
        }
        // 关闭资源 
        fr.close(); 
    } 
}
输出结果：
你
好
啊

public class FRRead {
    public static void main(String[] args) throws IOException {
        // 使用文件名称创建流对象
        FileReader fr = new FileReader("read.txt");
        // 定义变量，保存有效字符个数
        int len;
        // 定义字符数组，作为装字符数据的容器
        char[] cbuf=new char[2];
        // 循环读取
        while ((len = fr.read(cbuf))!=‐1) {
            System.out.println(new String(cbuf,0,len));
        }
        // 关闭资源
        fr.close();
    }
}
输出结果：
你好
啊

2.4.2 字符输出流【Writer】

java.io.Writer抽象类是表示用于写出字符流的所有类的超类，将指定的字符信息写出到目的在，它定义了字节输出流的基本共性功能方法。

FileWriter类

java.io.FileWriter类是写出字符到文件的便利类，构造时使用系统默认的字符编码和默认字节缓冲区。

构造方法

当你创建一个流对象时，必须传入一个文件路径，类似于FileOutputStream。

其他方法

若为调用close方法，数据只是保存到了缓冲区，并没写到文件中。

关闭和刷新
因为内置缓冲区的原因，如果不关闭输出流，无法写出字符到文件中。但是关闭的流对象，是无法继续写出数据 的。如果我们既想写出数据，又想继续使用流，就需要 flush 方法了。

public class FWWrite {
    public static void main(String[] args) throws IOException {
        // 使用文件名称创建流对象
        FileWriter fw = new FileWriter("fw.txt");
        // 字符串转换为字节数组
        char[] chars = "你好啊".toCharArray();
        
        // 写出字符数组
        fw.write(chars);// 你好啊 
        
        // 写出从索引1开始，2个字节。索引1是'好'，两个字节，也就是'好啊'。 
        fw.write(b,1,2); // 好啊 
        
        // 关闭资源 
        fos.close(); 
    } 
}

续写和换行：类似于FileOutputStream。

三、缓冲流、转换流和序列化流

3.1 缓冲流

缓冲流是对前面讲的4个基本的Filexxx流的增强，所以也是4个流，安装数据类型分类：

缓冲流的基本原理，是在创建流对象时，会创建一个内置的默认大小的缓冲区数组，通过缓冲区读写，减少系统 IO 次数，从而提高读写的效率。

3.1.1 字节缓冲流

构造方法

// 创建字节缓冲输入流 
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("bis.txt")); 
// 创建字节缓冲输出流 
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("bos.txt"));

3.1.2 字符缓冲流

构造方法

构造方法举例：

// 创建字符缓冲输入流 
BufferedReader br = new BufferedReader(new FileReader("br.txt")); 
// 创建字符缓冲输出流 
BufferedWriter bw = new BufferedWriter(new FileWriter("bw.txt"));

缓冲流的读写方法和基本流是一致的，只不过缓冲流大大提高了读写效率。

特有方法
字符缓冲流的基本方法与普通字符流调用方式一致，不再阐述，我们来看它们具备的特有方法。

readLine方法演示，代码如下：

public class BufferedReaderDemo { 
    public static void main(String[] args) throws IOException { 
        // 创建流对象 
        BufferedReader br = new BufferedReader(new FileReader("in.txt")); 
        // 定义字符串,保存读取的一行文字 
        String line = null; 
        // 循环读取,读取到最后返回null 
        while ((line = br.readLine())!=null) { 
            System.out.print(line); 
            System.out.println("‐‐‐‐‐‐"); 
        }
        // 释放资源 
        br.close(); 
    } 
}

newLine方法演示，代码如下：

public class BufferedWriterDemo throws IOException { 
    public static void main(String[] args) throws IOException { 
        // 创建流对象 
        BufferedWriter bw = new BufferedWriter(new FileWriter("out.txt")); 
        // 写出数据 
        bw.write("你好"); 
        // 写出换行 
        bw.newLine(); 
        bw.write("啊");
        // 释放资源 
        bw.close(); 
    } 
}
输出结果：
你好
啊

缓冲流的原理

3.2 转换流

编码引出的问题
在IDEA中，使用 FileReader 读取项目中的文本文件。由于IDEA的设置，都是默认的 UTF-8 编码，所以没有任何 问题。但是，当读取Windows系统中创建的文本文件时，由于Windows系统的默认是GBK编码，就会出现乱码。

**想要在IDEA中读取GBK编码的文件，就必须使用转换流了。

3.2.1 InputStreamReader类

转换流java.io.InputStreamReader ，是Reader的子类，是从字节流到字符流的桥梁。它读取字节，并使用指定 的字符集将其解码为字符。它的字符集可以由名称指定，也可以接受平台的默认字符集。

构造方法

构造举例，代码如下：

InputStreamReader isr = new InputStreamReader(new FileInputStream("in.txt")); 
InputStreamReader isr2 = new InputStreamReader(new FileInputStream("in.txt") , "GBK");

3.2.2 OutputStreamWriter类

转换流java.io.OutputStreamWriter,是Writer的子类，是从字符流到字节流的桥梁。使用指定的字符集将字符 编码为字节。它的字符集可以由名称指定，也可以接受平台的默认字符集。

构造方法

构造举例，代码如下：

OutputStreamWriter isr = new OutputStreamWriter(new FileOutputStream("out.txt")); 
OutputStreamWriter isr2 = new OutputStreamWriter(new FileOutputStream("out.txt") , "GBK");

转换流理解图解
转换流是字节与字符间的桥梁！

转换流原理.png

3.3 序列化

Java 提供了一种对象序列化的机制。用一个字节序列可以表示一个对象，该字节序列包含该对象的数据、 对象的类型和对象中存储的属性等信息。字节序列写出到文件之后，相当于文件中持久保存了一个对象的信息。

反之，该字节序列还可以从文件中读取回来，重构对象，对它进行反序列化。对象的数据、对象的类型和对象中存储的数据信息，都可以用来在内存中创建对象。看图理解序列化：

3.3.1 ObjectOutputStream类

java.io.ObjectOutputStream类，将java对象的原始数据类型写出到文件，实现对象的持久存储。

构造方法

FileOutputStream fileOut = new FileOutputStream("employee.txt"); 
ObjectOutputStream out = new ObjectOutputStream(fileOut);

序列化操作
1.一个对象要想序列化，必须满足两个条件：

public class Person implements Serializable {

    private static final long serialVersionUID=1l;

    private String name;
    public Integer age;
//    private static Integer age;
//    private transient Integer age;

    public Person(String name, Integer age) {
        this.name = name;
        this.age = age;
    }
  ......
}


public class Demo01ObjectOutputStream {

    public static void main(String[] args) throws IOException {
        ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("/Users/abc/person.txt"));

        oos.writeObject(new Person("小美人",18));

        oos.close();
    }
}

被注明为static和transient的属性不会被序列化。

3.3.2 ObjectInputStream类

ObjectInputStream反序列化流，将之前使用ObjectOutputStream序列化的原始数据恢复为对象。

构造方法

反序列化方法

public class Demo02ObjectInputStream {

    public static void main(String[] args) throws IOException, ClassNotFoundException {
        ObjectInputStream ois=new ObjectInputStream(new FileInputStream("/Users/abc/person.txt"));

        Object o = ois.readObject();

        ois.close();

        System.out.println(o);
    }
}

对于JVM可以反序列化对象，它必须是能够找到class文件的类。如果找不到该类的class文件，则抛出一个ClassNotFoundException异常。

另外，当JVM反序列化对象时，能找到class文件，但是class文件在序列化对象之后发生了修改，那么反序列化操 作也会失败，抛出一个InvalidClassException异常。发生这个异常的原因如下：

Serializable 接口给需要序列化的类，提供了一个序列版本号。serialVersionUID 该版本号的目的在于验证序 列化的对象和对应类是否版本匹配。

// 加入序列版本号 
private static final long serialVersionUID = 1L;

3.4 打印流

平时我们在控制台打印输出，是调用 print 方法和 println 方法完成的，这两个方法都来自于java.io.PrintStream 类，该类能够方便地打印各种数据类型的值，是一种便捷的输出方式。

3.4.1 PrintStream类【字节打印流】

构造方法

System.out就是PrintStream类型的，只不过它的流向是系统规定的，打印在控制台上。不过，既然是流对象， 我们就可以改变它的流向。

public class PrintDemo { 
      public static void main(String[] args) throws IOException { 
      // 调用系统的打印流,控制台直接输出97
      System.out.println(97); 
      // 创建打印流,指定文件的名称 
      PrintStream ps = new PrintStream("ps.txt"); 
      // 设置系统的打印流流向,输出到ps.txt 
      System.setOut(ps); 
      // 调用系统的打印流,ps.txt中输出97 
      System.out.println(97); 
    }
}

3.4.2 PrintWriter类【字符打印流】

构造方法

上一篇 下一篇

猜你喜欢

热点阅读