JavaIO
Java中IO的基本概况，以及在使用过程中涉及到的序列化，同时将Roaringbitmap的序列化以及反序列化做个编写示例
JAVA中IO流体系
1.四大IO抽象类
一、文件 字节流
读取和写入：
利用文件流实现文件的复制
二、文件 字符流
使用FileReader与FileWriter实现文本文件的复制
三、缓冲 字节流: BufferedInputStream 和 BufferedOutputStream 这两个流是缓冲字节流，通过内部缓存数组来提高操作流的效率
四、缓冲 字符流
字节流在操作时本身不会用到缓冲区（内存），是文件本身直接操作的，
而字符流在操作时使用了缓冲区，通过缓冲区再操作文件
从文件的角度
FileInputStream 通过字节的方式读取文件，适合读取所有类型的文件(图像、视频、文本文件等)。
Java也提供了 FileReader 专门读取文本文件。
FileOutputStream 通过字节的方式写数据到文件中，适合所有类型的文件。
Java也提供了 FileWriter 专门写入文本文件
2.input stream of bytes
InputStream 和 OutputStream 是字节流的两个顶层父类，提供了输入流类和输出流类的通用API
java.io.DataInput
DataInput 接口用于从二进制流中读取字节，并重构所有 Java 基本类型数据
DataOutput 接口提供将数据从任何Java基本类型转换为一系列字节，并将这些字节写入二进制流
DataInputStream 是数据输入流。它继承于FilterInputStream。
public class DataInputStream extends FilterInputStream implements DataInput {}
构造函数 DataInputStream(InputStream in)
public abstract class InputStream implements Closeable {
* @see java.io.BufferedInputStream
* @see java.io.ByteArrayInputStream
* @see java.io.DataInputStream
* @see java.io.FilterInputStream
* @see java.io.InputStream#read()
* @see java.io.OutputStream
* @see java.io.PushbackInputStream
*/
public abstract class OutputStream implements Closeable, Flushable {}
* that writes one byte of output.
* @see java.io.BufferedOutputStream
* @see java.io.ByteArrayOutputStream
* @see java.io.DataOutputStream
* @see java.io.FilterOutputStream
* @see java.io.InputStream
* @see java.io.OutputStream#write(int)
*/
3.a new byte array output stream
ByteArrayOutputStream
outRR.deserialize(new DataInputStream(new ByteArrayInputStream(outBytes)));
inRR.deserialize(new DataInputStream(new ByteArrayInputStream(inBytes)));
outRR.or(inRR);
ByteArrayOutputStream bos = new ByteArrayOutputStream();
outRR.serialize(new DataOutputStream(bos));
result = bos.toByteArray();
ByteArrayOutputStream.toByteArray() 将缓冲区的数据全部获取出来，返回字节数组，
然后通过string 的方法，使用指定的字符集，通过解码字节将缓冲区内容转换为字符串
4. deserialize 和 serialize
序列化和反序列化 将对象转换成与平台无关的二进制流 序列化机制可以使对象可以脱离程序的运行而对立存在。
如何实现对象的序列化：
Java io 分类方式
根据是否直接处理数据，
Java io又分为节点流和处理流，节点流是真正直接处理数据的；处理流是装饰加工节点流的
节点流
文件流： FileInputStream FileOutputStrean FileReader，FileWriter，它们都会直接操作文件，直接与 OS 底层交互。因此他们被称为节点流 ，注意：使用这几个流的对象之后，需要关闭流对象，因为 java 垃圾回收器不会主动回收。不过在 Java7 之后，可以在 try() 括号中打开流，最后程序会自动关闭流对象，不再需要显示地 close。
数组流： ByteArrayInputStream ByteArrayOutputStream CharArrayReader，CharArrayWriter，对数组进行处理的节点流。
字符串流： StringReader StringWriter，其中 StringReader 能从 String 中读取数据并保存到 char 数组。
管道流： PipedInputStream PipedOutputStream PipedReader，PipedWrite，对管道进行处理的节点流。
处理流
处理流 处理流的构造方法总是要带一个其他的流对象做参数。
处理流是对一个已存在的流的连接和封装，通过所封装的流的功能调用实现数据读写。如 BufferedReader。
缓冲流 ：BufferedImputStrean，BufferedOutputStream，BufferedReader ，BufferedWriter，
需要父类作为参数构造，增加缓冲功能， 避免频繁读写硬盘，可以初始化缓冲数据的大小，由于带了缓冲功能，所以就写数据的时候需要使用 flush 方法
ByteArrayInputStream StringBufferInputStream FileInputStream
是三种基本的介质流，它们分别从 Byte 数组、StringBuffer、和本地文件中读取数据
字节输入流
BufferedOutputStream （输入流）、 BufferedInputStream （输出流）
DataOutputStream （输入流）、 DataInputStream （输出流）：
数据字节输入输出流（高级流），
在用该流进行文件复制时，不支持复制视频音频文件，会出现编码错误，只支持普通文件。
InputStream InputStream这个抽象类是所有基于字节的输入流的超类，抽象了Java的字节输入模型
PUBLIC class FileInputStream extends InputStream
PUBLIC class FilterInputStream extends InputStream {
PUBLIC class BufferedInputStream extends FilterInputStream {
PUBLIC class DataInputStream extends FilterInputStream implements DataInput {
PUBLIC class ObjectInputStream extends InputStream implements ObjectInput, ObjectStreamConstants
PUBLIC class ByteArrayInputStream extends InputStream {
public class PipedInputStream extends InputStream {
PUBLIC class PushbackInputStream extends FilterInputStream {
PUBLIC class SequenceInputStream extends InputStream {
序列化介质
将对象序列化存储到本地文件中去，
将对象序列化成byte[]存放到缓存中
序列化到文件
public class JavaSerializableExp {
public static void main(String[] args) {
PairObj obj = new PairObj(200, 2,"mylife");
String fileString = "F:\sources\sfm.txt";
try {
//file对应相应的.txt文件
File file = new File(fileString);
//步骤一：创建一个 ObjectOutputStream 输出流；
//步骤二：调用 ObjectOutputStream 对象的 writeObject 输出可序列化对象。
//将对象写入ObjectOutputStream中 , 再转化到FileOutputStream并输出到文件中
//通过重写writeObject与readObject方法，可以自己选择哪些属性需要序列化， 哪些属性不需要
FileOutputStream fos = new FileOutputStream(file);
ObjectOutputStream oos = new ObjectOutputStream(fos);
//obj即对应的对象
oos.writeObject(obj);
oos.flush();
//关闭流,否则再次write时易出现文件空白的情况
oos.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
//反序列化
ObjectInputStream ois = null;
try {
ois = new ObjectInputStream(new FileInputStream(fileString));
PairObj stu2 = (PairObj) ois.readObject();
System.out.println("The same Jvm");
System.out.println(stu2);
System.out.println(stu2.getFirst());
System.out.println(stu2.getSecond());
System.out.println(stu2.getPassword());
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
序列化数组
序列化为数组- 对象p实现序列化接口Serializable
把序列化对象p套一个对象输出流，对象输出流再套一个字节数组输出流。最后转成对象字节数组
ObjectOutputStream oos=new ObjectOutputSream(new ByteArrayOutputSream());
oos.writeObject(p);
byte[] pBytes=ba.toByteArray();
序列化:
try {
ByteArrayOutputStream obj = new ByteArrayOutputStream();
ObjectOutputStream out = new ObjectOutputStream(obj);
out.writeObject(this);
return obj.toByteArray();
} catch (IOException e) {
e.printStackTrace();
}
反序列化:
ByteArrayInputStream bin = new ByteArrayInputStream((byte[])objs);
try {
ObjectInputStream obin = new ObjectInputStream(bin);
Object obj = obin.readObject();
} catcch(Exception e) {
e.printStackTrace();
}
RoaringBitmap序列化到文件
public class RoaringBitMapSerialize {
public static String fileString = "F:\sources\sfm.txt";
public static void main(String[] args) {
//序列化Roaringbitmap数据
RoaringBitmap outRR = RoaringBitmap.bitmapOf(1, 9, 3, 1000);
outRR.add(5);
/**
* 将RoaringBitmap 对象序列化存储到本地文件中去，
*/
try {
//file对应相应的.txt文件
File file = new File(fileString);
FileOutputStream fos = new FileOutputStream(file);
ObjectOutputStream oos = new ObjectOutputStream(fos);
//obj即对应的对象
outRR.serialize(oos);
oos.flush();
//关闭流,否则再次write时易出现文件空白的情况
oos.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
System.out.println("序列化到文件完成");
RoaringBitmap outRR = new RoaringBitmap();
/**
* 将RoaringBitmap 对象从本地文件中反序列化，
*/
try {
InputStream inputStream = new FileInputStream(fileString);
ObjectInputStream ois = new ObjectInputStream(inputStream);
outRR.deserialize(new DataInputStream(ois));
System.out.println("反序列化到文件完成");
System.out.println(outRR.getCardinality());
// 遍历放入List中
List<Integer> numbers = new ArrayList<>();
outRR.forEach((IntConsumer) numbers::add);
System.out.println(numbers);
// 遍历输出
outRR.forEach((IntConsumer)i -> System.out.println(i));
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
RoaringBitmap序列化到byte[]存放到缓存中
public class RoaringBitmapByteDeserialize {
public static void main(String[] args){
//序列化Roaringbitmap数据
RoaringBitmap outRBM =new RoaringBitmap();
outRBM.add(1);
outRBM.add(3);
outRBM.add(9);
outRBM.add(100);
byte[] pBytes= null;
RoaringBitmap outRR = new RoaringBitmap();
byte[] result= null;
try {
//1.序列化 Roaringbitmap
ByteArrayOutputStream bos = new ByteArrayOutputStream();
outRBM.serialize(new DataOutputStream(bos));
//obj即对应的对象
pBytes = bos.toByteArray();
bos.flush();
//关闭流,否则再次write时易出现文件空白的情况
bos.close();
System.out.println("序列化到ByteArray 缓存完成");
//2.反序列化 Roaringbitmap 并计算结构
outRR.deserialize(new DataInputStream(new ByteArrayInputStream(pBytes)));
outRR.forEach((IntConsumer) i -> System.out.println(i));
outRR.add(50);
//3.序列化的Roaringbitmap进行计算
System.out.println("计算后的数据是");
outRR.forEach((IntConsumer) i -> System.out.println(i));
//序列化 Roaringbitmap
ByteArrayOutputStream nbos = new ByteArrayOutputStream();
outRR.serialize(new DataOutputStream(nbos));
result = nbos.toByteArray();
nbos.flush();
//关闭流,否则再次write时易出现文件空白的情况
nbos.close();
} catch (
FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}