美文网首页java学习笔记
java-保姆级IO流详解

java-保姆级IO流详解

作者: 吾乃零陵上将军邢道荣是也 | 来源:发表于2020-09-24 15:26 被阅读0次

    一、File类

    1.1 概述

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

    抽像:

    1.2 构造方法

    • public File(String pathname):通过将给定的路径名字符串转换为抽象路径名来创建新的 File 实例。
    • public File(String parent, String child) :从父路径名字符串和子路径名字符串创建新的 File实例。
    • public File(File parent, String child) :从父抽象路径名和子路径名字符串创建新的 File实例。
    • public File(URI uri):通过给定的 file:URI 转换为抽象路径名来创建新的 File 实例。
    • 构造举例,代码如下:
    // 文件路径名
            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.一个File对象代表硬盘中实际存在的一个文件或目录
      1. 无论该路径下是否存在文件或者目录,都不影响File对象的创建。
    • 3.关于路径的书写问题,这取决于你的系统,分为windows、linux和mac os版本。你可以通过File的静态成员变量来查看自己系统的分隔符。例如:
      File.pathSeparator表示与系统相关的路径分隔符字符。
      File.separator表示与系统相关的默认名称 - 分隔符字符
      对应到windows系统,pathSeparator为":",separator为:"\"。所以windows系统的文件路径可以用这样表示:"D:\abc\a.txt"。

    1.3 常用方法

    获取功能的方法

    • public String getAbsolutePath():返回此File的绝对路径名字符串。
    • public String getPath():将此File转换为路径名字符串。
    • public String getName():返回由此File表示的文件或目录的名称。
    • public long length():返回由此File表示的文件的长度。

    方法演示,代码如下:

    // 文件路径名
            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字节
    

    判断功能的方法

    • public boolean exists():此File表示的文件或目录是否实际存在。
    • public boolean isDirectory():此File表示的是否为目录。
    • public boolean isFile():此File表示的是否为文件。

    方法演示,代码如下:

    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
    

    创建删除功能的方法

    • public boolean createNewFile():当且仅当具有该名称的文件尚不存在时,创建一个新的空文件。
    • public boolean delete():删除由此File表示的文件或目录。
    • public boolean mkdir():创建由此File表示的目录。
    • public boolean mkdirs():创建由此File表示的目录,包括任何必需但不存在的父目录。

    方法演示,代码如下:

            // 文件的创建
            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 String[] list():返回一个String数组,表示该File目录中的所有子文件或目录。
    • public File[] listFiles():返回一个File数组,表示该File目录中的所有子文件或目录。

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

    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抽象类是表示字节输出流的所有类的超类,将指定的字节信息写出到目的地。它定义了字节输出流的基本共性方法。

    • public void close():关闭此输出流并释放与此流相关联的任何系统资源。
    • public void flush():刷新此输出流并强制任何缓冲的输出字节被写出。
    • public void write(byte[] b):将 b.length 字节从指定的字节数组写入此输出流。
    • public void write(byte[] b, int off, int len):从指定的字节数组写入 len字节,从偏移量 off开始输 出到此输出流。
    • public abstract void write(int b):将指定的字节写入此输出流。

    FileOutputStream类

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

    构造方法

    • public FileOutputStream(File file):创建文件输出流以写入指定的File对象表示的文件。
    • public FileOutputStream(String name):创建文件输出流以指定的名称写入文件。

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

    其他常用方法

    • public void write(int b):每次写出一个字节数据,代码使用案例:
    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 void write(byte[] b):将 b.length个字节从指定的字节数组写入此文件输出流。代码演示:
    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 void write(byte[] b,int off,int len):将 len 字节从位于偏移量 off 的指定字节数组写入此文件输出流。代码演示:
    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
    

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

    • public FileOutputStream(File file, boolean append)
    • public FileOutputStream(String name, boolean append)

    只有在这两个构造方法中传入一个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
    

    提示

    • Windows系统里,换行符是\r\n;
    • Linux系统里,换行符是\n;
    • Mac系统里,是\r或\n;

    2.3.2 字节输入流【InputStream】

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

    • public void close():关闭此输入流并释放与此流相关联的任何系统资源。
    • public abstract int read():从输入流读取数据的下一个字节。
    • public int read(byte[] b):从此输入流中读取一些字节数,并将它们存储到字节数组b中。

    FileInputStream类

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

    构造方法

    • FileInputStream(File file):通过打开与实际文件的连接来创建一个 FileInputStream ,该文件由文件系统中的 File 对象 file 命名。
    • FileInputStream(String name):通过打开与实际文件的连接来创建一个 FileInputStream ,该文件由文件系统中的路径名 name 命名。

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

    常用方法

    • public int read():每次可以读取一个字节的数据,并将其提升为int类型,若读取到文件末尾,则返回 -1 ,代码使用演示:
    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 int read(byte[] b):每次读取 b 的长度个字节到数组中,返回读取到的有效字节个数,读 取到末尾时,返回 -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抽象类是表示用于读取字符流的所有类的超类,可以读取字符信息到内存中。它定义了字符输入 流的基本共性功能方法。

    • public void close():关闭此流并释放与此流相关联的任何系统资源。
    • public int read():从输入流读取一个字符。
    • public int read(char[] cbuf):从输入流中读取一些字符,并将它们存储到字符数组 cbuf 中 。
    FileReader类

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

    构造方法

    • FileReader(File file): 创建一个新的 FileReader ,给定要读取的File对象。
    • FileReader(String fileName):创建一个新的 FileReader ,给定要读取的文件的名称。

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

    其他方法

    • public int read():每次读取一个字符的数据,并将其提示为int类型,读取到文件末尾,返回-1。
    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 int read(char[] chuf):每次读取b的长度个字符到数组中,返回读取到的有效字符个数, 读取到末尾时,返回 -1 ,代码使用演示:
    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抽象类是表示用于写出字符流的所有类的超类,将指定的字符信息写出到目的在,它定义了字节输出流的基本共性功能方法。

    • void write(int c): 写入单个字符。
    • void write(char[] cbuf): 写入字符数组。
    • abstract void write(char[] cbuf, int off, int len): 写入字符数组的某一部分,off数组的开始索引,len 写的字符个数。
    • void write(String str): 写入字符串。
    • void write(String str, int off, int len):写入字符串的某一部分,off字符串的开始索引,len写的字符个 数。
    • void flush(): 刷新该流的缓冲。
    • void close(): 关闭此流,但要先刷新它。
    FileWriter类

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

    构造方法

    • FileWriter(File file) : 创建一个新的 FileWriter,给定要读取的File对象。
    • FileWriter(String fileName): 创建一个新的 FileWriter,给定要读取的文件的名称。

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

    其他方法

    • public void write(int b):每次写出一个字符数据。

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

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

    • flush():刷新缓冲区,流对象可以继续使用。

    • close():先刷新缓冲区,然后通知系统释放资源。流对象不可以再被使用了。

    • public void write(char[] cbuf)public void write(char[] cbuf,int off,int len),每次可以写出字符数组中的数据,用法类似FileOutputStream,代码使用演示:

    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(); 
        } 
    }
    
    • public void write(String str)public void write(String str,int off,int len),每次可以写出字符串中的数据,更为方便。

    续写和换行:类似于FileOutputStream。

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

    3.1 缓冲流

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

    • 字节缓冲流BufferedInputStream,BufferedOutputStream
    • 字符缓冲流:BufferedReader,BufferedWriter

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

    3.1.1 字节缓冲流

    构造方法

    • public BufferedInputStream(InputStream in):创建一个新的缓冲输入流。
    • public BufferedOutputStream(OutputStream out):创建一个新的缓冲输出流。
      构造举例,代码如下:
    // 创建字节缓冲输入流 
    BufferedInputStream bis = new BufferedInputStream(new FileInputStream("bis.txt")); 
    // 创建字节缓冲输出流 
    BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("bos.txt"));
    

    3.1.2 字符缓冲流

    构造方法

    • pubic BufferedReader(Reader in):创建一个新的缓冲输入流。
    • public BufferedWriter(Writer out):创建一个新的缓冲输出流。

    构造方法举例:

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

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

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

    • BufferedReader:public String readLine():读一行文字。
    • BufferedWriter:pubic void newLine():写一行文字,分隔符由系统属性定义。

    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(InputStream in):创建一个使用默认字符集的字符流。
    • InputStreamReader(InputStream in, String charsetName):创建一个指定字符集的字符流。

    构造举例,代码如下:

    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(OutputStream in):创建一个使用默认字符集的字符流。
    • OutputStreamWriter(OutputStream in, String charsetName):创建一个指定字符集的字符流。

    构造举例,代码如下:

    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对象的原始数据类型写出到文件,实现对象的持久存储。

    构造方法

    • public ObjectOutputStream(OutputStream out):创建一个指定OutputStream的ObjectOutputStream。
      构造举例,代码如下:
    FileOutputStream fileOut = new FileOutputStream("employee.txt"); 
    ObjectOutputStream out = new ObjectOutputStream(fileOut);
    

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

    • 该类必须实现java.io.Serializable接口,Serializable 是一个标记接口,不实现此接口的类将不会使任 何状态序列化或反序列化,会抛出 NotSerializableException 。
    • 该类的所有属性必须是可序列化的。如果有一个属性不需要可序列化的,则该属性必须注明是瞬态的,使用transient关键字修饰。
    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 final void writeObject (Object obj):将指定的对象写出。
    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 ObjectInputStream(InputStream in):创建一个指定InputStream的ObjectInputStream。

    反序列化方法

    • public final Object readObject():读取一个对象。
    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类【字节打印流】

    构造方法

    • public PrintStream(String fileName):使用指定的文件名创建一个新的打印流。

    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类【字符打印流】

    构造方法

    • PrintWriter(File file):使用指定的文件创建一个新的PrintWriter。
    • PrintWriter(String fileName):使用指定的文件名创建一个新的PrintWriter。

    相关文章

      网友评论

        本文标题:java-保姆级IO流详解

        本文链接:https://www.haomeiwen.com/subject/yokzyktx.html