十四、IO

一、概述：

1.流的分类：

  按照流向的不同分为：输入流 输出流
  按照处理数据单位的不通分为：字节流 字符流（处理的文本文件）
  按照角色的不通分为 节点流（直接作用于文件的）处理流

关于处理流的说明：(处理流作用在节点流上)

 2.IO的体系：

抽象基类	节点流（文件流）	缓冲流
InputStream（字节流）	FileInputStream	BufferedInputStream
OutputStream（字节流）	FileOutputStream	BufferedOutputStream
Reader（字符流）	FileReader	BufferedReader
Writer（字符流）	FileWriter	BufferedWriter

 

 

 

 

 

 

 3.如何使用

• 　　对于文本文件（.txt,.java,.c,.cpp）使用字符流处理
• 　　对于非文本文件，使用字节流处理

二、字节流

1、FileReaderd

1.1步骤：

• 创建File类对象，指明要操作的文件；
• 提供具体的流
• 数据的处理
• 关闭应用的流

demo1：从硬盘存在的一个文件中，读取其内容到程序中，使用FileInputStream，显示在控制台上

@Test

    public void testStream1() {

        // 2.提供具体的流
        FileReader fileReader = null;
        try {

            // 1.创建一个File类的对象,指明要操作的文件

            File file1 = new File("hello.txt");// 文件位置为当前工程下面，不是当前类下
            fileReader = new FileReader(file1);
            // 3.数据的读入
            // read() 返回读入的一个字符，文件达到末尾，则返回-1
            int data = fileReader.read();
            while (data != -1) {
                System.out.print((char) data);
                data = fileReader.read();
            }
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            // 4.关闭相应的流
            if (fileReader != null) {
                try {
                    fileReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

        }

    }

注意：要读取的文件一定要存在，否则空指针异常

说明：

• read()的理解：返回读入的一直字符，如果到底文件末尾则返回-1；
• 关于异常的处理，为了保证保证流资源的关闭，这里使用了try catch finally 来处理，这里看到了顺序没有从上到下来，是因为最后做了异常处理导致的；

1.2.关于read方法的详细说明

1.2.1read()方法错误版（只为说明用）

/
      reader 方法升级版(错误版)
 4       @Description
@author lixiuming
      @date 2021年5月5日上午11:22:37
@throws IOException
 9      /
    @Test
    public void testReaderUpgrade2() throws IOException {
        // 1.File 类的实例化
        File file1 = new File("hello.txt");// 文件位置为当前工程下面，不是当前类下
        // 2.流的实例化
        FileReader fileReader = new FileReader(file1);
        // 3.流的写出
        char[] charArr = new char[5];// 一次读入多个数据来提高效率
        int len = fileReader.read(charArr);// 一次读入多个数据,返回每次读入的charArr数组中字符的个数，如果达到文件末尾，返回-1
        while (len != -1) {
            for (int i = 0; i < charArr.length; i++) {
                System.out.print((char) charArr[i]);
            }
            len = fileReader.read(charArr);
        }
        // 4.流的操作
        fileReader.close();

    }

这里的charArr.length;有问题，在文件中，如果hello.txt中的内容是：hello word!! hello lixiuming!!123，那么此时的输出结果就是 hello word!! hello lixiuming!!123!!,多了两个“!!”;

若最后取的数组长度不足5，那么前一个的数组是：

i

n

g

！

！

 

 

最后一组数组则是：

1

3

2

！

！

 

 

没有覆盖掉原来的数据；

1.2.2read()的升级版本正确写法：

/
      reader 方法的升级版(正确版)
 4       @Description
@author lixiuming
@throws IOException
      @date 2021年5月5日上午10:55:53
 9      /
    @Test
    public void testReaderUpgrade() throws IOException {
        // 1.File 类的实例化
        File file1 = new File("hello.txt");// 文件位置为当前工程下面，不是当前类下
        // 2.流的实例化
        FileReader fileReader = new FileReader(file1);
        // 3.流的写出
        char[] charArr = new char[5];// 一次读入多个数据来提高效率
        int len = fileReader.read(charArr);// 一次读入多个数据,返回每次读入的charArr数组中字符的个数，如果达到文件末尾，返回-1
        while (len != -1) {
            for (int i = 0; i < len; i++) {
                System.out.print((char) charArr[i]);

            }
            len = fileReader.read(charArr);
        }
        // 4.流的操作
        fileReader.close();

    }

2.FileWrite

步骤：

• 创建File类对象，指明要操作的文件；
• 提供具体的流
• 数据的处理
• 关闭应用的流

demo:从内存中写出数据到硬盘的文件里的简单说明

@Test
    public void testFileWirter() throws IOException {
        // 1、提供File类的对象，指明写出到的文件
        File file = new File("hello2.txt");
        // 2.提供FileWrite的对象，用于数据的写出
        FileWriter fw = new FileWriter(file);
        // 3.写出的具体操作

        fw.write("I have a dream!");
        fw.write("You need have a dream!");
        // 4.关闭流
        fw.close();

    }

说明：

输出操作，对应File可以不存在，并不会报异常；

如不存在，在输出过程中自动穿件文件

如果存在， a.如果流构造器使用的是FileWriter(file,false)/FileWriter(file),对象会对原有的文件进行覆盖；

　　　　　　b.如果流构造器使用的是FileWriter(file,true) 不会对原有的文件覆盖，而是在原有的文件内追加；

 

3.文件的复制（FileReader和FileWriter同时使用）

3.1JUNIT测试版：

/
      文件的复制
 4       @Description
@author lixiuming
@throws IOException
      @date 2021年5月5日上午10:19:44
 9      /
    @Test
    public void testFileCopy() {
        // 2.创建输入和出入流的对象
        FileReader fr = null;
        FileWriter fw = null;
        try {
            // 1.创建File 类的对象，指明读入和写出的文件
            File copy = new File("hello.txt");
            File copyTo = new File("hello2.txt");
            fr = new FileReader(copy);
            fw = new FileWriter(copyTo);
            // 3.数据的读入和写出
            char[] charArr = new char[5];
            int len = fr.read(charArr);
            while (len != -1) {
                for (int i = 0; i < len; i++) {
                    char data = (char) charArr[i];
                    fw.write(data);
                }
                len = fr.read(charArr);
            }
        } catch (Exception e) {
        } finally {
            // 4.关闭流资源
            try {
                if (fw != null) {
                    fw.close();
                }

            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (fr != null) {
                    try {
                        fr.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }

        }

    }

4、FileInputStream/FileOutputStream

4.1步骤：

• 创建File类对象，指明要操作的文件；
• 提供具体的流
• 数据的处理
• 关闭应用的流

说明：用字节流 读取文本文件（中文 数字 英文）：控制台中文会有乱码，如果单纯的复制文件没有问题；

使用demo:用字节流读取文本文件

@Test
    public void testFileInputString() {
        // 2.造流
        FileInputStream fo = null;
        try {
            // 1.造文件
            File file = new File("hello.txt");
            fo = new FileInputStream(file);
            // 3.文件读出
            byte[] arr = new byte[5];
            int len = fo.read(arr);
            while (len != -1) {
                System.out.print(new String(arr, 0, len));
                len = fo.read(arr);
            }
        } catch (Exception e) {
            // TODO: handle exception
        } finally {
            // 4、流关闭
            try {
                if (fo != null)
                    fo.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

    }

4.2实现图片的复制

@Test
    public void testCopyImg() {
        // 2.造流
        FileInputStream fi = null;
        FileOutputStream fo = null;
        try {
            // 1.造文件
            File copyFile = new File("WX20210407-100610.png");
            File copytoFile = new File("collection.png");
            fi = new FileInputStream(copyFile);
            fo = new FileOutputStream(copytoFile);
            // 3.文件读出
            byte[] arr = new byte[5];
            int len = fi.read(arr);
            while (len != -1) {
                for (int i = 0; i < len; i++) {
                    fo.write(arr[i]);
                }
                len = fi.read(arr);

            }
        } catch (Exception e) {
            // TODO: handle exception
        } finally {
            // 4、流关闭
            try {
                if (fo != null)
                    fo.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            try {
                if (fi != null)
                    fi.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

    }

 

4.3对文件复制的通用方法：

说明：不能使用字符流复制照片，但是 字节流可以复制文本文件，但是，如果在复制的过程中，想在控制台查看文件，可能会有中文乱码；

/
      复制文件通用方法
 4       @Description
@author lixiuming
      @date 2021年5月5日下午2:34:36
@param srcStr  复制文件地址（文件名）
@param destStr 复制到文件的地址（文件名）
10      /
    public void testCopFile(String srcStr, String destStr) {
        // 2.造流
        FileInputStream fi = null;
        FileOutputStream fo = null;
        try {
            // 1.造文件
            File copyFile = new File(srcStr);
            File copytoFile = new File(destStr);
            fi = new FileInputStream(copyFile);
            fo = new FileOutputStream(copytoFile);
            // 3.文件读出
            byte[] arr = new byte[1024];// 一般使用1024
            int len = fi.read(arr);
            while (len != -1) {
                for (int i = 0; i < len; i++) {
                    fo.write(arr[i]);
                }
                len = fi.read(arr);

            }
        } catch (Exception e) {
            // TODO: handle exception
        } finally {
            // 4、流关闭
            try {
                if (fo != null)
                    fo.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            try {
                if (fi != null)
                    fi.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

    }

三、缓冲流

1.1缓冲流的作用：可以提供效率

1.2使用和步骤

• 创建File类对象，指明要操作的文件；
• 提供具体的流:节点流和缓冲流；
• 数据的处理
• 关闭应用的流

demo：使用缓冲流实现文件的复制：（BufferedInputStream/BufferedOutputStream）

/
      缓冲流实现的文件复制
 4       @Description
@author lixiuming
      @date 2021年5月5日下午2:58:38
 8      /
    @Test
    public void testCopyFileByBuffer() {
        BufferedInputStream bi = null;
        BufferedOutputStream bo = null;
        // 3.复制
        byte[] arr;
        int len;
        try {
            // 1.造文件
            File copy = new File("hello.txt");
            File copyTo = new File("hello3.txt");
            // 2.造流
            FileInputStream fi = new FileInputStream(copy);
            FileOutputStream fo = new FileOutputStream(copyTo);
            bi = new BufferedInputStream(fi);
            bo = new BufferedOutputStream(fo);
            arr = new byte[1024];
            len = bi.read(arr);
            while (len != -1) {
                for (int i = 0; i < len; i++) {
                    bo.write(arr[i]);
                }
                len = bi.read(arr);
            }
        } catch (Exception e) {
        } finally {
            // 4.关闭资源
            try {
                if (bo != null) {
                    bo.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (bi != null) {
                    bi.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }

说明，这里的造流除了 节点流还有缓冲流，因为缓冲流作用在节点流之上；

1.3 缓冲流复制文件的通用方法

public void testCopyFileByBuffer(String srcStr, String destStr) {
        BufferedInputStream bi = null;
        BufferedOutputStream bo = null;
        // 3.复制
        byte[] arr;
        int len;
        try {
            // 1.造文件
            File copy = new File(srcStr);
            File copyTo = new File(destStr);
            // 2.造流
            // 2.1造节点流
            FileInputStream fi = new FileInputStream(copy);
            FileOutputStream fo = new FileOutputStream(copyTo);
            // 2.2造缓冲流
            bi = new BufferedInputStream(fi);
            bo = new BufferedOutputStream(fo);
            arr = new byte[1024];
            len = bi.read(arr);
            while (len != -1) {
                for (int i = 0; i < len; i++) {
                    bo.write(arr[i]);
                }
                len = bi.read(arr);
            }
        } catch (Exception e) {
        } finally {
            // 4.关闭资源
            // 说明，关闭外层流，内层流自动关闭；所以 file的节点流在此处自动关闭
            try {
                if (bo != null) {
                    bo.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (bi != null) {
                    bi.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }

1.4BufferReader BufferedWriter 实现文本文件的复制

junit测试版

/**
     * BufferReader BufferedWriter 实现文本文件的复制
     * 
     * @Description
     * @author lixiuming
     * @throws IOException
     * @date 2021年5月5日下午3:12:32
     *
     */
    @Test
    public void testBufferReaderWriter() {
        BufferedReader bi = null;
        BufferedWriter bo = null;
        try {
            // 1造文件
            File file = new File("hello.txt");
            File copyto = new File("hello4.txt");
            // 2.造流
            FileReader fi = new FileReader(file);
            FileWriter fo = new FileWriter(copyto);
            bi = new BufferedReader(fi);
            bo = new BufferedWriter(fo);
            // 3.复制的处理过程
            char[] arr = new char[1024];
            int len = bi.read(arr);
            while (len != -1) {
                for (int i = 0; i < len; i++) {
                    bo.write(arr[i]);
                }
                len = bi.read(arr);
            }
        } catch (Exception e) {
            // TODO: handle exception
        } finally {
            // 4.关闭流
            try {
                if (bi != null) {
                    bi.close();
                }
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            try {
                if (bo != null) {
                    bo.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

封装版：

/**
     * BufferReader BufferedWriter 实现文本文件的复制
     * 
     * @Description
     * @author lixiuming
     * @throws IOException
     * @date 2021年5月5日下午3:12:32
     *
     */
    public void testBufferReaderWriterCopy(String srcStr, String destStr) {
        BufferedReader bi = null;
        BufferedWriter bo = null;
        try {
            // 1造文件
            File file = new File(srcStr);
            File copyto = new File(destStr);
            // 2.造流
            FileReader fi = new FileReader(file);
            FileWriter fo = new FileWriter(copyto);
            bi = new BufferedReader(fi);
            bo = new BufferedWriter(fo);
            // 3.复制的处理过程
            char[] arr = new char[1024];
            int len = bi.read(arr);
            while (len != -1) {
                for (int i = 0; i < len; i++) {
                    bo.write(arr[i]);
                }
                len = bi.read(arr);
            }
        } catch (Exception e) {
            // TODO: handle exception
        } finally {
            // 4.关闭流
            try {
                if (bi != null) {
                    bi.close();
                }
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            try {
                if (bo != null) {
                    bo.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

四、其他流

1.转换流（属于字符流 ）：

•  InputStreamReader：将字节的输入流 转 字符的输入流;
• OutputStreamWriter; 将字符的输出流，转字节的输出流

作用：提供字节流和字符流的转换；

通途：可以编码 和 解码；

demo:使用utf-8读取文件，使用gbk写文件;

@Test
    public void testReaderWriter() {
        InputStreamReader isr = null;
        OutputStreamWriter osw = null;
        try {
            //1.造文件
            File strFile = new File("hello.txt");
            File destFile = new File("hello_gbk.txt");
            //2.造流
            FileInputStream fi = new FileInputStream(strFile);
            FileOutputStream fo = new FileOutputStream(destFile);
            isr = new InputStreamReader(fi, "utf-8");
            osw = new OutputStreamWriter(fo, "gbk");
            //3.处理
            char[] arr = new char[1024];
            int len = isr.read(arr);
            while (len != -1) {
                for (int i = 0; i < len; i++) {
                    osw.write(arr[i]);
                }
                len = isr.read(arr);
            } 
        } catch (Exception e) {
            // TODO: handle exception
        }finally {
            //4.关闭流
            try {
                if(isr!=null) {
                    isr.close();
                }
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            try {
                if(osw!=null) {
                    osw.close();
                }
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        
    }

2.数据流：处理基本数据类型和String数据；

DataInputStream / DataOutputStream
用于读取或写出基本数据类型的变量或者字符串
      readBoolean()
      readChar()
      readLone()
      String readUTF()
      readByte()
      readFloat()
      readShort()
      readInt()
      void readFully(byte[] b)

demo1:将基本类型数据写出到文件

@Test
       public void testData(){
           FileOutputStream fos=null;
           DataOutputStream dos = null;
           try {
            fos = new FileOutputStream("data.txt");
            dos = new DataOutputStream(fos);
            dos.writeUTF("ksdflskdfhslkdf");
            dos.writeBoolean(true);
            dos.writeLong(123123);
        } catch (Exception e) {
            // TODO: handle exception
        }finally {
            try {
                if(dos!=null) {
                dos.close();
                }
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
           
           }

demo2：将文件 读入到内存

//将基本类型和字符串从文件中读入到内存中，读入的顺序需要和写入时的顺序一致
      @Test
       public void testReadData(){
          DataInputStream dos = null;
          try {
            File file = new File("data.txt");
            FileInputStream fos = new FileInputStream(file);
             dos = new DataInputStream(fos);
            byte[] arr = new byte[1024];
            String str = dos.readUTF();
            Boolean bo = dos.readBoolean();
            long lo =dos.readLong();
            System.out.println(str+"||"+bo+"||"+bo);
        } catch (Exception e) {
            // TODO: handle exception
        }finally {
            try {
                if(dos!=null) {
                    dos.close();
                }
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
           }

注意：读入内存过程中，读入的顺序需要和写入时的顺序一致

3.打印流：

字节流：PrintStream

字符流：printWriter
提供了一系列重载的print() 和println()
  改变输出位置

      
      @Test
      
      public void printSrtreamWriter()  {
      // 设置打印位置
      PrintStream ps = null;
      try {
        File file = new File("hello.txt");
        FileOutputStream fos = new FileOutputStream(file);
        ps = new PrintStream(fos, true);
        System.setOut(ps);
        for (int i = 0; i < 255; i++) {
            System.out.print((char) i);
            if (i % 50 == 0) {
                System.out.println();// 换行
            }
        }
    } catch (Exception e) {
        // TODO: handle exception
    } finally {
        if (ps != null) {
            ps.close();
        }
    }
}

4. 标准的输入，输出流

• System.in 标准的输入流，默认键盘输入
• System.out 标准的输出流，默认从控制台输出
• System.setIn()/System.setOut()可以冲洗指定输入和输出；

demo：把输入内容转化成大写，输出,当直接输入“e”或者“exit”时，退出程序

@Test
      public void testSystemIn() {
      InputStream is = null;
      
      InputStreamReader isr = null;
      BufferedReader br = null;
      
      try {
        is = System.in;
        isr = new InputStreamReader(is);
        br = new BufferedReader(isr);
        String str = null;
        while (true) {

            System.out.print("请输入字符串：");

            str = br.readLine();

            if (str.equalsIgnoreCase("e") || str.equalsIgnoreCase("exit")) {

                break;

            } else {

                String str1 = str.toUpperCase();

                System.out.println(str1);

            }

        } 
    } catch (Exception e) {
        // TODO: handle exception
    }finally {
        if(br!=null)
            try {
                br.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
    }
      
      }

5.对象流

①作用：用于存储和读取基本数据类型数据或者对象的处理流；

　　　　序列化：用ObjectOutputStream 类保存基本类型数据或对象的机制
　　　　反序列化：用ObjectInputStream 类读取基本类型数据或对象

②对象的序列化机制：允许把内存中的Java对象转换成与平台无关的二进制流，从而允许把这种二进制流持久的保存到磁盘上，
　　　　　　　　　或者通过网络将这种二进制流传输到另一个网络节点，当其他程序获取了这种二进制流，就可以恢复成原来的java对象；
 
③序列化的好处：可以将任意实现了Serializable接口的对象转换为字节数据，使其在保存和传输时可被还原；
 
　　　　　　　序列化是RMI过程的传输和返回值都必须实现的机制，而RMI是java EE的基础，因此序列化是javaEE平台的基础
④注意： 

如果需要让某个对象支持序列化机制：则必须让对象所属的类及其属性是可序列化的，为了让某个类是可序列化的，该类必须实现如下两个接口之一 否则会抛出
  NoSerializableException的异常

• Sericalizable
• Externalizable

ObjectInputStream 和 ObjectOutputStream 不能序列化static和transient修饰的成员；

⑤demo示例（只是为了展示基本使用步骤）

/**
     * 对象的序列号（简单版）
     * 
     * @Description
     * @author lixiuming
     * @throws IOException
     * @date 2021年5月15日下午2:47:12
     *
     */
    @Test
    public void testObjectStream() throws IOException {
        File file = new File("object.dat");
        FileOutputStream fi = new FileOutputStream(file);
        ObjectOutputStream bos = new ObjectOutputStream(fi);
        bos.writeObject(new String("我爱北京天安门"));
        bos.close();
    }

    /**
     * 反向过程
     * 
     * @Description
     * @author lixiuming
     * @date 2021年5月15日下午3:01:59
     *
     */
    @Test
    public void testInput() {
        ObjectInputStream bis = null;
        try {
            File file = new File("object.dat");
            FileInputStream fi = new FileInputStream(file);
            bis = new ObjectInputStream(fi);
            byte[] arr = new byte[1024];
            String str = (String) bis.readObject();
            System.out.println(str);
        } catch (Exception e) {
            // TODO: handle exception
        } finally {
            try {
                if (bis != null) {
                    bis.close();
                }
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

    }

升级版：

/
      自定义类的序列化
 4       @Description
@author lixiuming
      @date 2021年5月15日下午3:23:28
 8      /
    @Test
    public void test1() {
        ObjectOutputStream obs = null;
        try {
            File file = new File("Person.dat");
            FileOutputStream fo = new FileOutputStream(file);
            obs = new ObjectOutputStream(fo);
            Persion persion = new Persion();
            persion.setAge(11);
            persion.setName("李秀明");
            obs.writeObject(persion);
        } catch (Exception e) {
            // TODO: handle exception
        } finally {
            try {
                if (obs != null) {

                    obs.close();
                }
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }

    /
      自定义饭序列化
38       @Description
@author lixiuming
      @date 2021年5月15日下午3:44:38
42      /
    @Test
    public void test2() {
        ObjectInputStream bis = null;
        try {
            File file = new File("Person.dat");
            FileInputStream fi = new FileInputStream(file);
            bis = new ObjectInputStream(fi);
            Persion persion = (Persion) bis.readObject();
            System.out.println(persion.toString());
        } catch (Exception e) {
            // TODO: handle exception
        } finally {
            try {
                if (bis != null) {
                    bis.close();
                }
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

    }

涉及到的类：

注意：对类的要求：

• 需要实现接口：serializable
• 当前类提供一个全局常量：serializableUID
• 除了当前类需要实现serializable接口外，还必须保证其内部所有属性也必须是可序列话的 默认情况下，基本数据类型是可序列化的；

 补充：ObjectOutputStream 和 ObjectInputStream不能序列化static和transient修饰的成员

public class Persion implements Serializable {

    /**
     * 
     */
    private static final long serialVersionUID = -5081496688118179383L;
    private String name;
    private int age;
    private Account account;//必须实现Serializable接口

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Account getAccount() {
        return account;
    }

    public void setAccount(Account account) {
        this.account = account;
    }

}

class Account implements Serializable {
    /**
     * 
     */
    private static final long serialVersionUID = -3229470228130872968L;
    private double banlence;

    public double getBanlence() {
        return banlence;
    }

    public void setBanlence(double banlence) {
        this.banlence = banlence;
    }

}

6.RandomAccessFile

说明：
     1.RdomAccessFile直接继承于java.lang.Object类，实现了DataInput和DataOutput接口
     2.RandomAccessFile既可以作为输入流，又可以作为输出流

　　RandomAccessFile的访问模式：

• r:以只读的方式打开
• rw:打开以后可以读取和写入
• rwd:打开以后可以读取和写入，同步文件内容的更新
• rws:打开以后可以读取和写入，同步文件内容和元数据的更新；

     3.如果RandomAccessFile作为输出流时，写出到的文件如果不存在，则在执行过程中自动创建，如果存在，则会对原有文件进行覆盖（默认情况下从头覆盖）；
     4.可以通过相关操作，可以实现对文件的“插入”数据的效果；
     （应用场景，文件断点续传）

demo1以照片赋值为例

@Test
    public void testAccessFileStream() {
        RandomAccessFile af = null;
        RandomAccessFile af2 = null;
        try {
            File file = new File("collection.png");
            File file2 = new File("collection22.png");
            af = new RandomAccessFile(file, "r");
            af2 = new RandomAccessFile(file2, "rw");
            byte[] arr = new byte[1024];
            int len = af.read(arr);
            while (len != -1) {
                for (int i = 0; i < len; i++) {
                    af2.write(arr[i]);
                }
                
                len = af.read(arr);
            }
        } catch (Exception e) {
            // TODO: handle exception
        } finally {
            try {
                if (af != null) {
                    af.close();
                }
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            try {
                if (af2 != null) {

                    af2.close();
                }
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

    }

demo2关于文件操作

//对文件的操作
    @Test
    public void testAccessFileStream2() {
        RandomAccessFile af2 = null;
        try {
            File file2 = new File("accessfile.txt");
            af2 = new RandomAccessFile(file2, "rw");
            af2.seek(12);//指定写入位置（从该位置进行覆盖）
            af2.write("1234567890".getBytes());//默认情况：文件不存在，则创建，存在，则覆盖（默认从头开始覆盖）
            
        } catch (Exception e) {
            // TODO: handle exception
        } finally {
            try {
                if (af2 != null) {

                    af2.close();
                }
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

    }

五、使用第三方jar包实现数据读写