[19/04/01-星期一] IO技术_字节流分类总结(含字节数组(Array)流、字节数据(Data)流、字节对象(Object)流)

一、字节流分类概括

-->1、ByteArrayInputStream /ByteArrayOutputStream(数组字节输入输出)

       InputStream/OutputStream            -->2、FileInputStream/FileOutputStream(文件字节输入输出流【参考19.03.30文章】)

(四大抽象类之二,与Reader/Writer平辈)   -->3、ObjectInputStream/ObjectOutputStream(对象字节输入输出流)

-->4、FilterInputStream/FilterOutputStream(加装饰器的输入/输出流)-----》》

----------------》》4-1：BufferedInputStream/BufferedOutputStream(带缓冲区的字节流)  【参考19.3.30文章】

----------------》》4-2：DataInputStream/DataOutputStream(数据输入/输出流)

----------------》》4-3：【独有】PrintStream打印输出流、处理流

1、ByteArrayInputStream /ByteArrayOutputStream(数组字节输入输出)

 /**学习 1、文件数组字节流 (InputStream/OutputStream的亲儿子)
 * ByteArrayInputStream /ByteArrayOutputStream(文件数组字节输入输出)与FileInputStream/FileOutputStream平辈
 * 以前源头：本地电脑硬盘文件<-----操作系统----->Java虚拟机  。以前的FileInputStream/FileOutputStream的用法
 *          所以每次都要通知操作系统释放内存
 * 现在源头：本地电脑的另外一块内存/网络上的一块内存/远程服务器的一块内存 ，看成一块字节数组，所以可以让Java虚拟机直接访问
 * 与操作系统无关，使用完后由垃圾回收机制管理，不用释放内存。风格统一，可以释放内存，是实际没作用。
 * 1、任何东西都可以转成字节数组 2、字节数组不要太大
 *
 * 写数据：ByteArrayOutputStream
 * 不需要指定文件目的地，这点与FileOutputStream(如需要自己指定个"dest.txt")不同,因为是内存写的，大小不好管理
 * 可以不用释放操作
  *
  */
 package cn.sxt.test;

 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;

 public class Test_0401_ArrayStream {
     public static void main(String[] args) throws IOException {
         //1、创建源 字符串，编码成字节数组
         byte[] src="I am angry,Are you OK!".getBytes();
         //2、选择流
         ByteArrayInputStream bStream=new ByteArrayInputStream(src);
         //3、选择操作
         int len=0;
        /*3-1： 不借助数组，简单粗暴
         while ((len=bStream.read())!=-1) { //等于说读一个字节输出一个字节
             System.out.print((char)len);
         }*/
         //4、可以释放内存，保持统一 ，但其方法是个空方法 ，没什么卵用
         bStream.close();
         //3-2 ：借助数组，常用方法
         byte butter[] =new byte[5];
         /*
         while ((len=bStream.read(butter))!=-1) {//往butter读取每5个字符，解码换行输出一回。 循环往复
             String msg=new String(butter,0,butter.length);
             System.out.println(msg);
         }*/

         //-------------分隔符----写数据(往内存中写，这里内存实际就是输出流的缓冲区)---

         ByteArrayOutputStream bStream2=new ByteArrayOutputStream();//默认构建一个32字节的缓冲区,且内容会自动增加)
         bStream2.write(src);//把经过编码后的字节src 写入到内存中，也就是输出流缓冲区
         byte[] dest=bStream2.toByteArray();//向缓冲区取数据
         System.out.println(dest.length+"-->>"+new String(dest,0,dest.length));//数据展示

     }

 }

【综合练习-复制图片】

 /** 复制一张图片 所有东西都能读到字节数组中
  * 前面4种流的综合
  * ByteArrayInputStream /ByteArrayOutputStream  FileInputStream/FileOutputStream
  * 图片---FileInputStream------->(借助程序作中转，Java虚拟机)---ByteArrayOutputStream------>字节数组中(内存)
  * 字节数组(内存)----ByteArrayInputStream---->(借助程序作中转，Java虚拟机)---FileOutputStream-------->图片
  *
  */
 package cn.sxt.test;

 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.FileInputStream;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;

 public class Test_0401_CopyImage {
     public static void main(String[] args) throws IOException {
         byte[] srcFile= fileToByteArray("SongYi.jpg");
         System.out.println(srcFile.length);//输出源文件图片的大小
         ByteArrayToFile(srcFile, "SongYi_copy.jpg");

     }
     //1、图片到字节数组 传进去一个源文件路径。    图片-->程序--->字节数组
     public static byte[]  fileToByteArray(String srcFilePath) throws IOException {

         InputStream iStream=new FileInputStream(srcFilePath);//图片-->程序
         ByteArrayOutputStream oStream=new ByteArrayOutputStream();//程序-->字节数组
         byte buffer[]=new byte[1024*10]; //缓冲数组
         int len=0; //分段读取
         while ((len=iStream.read(buffer))!=-1) {
             oStream.write(buffer,0,len);

         }
         iStream.close();

         return oStream.toByteArray();

     }

     //2、字节数组到图片 字节数组--->程序--->要复制的图片
     public static void  ByteArrayToFile(byte[] src,String destFilePath) throws IOException {

         ByteArrayInputStream iStream1=new ByteArrayInputStream(src);//字节数组-->程序

         OutputStream oStream1=new FileOutputStream(destFilePath);//程序--->要复制的图片

         byte buffer1[]=new byte[1024*10]; //缓冲数组
         int len=0; //分段读取
         while ((len=iStream1.read(buffer1))!=-1) {
             oStream1.write(buffer1,0,len);
         }
         oStream1.close();
     }

 }

2、ObjectInputStream/ObjectOutputStream(对象字节输入输出流)

当两个进程远程通信时，彼此可以发送各种类型的数据。 无论是何种类型的数据，都会以二进制序列的形式在网络上传送。

比如，我们可以通过http协议发送字符串信息;我们也可以在网络上直接发送Java对象。发送方需要把这个Java对象转换为字节序列，

才能在网络上传送;接收方则需要把字节序列再恢复为Java对象才能正常读取。把Java对象转换为字节序列的过程称为对象的序列化。

把字节序列恢复为Java对象的过程称为对象的反序列化。

对象序列化的作用有如下两种：

1. 持久化： 把对象的字节序列永久地保存到硬盘上，通常存放在一个文件中，比如：休眠的实现。以后服务器session管理，hibernate将对象持久化实现。

2. 网络通信：在网络上传送对象的字节序列。比如：服务器之间的数据通信、对象传递。

【代码示例】

 /**2、对象流 ObjectStream
  * 输出流：序列化
  * 输入流：反序列化
  *ObjectOutputStream 对象输出流，它的writeObject(Object obj)方法可对参数指定的obj对象进行序列化，
  *把得到的字节序列写到一个目标输出流中。这个目标输入流可能是文件，数据库，内存中。
  *
   ObjectInputStream  对象输入流，它的readObject()方法从一个源输入流中读取字节序列
   ，再把它们反序列化为一个对象，并将其返回。

       只有实现了Serializable接口的类的对象才能被序列化。 Serializable接口是一个空接口，只起到标记作用。
  *
  * 不是所有的对象都可序列化
  */
 package cn.sxt.test;

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

 import javax.tools.JavaCompiler;

 public class Test_0401_ObjectStream {
     public static void main(String[] args) throws IOException, ClassNotFoundException {

         ByteArrayOutputStream baos=new ByteArrayOutputStream();
         ObjectOutputStream dos=new ObjectOutputStream(baos);

         dos.writeUTF("编码");
         dos.writeInt(345);
         //写入：序列化
         dos.writeObject("编码好痛苦");//字符串也是一个对象
         dos.writeObject(new Date());
         dos.writeObject(new Employee("李白",3458.4));

         dos.flush();

         //错误原因：byte[] datas=baos.toByteArray();放在了oos.writeInt(14);oos.flush();的前边,应该在后边
         byte[] datas=baos.toByteArray();

         //DataInputStream dis=new DataInputStream(new ByteArrayInputStream(datas));

         ByteArrayInputStream bis=new ByteArrayInputStream(datas);
         ObjectInputStream dis=new ObjectInputStream(bis);

         //读取 ：反序列化
         String msg=dis.readUTF();
         System.out.println(msg);
         System.out.println(dis.readInt());
         System.out.println(dis.readObject());
         System.out.println(dis.readObject());
         //System.out.println(dis.readObject());
         //同理前边的字符串类也可以这样操作
         Object employee=dis.readObject();
         if (employee instanceof Employee) {//如果employee 是Employee类的实例化对象则输出
             Employee employeetemp=(Employee)employee;//而且可以强制转换一下
             System.out.println(employeetemp); 

             System.out.println("名字："+employeetemp.getName());
             //可以看出薪水的属性加了transient透明修饰,这里的返回值为0.0
             System.out.println("薪水："+employeetemp.getSalary());

         }

     }

 }

 //自己定义的一个类,称之为Javabean封装数据用的。这里还必须要序列化(Serializable)，加个牌照，否则虚拟机后拦截的
 class Employee implements java.io.Serializable{
     private  String name;

     private transient double salary;//transient:短暂的，临时的  这里翻译为透明的、隐身的.敏感数据可以用。这里不需要序列化

     //按键alt+shift+s 出现上面菜单  无参构造 : 快捷键 下边 Generate Constructors from Supperclass..
     //.根据基类的构造函数生成构造函数，生成和基类参数相同的构造函数，并同时调用基类的构造函数。
     public Employee() {
         super();
     }

     //构造方法 Generate Constructor using Fields...
     //      使用类属性生成构造函数，就是说会生成使用你定义好的属性作为参数的构造函数。
     public Employee(String name, double salary) {
         super();
         this.name = name;
         this.salary = salary;
     }

     public String getName() {
         return name;
     }

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

     public double getSalary() {
         return salary;
     }

     public void setSalary(double salary) {
         this.salary = salary;
     }

    //重写 toString 方法
     public String toString() {
         return "雇员 [name=" + name + ", salary=" + salary + "]";
     }

 }

4-2：DataInputStream/DataOutputStream(数据输入/输出流)

【代码示例】

 /**
  *4-2：DataInputStream/DataOutputStream(数据输入/输出流)
  *用途：方便处理8大基本数据类型
  *1) 先写出后读取
  *2) 读取顺序和写出保持一致
  *
  */
 package cn.sxt.test;

 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.DataInputStream;
 import java.io.DataOutputStream;
 import java.io.FileInputStream;
 import java.io.FileOutputStream;
 import java.io.IOException;

 public class Test_0401_DataStream {
     public static void main(String[] args) throws IOException {
         //先搞个节点流ByteArrayInputStream /ByteArrayOutputStream或FileInputStream/FileOutputStream
         //然后让装饰流去操作他们，否则装饰流就是无源之水，无本之木。//默认构建一个32字节的缓冲区,且内容会自动增
         //ByteArrayOutputStream bos=new ByteArrayOutputStream();//这个流不用关闭

         //写出,使用数组作为节点流时
         FileOutputStream out = new FileOutputStream("D:/a1.txt");
         DataOutputStream dos=new DataOutputStream(out);

         //byte[] datas=bos.toByteArray();//转成字节放在字节数组中

         dos.writeChar('a');
         dos.writeInt(10);
         dos.writeDouble(Math.random());
         dos.writeBoolean(true);
         dos.writeUTF("Are you OK");
         dos.flush();

         //读取顺序与写入保持一致
         //ByteArrayInputStream bis=new ByteArrayInputStream(datas);//从字节数组中读取
         FileInputStream in = new FileInputStream("D:/a1.txt");
         DataInputStream dis=new DataInputStream(in);

         System.out.println("char: " + dis.readChar());
         System.out.println("int: " + dis.readInt());
         System.out.println("double: " + dis.readDouble());
         System.out.println("boolean: " + dis.readBoolean());
         System.out.println("String: " + dis.readUTF());

         dos.close();
         dis.close();

         //数组作为字节流
     /*    ByteArrayOutputStream baos=new ByteArrayOutputStream();
         DataOutputStream dos=new DataOutputStream(baos);

         dos.writeUTF("编码");
         dos.writeInt(345);
         dos.flush();

         byte[] datas=baos.toByteArray();

         //DataInputStream dis=new DataInputStream(new ByteArrayInputStream(datas));

         ByteArrayInputStream bis=new ByteArrayInputStream(datas);
         DataInputStream dis=new DataInputStream(bis);*/

     }

 }

4-3：【独有】PrintStream打印输出流、处理流

【代码示例】

 /**
  * 学习4-3：打印流、处理流PrintStream
  *
  */
 package cn.sxt.test;

 import java.io.FileDescriptor;
 import java.io.FileNotFoundException;
 import java.io.FileOutputStream;
 import java.io.PrintStream;
 import java.io.PrintWriter;

 public class Test_0401_PrintStream {
     public static void main(String[] args) throws FileNotFoundException {
         PrintStream pStream=System.out;
         pStream.println("人生如逆旅"); //输出内容到控制台
         pStream.println(true);
         //2个打印流的效果一样
         PrintWriter pWriter=new PrintWriter(new FileOutputStream("print3.txt"),true);
         pWriter.print("学习Java");
         pWriter.close();

         FileOutputStream file=new FileOutputStream("print.txt");
         PrintStream pStream2=new PrintStream(file,true);//在里面放个字节流 true:使用自动刷新的功能
         pStream2.println(false); //输出内容到文件
         pStream2.println("人生苦短，学习要趁早！");
         pStream2.println("java is best");

         //重定向输出端 把原本输出到控制台的输出到文件中去
         System.setOut(pStream2);
         pStream2.println("改变自己");
         //重定向回去控制台 FileDescriptor.out 标准的输入输出端
         FileOutputStream file2=new FileOutputStream(FileDescriptor.out);
         PrintStream pStream3=new PrintStream(file2,true);
         System.setOut(pStream3);
         pStream3.println("back");

         /*//效果一样
         System.setOut(pStream);
         pStream.print("回来了");*/

         pStream.close();
         pStream2.close();
         pStream3.close();
     }

 }