Java高级编程–输入和输出处理(二)

1.读写二进制文件

1.1DataInputStream类(读取)

• FileInputStream的子类

• 与FileInputStream类结合使用读取二进制文件

• 使用 DataInputStream 读二进制文件

  //引入相关的类
  import java.io.DataInputStream;
  import java.io.FileInputStream;
  import java.io.IOException;
  public class Test05 {
      public static void main(String[] args) {
          //构造数据输入流对象
          FileInputStream fis = null;
          DataInputStream dis = null;
          try {
              fis = new FileInputStream("D:\\2.txt");
              dis = new DataInputStream(fis);
              //调用read()方法读取二进制数据
              dis.read();
          } catch (Exception e) {
            e.printStackTrace();
          } finally {
              //关闭数据输入流
              try {
                  dis.close();
                  fis.close();
              } catch (IOException e) {
                  throw new RuntimeException(e);
              }
          }
      }
  }
  
  

1.2DataOutputStream类(写入)

• FileOutputStream的子类
• 与FileOutputStream类结合使用写二进制文件
• 使用DataOutputStream写二进制文件

package com.hz.ch06;
//引入相关的类
import java.io.*;

public class Test05 {
    public static void main(String[] args)  {
        FileOutputStream outfile = null;
        DataOutputStream out = null;
        try {
            //构造数据输出流对象
            outfile = new FileOutputStream("D:\\test.txt");
            out = new DataOutputStream(outfile);
            //调用write()方法进制文件的数据
            out.writeInt(97);//a
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {   
            //关闭数据输出流
            try {
                out.close();
                outfile.close();
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }
    }
}

1.3练习：复制图片

import java.io.*;

public class Test02 {
    /*
    图片jiucai.jpg位于D盘根目录下，要求将此图片复制到   D:\0033\myPicture.jpg
     */
    public static void main(String[] args) {
        FileInputStream fis = null;
        FileOutputStream fos = null;
        DataInputStream dis = null;
        DataOutputStream dos = null;
        try {
            fis = new FileInputStream("D:\\jiucai.jpg");
            dis = new DataInputStream(fis);
            fos = new FileOutputStream("D:\\0033\\myPicture.jpg");
            dos = new DataOutputStream(fos);
            int len;
            byte[] bytes = new byte[1024];
            while ((len = dis.read(bytes)) != -1) {
                dos.write(bytes, 0, len);
            }
            System.out.println("复制成功！！！");
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            try {
                dos.close();
                dis.close();
                fos.close();
                fis.close();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

2.序列化和反序列化

• 序列化和反序列化的过程
  • 序列化是将java对象持久化存储 (记事本)
  • 反序列化是将持久化对象读取到java内存

注：需要序列化的类必须要实现接口Serializable

• 实现序列化
  • 序列化的步骤

package com.hz.ch06.serialization;

import java.io.Serializable;

public class Student implements Serializable {
    private String stuNo;
    private String name;
    private int age;

    public Student(String stuNo, String name, int age) {
        this.stuNo = stuNo;
        this.name = name;
        this.age = age;
    }

    public String getStuNo() {
        return stuNo;
    }

    public void setStuNo(String stuNo) {
        this.stuNo = stuNo;
    }

    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;
    }

    @Override
    public String toString() {
        return "Student{" +
                "stuNo='" + stuNo + '\'' +
                ", name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

package com.hz.ch06.serialization;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStreamReader;
import java.io.ObjectOutputStream;

public class Test {
    public static void main(String[] args) {
        try {
            //创建一个对象字节输出流包装原始的字节输出流。
            FileOutputStream fos=new FileOutputStream("D:\\test.txt");
            ObjectOutputStream oos=new ObjectOutputStream(fos);
            Student stu=new Student("001","杨洋",20);
            //调用writeObject0方法将对象写入文件
            oos.writeObject(stu);
            System.out.println("序列化对象成功!");
            //关闭对象输出流
            oos.close();
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

注：使用集合保存对象，可以将集合中的所有对象序列化

• 实现反序列化

  • 反序列化的步骤

package com.hz.ch06.serialization;
import java.io.FileInputStream;
import java.io.ObjectInputStream;

public class ObjectInputStreamTest {
    public static void main(String[] args) {
        try {
            FileInputStream fis=new FileInputStream("D:\\test.txt");
            //创建对象输入流
            ObjectInputStream ois=new ObjectInputStream(fis);
            //调用readObject()方法读取对象
            Student stu= (Student) ois.readObject();
            System.out.println(stu);
            //关闭对象输入流
            ois.close();
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

输出结果(控制台)

注：如果向文件中使用序列化机制写入多个对象， 那么反序列化恢复对象时，必须按照写入的顺序读取