IO流(五)其他流

节点流

ByteArrayInputStream

public class ByteArrayInputStream extends InputStream

ByteArrayInputStream 包含一个内部缓冲区，该缓冲区包含从流中读取的字节。

构造方法

ByteArrayInputStream(byte[] buf) //创建一个ByteArrayInputStream，使用buf作为缓冲区数组。
ByteArrayInputStream(byte[] buf,int offset,int length)  //创建ByteArrayInputStream，使用buf的一部分作为缓冲区数组。

没有新增方法，继承自InputStream的方法。

ByteArrayOutputStream

public class ByteArrayOutputStreamextends OutputStream

此类实现了一个输出流，其中的数据被写入一个byte数组。缓冲区会随着数据的不断写入而自动增长。可使用toByteArray()和toString()获取数据。

构造方法

ByteArrayOutputStream()  //创建一个新的byte数组输出流
ByteArrayOutputStream(int size)  //创建一个新的byte数组输容量出流，它具有指定大小的缓冲区

Demo

public class TestByteArray{
    public static void main(String[] args) throws IOException{
        read(write());
    }
    public static void read(byte[] b) throws IOException{
        InputStream is = new BufferedInputStream(new ByteArrayInputStream(b));
        byte[] flush = new byte[1024];
        int len = 0;
        while(-1 != is.read(flush)){
            System.out.println(new String(flush));
        }
        is.close();
    }
    //输出流有新增方法，不能使用多态
    public static byte[] write() throws IOException{
        byte[] dest;
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        String msg = "操作与文件输入流一致";
        byte[] info = msg.getBytes();
        bos.write(info,0,info.length);
        dest = bos.toByteArray();
        bos.close();
        return dest;
    }
}

处理流

DataInputStream

public class DataInputStream extends FileterInputStream implements DataInput

数据输入流允许应用程序以机器无关方式从底层输入流中读取基本Java数据类型。

构造方法

DataInputStream(InputStream in) //使用指定的底层InputStream 创建一个DataInputStream

DataOutputStream

public class DataOutputStream extends FilterOutputStream implements DataOutput

数据输出流允许应用程序以适当方式将基本Java数据类型写入输出流中。然后，应用程序可以使用数据输入流将数据读入。

Demo

public class TestData{
    public static void main(String[] args) throws IOException{
       try {
        read("D:/io/a.txt");
    } catch (Exception e) {
        e.printStackTrace();
        }
    }
    public static void read(String destPath){
        File src = new File(destPath);
        DataInputStream dis = new DataInputStream(new BufferedInputStream(new FileInputStream(src)));
        double num1 = dis.readDouble();
        long num2 = dis.readLong();
        String str = dis.readUTF();
        System.out.println(str);
    }
    public static void write(String destPath){
        double point = 2.5;
        long num = 100L;
        String src = "数据类型";
        File dest = new File(destPath);
        DataOutputStream dos = new DataOutputStream(new BufferedOutputStream(new FileOutputStream(dest)));
        dos.writeDouble(point);
        dos.writeLong(num);
        dos.writeUTF(src);
        dos.flush();
        dos.close();
    }
}

实现序列化和反序列化

ObjectOutputStream

序列化

public class ObjectOutputStream extends OutputStream implements ObjectOutput,ObjectStreamConstants

可以使用ObejctOutputStream重构对象。通过在流中使用文件可以实现对象的持久存储。

注意:

• 先序列化后反序列化；反序列化顺序必须与序列化一致

Demo

    import java.io.Serializable;
    /**
     * 实现序列化接口后该类可以被序列化
     */
    public class Emp implements Serializable{
        /**
         * 版本号
         */
        private static final long serialVersionUID = 1L;
        private String name;
        private int age;
        private String gender;
        private double salary;
        public Emp(String name, int age, String gender, double salary) {
            this.name = name;
            this.age = age;
            this.gender = gender;
            this.salary = salary;
        }
        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 String getGender() {
            return gender;
        }
        public void setGender(String gender) {
            this.gender = gender;
        }
        public double getSalary() {
            return salary;
        }
        public void setSalary(double salary) {
            this.salary = salary;
        }
        @Override
        public String toString() {
            return "Emp [name=" + name + ", age=" + age + ", gender=" + gender
                    + ", salary=" + salary + "]";
        }
        @Override
        public int hashCode() {
            final int prime = 31;
            int result = 1;
            result = prime * result + ((name == null) ? 0 : name.hashCode());
            return result;
        }
    }

将Emp对象序列化到文件emp.obj中
- 使用属性name，age，gender，salary为[“张三”，15，”男”]
- 创建文件字节输出流FileOutputStream类的对象，接着使用该文件字节输出流对象作为参数构造对象字节输出流ObjectOutputStream类的对象
- 使用ObjectOutputStream类的writeObject方法将Emp对象写入到文件emp.obj中
- 关闭oos对象流，以释放资源

public class TestOisAndOos {
    /**
     * 使用OOS实现对象的序列化
     */
    @Test
    public void testOOS()throws Exception{
        FileOutputStream fos = new FileOutputStream("emp.obj");
        ObjectOutputStream oos = new ObjectOutputStream(fos);

        Emp emp = new Emp("张三",15,"男",4000);
        oos.writeObject(emp);
        System.out.println("序列化完毕");
        oos.close();        
    }
}

ObjectInputStream

实现对Emp对象的反序列化
- 创建文件字节输入流FileInputStream类的对象，接着使用该文件输入流对象作为参数构造对象字节输入流ObjectInputStream类的对象
- 使用ObejctInputStream类的readObject方法将Emp对象从emp.obj文件中读取出来
- 关闭ois对象，以释放资源

public class TestOisAndOos {
    /**
     * 使用OOS实现对象的序列化
     */
    @Test
    public void testOOS()throws Exception{
        //...（代码略）
    }
    /**
     * 使用OIS实现对象的反序列化
     */
    @Test
    public void testOIS()throws Exception{
        FileInputStream fis = new FileInputStream("emp.obj");
        ObjectInputStream ois = new ObjectInputStream(fis);

        Emp emp = (Emp)ois.readObject();
        System.out.println("反序列化完毕");
        System.out.println(emp);
        ois.close();        
    }
}