2021-08-23

**

学习总结

学习内容：

字节数组流

学习产出：

ByteArrayInputStream和ByteArrayOutputStream经常用在需要流和数组之间转化的情况!
说白了，FileInputStream是把文件当做数据源。ByteArrayInputStream则是把内存中的”某个字节数组对象”当做数据源。

1 字节数组流（字节流）

ByteArrayInputStream: 字节数组输入流在内存中创建一个字节数组缓冲区，从输入流读取的数据保存在该字节数组缓冲区中，从字节数组中读数据。

ByteArrayOutputStream：创建字节数组输出流的同时，内存会为该输出流创建一个默认大小的字节数组，用于存储写入的字节内容。

2 字节数组流的构造方法

ByteArrayInputStream(byte[] buf);

ByteArrayInputStream(byte[] buf, int offset, int length);

ByteArrayOutputStream(); 创建字节输出流的同时内存中会创建一个byte[]字节数组，默认大小。

ByteArrayOutputStream(int size); 创建字节输出流的同时内存中会创建一个大小为size的byte[]字节数组。

在使用的时候，可以用byte[] b = byteArrayOutputStream.toByteArray()返回流中的字节数组，然后创建ByteArrayInputStream bai = new

ByteArrayInputStream(byte[] b)来将输入流接入到字节数组上。

3 例子：

package test.io.data;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
public class DataByteArrayStreamTest {
     public static void main(String args[]){
           ByteArrayOutputStream baos = new ByteArrayOutputStream();
           DataOutputStream dos = new DataOutputStream(baos);
           ByteArrayInputStream bais = null;
           DataInputStream dis = null;
           try {
                dos.writeDouble(Math.random());
                dos.writeBoolean(true);
                dos.flush();
                bais = new ByteArrayInputStream(baos.toByteArray());
                dis = new DataInputStream(bais);
                System.out.println(dis.available());
            
                System.out.println(dis.readDouble());
                System.out.println(dis.readBoolean());
           } catch (IOException e) {
                e.printStackTrace();
           }finally{
                try {
                     if(baos != null){
                           baos.close();
                     }
                     if(dos != null){
                           dos.close();
                     }
                     if(bais != null){
                           bais.close();
                     }
                     if(dis != null){
                           dis.close();
                     }
                } catch (IOException e) {
                     e.printStackTrace();
                }
           }    
     }
}
 

4 节点流

1. 数据源或目的地为：字节数组

2. 只有字节流，没有字符流

作用：

提高空间利用率

压缩内容，在网络传输时，能有效压缩传输数据的大小，从而提高效率

5 文件读取到字节数组，再从字节数组读取到文件

四个步骤：
1、创建源
2、选择流
3、操作
4、释放资源

6

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.Date;

public class Test {
    public static void main(String[] args) {
        byte [] buf=write();
        read(buf);
    }
    public static byte[] write(){
       
        ByteArrayOutputStream baos=null;
        ObjectOutputStream oos=null;

        try {
            baos=new ByteArrayOutputStream();
            oos=new ObjectOutputStream(baos);
            oos.writeInt(98);
            oos.writeDouble(98.5);
            oos.writeChar('a');
            oos.writeBoolean(false);
            oos.writeObject(new Date(1000));
        } catch (IOException e) {
          
            e.printStackTrace();
        }finally{
           
            if (oos!=null) {
                try {
                    oos.close();
                } catch (IOException e) {
                   
                    e.printStackTrace();
                }
            }
        }

        return baos.toByteArray();
    }
    public static void read(byte [] buf){
        ByteArrayInputStream bais=null;
        ObjectInputStream ois=null;
 
        try {
            bais=new ByteArrayInputStream(buf); 
            ois=new ObjectInputStream(bais);

     
            System.out.println(ois.readInt());
            System.out.println(ois.readDouble());
            System.out.println(ois.readChar());
            System.out.println(ois.readBoolean());
            System.out.println(ois.readObject());
        } catch (ClassNotFoundException e) {
            
            e.printStackTrace();
        } catch (IOException e) {
            
            e.printStackTrace();
        }finally{

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