zoukankan      html  css  js  c++  java
  • Java之IO流进阶篇:内存流,打印流,对象流

    Java中的IO流,即为输入输出流。所谓输入输出流,都是相对于程序而言,程序就是这个参照物。一张图看懂输入输出流:

     

      输入流抽象基类:InputStream,Reader

      输出流抽象基类:OutputStream,Writer

      输入输出流子类众多,详情见下图:

      

    1.内存流

      用来操作内存

      ByteArrayInputStream     内存到程序  不需要关闭  不使用内存资源,内存不够建议不用

      ByteArrayOutputStream  程序到内存  不需要关闭  不使用内存资源,内存不够建议不用

    内存输入流和内存输出流:

    首先创建字节数组,一般引用数据类型存放在内存中。显然此时,可以创建字节数组输入流,读入程序当中。

    package com.test;
    
    import java.io.ByteArrayInputStream;
    import java.io.IOException;
    
    public class ByteArrayInputStreamDemo {
    
        public static void main(String[] args) throws IOException {
            // TODO Auto-generated method stub
            //1.创建字节数组(要读取的数据)
            byte[] data= {10,15,50,33,12,22};
            //2.创建流
            ByteArrayInputStream bais=new ByteArrayInputStream(data);
            //3.读取
    //        int d;
    //        while((d=bais.read())!=-1) {
    //            System.out.println(d);
    //        }
    //        bais.close();//实际操作中无需关闭流
            byte[] buf=new byte[1024];
            int len;
            while((len=bais.read(buf))!=-1) {
                for (int i = 0; i < len; i++) {
                    System.out.println(buf[i]);
                }
            }
        }
    }
    package com.test;
    
    import java.io.ByteArrayOutputStream;
    
    public class ByteArrayOutputStreamDemo {
    
        public static void main(String[] args) {
            // TODO Auto-generated method stub
            //1.创建字节数组输出流对象
            ByteArrayOutputStream baos=new ByteArrayOutputStream();
            //2.写入数据
            baos.write(12);
            baos.write(20);
            baos.write(18);
            baos.write(32);
            //3.获取输出流中的字节数据
            byte[] data=baos.toByteArray();
            for (byte b : data) {
                System.out.println(b);
            }
        }
    }

    使用内存流读取图片:

    package com.test;
    
    import java.io.ByteArrayInputStream;
    import java.io.ByteArrayOutputStream;
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    public class ReadImg {
    
        public static void main(String[] args) throws IOException {
            // TODO Auto-generated method stub
            //1.创建文件字节输入流
            FileInputStream fis=new FileInputStream("E:\xx.png");
            ByteArrayOutputStream baos=new ByteArrayOutputStream();
            byte[] buf=new byte[1024];
            //2.读取数据
            int len;
            while((len=fis.read(buf))!=-1) {
                baos.write(buf,0,len);
            }
            //3.获取图片数据
            byte[] imgbyte=baos.toByteArray();
            System.out.println(imgbyte.length);
            //4.创建文件输出流
            FileOutputStream fos=new FileOutputStream("E:\xx1.png");
            ByteArrayInputStream bais=new ByteArrayInputStream(imgbyte);
            //5.读取数组
            byte[] buf1=new byte[1024];
            int len1;
            while((len1=bais.read(buf1))!=-1) {
                fos.write(buf1,0,len1);
            }
            fis.close();
            fos.close();
            bais.close();
            baos.close();
        }
    
    }

    2.打印流

      PrintSream:操作字节,自动刷新,可设置字符集

      PrintWriter :不能操作字节,内部有缓冲区

    打印字节流实例:

    package com.test;
    
    import java.io.BufferedOutputStream;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.PrintStream;
    
    public class PrintStreamDemo {
        //打印流(字节)
        public static void main(String[] args) throws IOException {
            // TODO Auto-generated method stub
            //PrintStream ps=new PrintStream("E:\aaa.txt");
            BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream("E:\xx.txt"));
            PrintStream ps=new PrintStream(bos,true);
            ps.print("123456");
            ps.print(true);
            ps.println("abcdef");
            ps.printf("%d", 200);
            ps.printf("%.2f", 3.1415926);
            ps.printf("%s", "我爱生活");
            ps.printf("%x", 256);
            
        }
    
    }

     打印字符流实例:

    package com.test;
    
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.FileWriter;
    import java.io.IOException;
    import java.io.PrintWriter;
    
    public class PrintWriterDemo {
    
        public static void main(String[] args) throws IOException {
            // TODO Auto-generated method stub
            PrintWriter pw=new PrintWriter(new FileOutputStream("E:\bbb.txt"));
            pw.println("123");
            pw.close();
        }
    
    }

    3.对象序列化与反序列化(对象流)

      本例举一个学生类Student.class序列化和反序列化的过程。

    创建的学生类:

    package com.test;
    
    import java.io.Serializable;
    
    public class Student implements Serializable {
            private static final long serialVersionUID=123L;//序列化与反序列化的唯一标记
            private int StuNo;//序列化和访问权限没有关系
            String name;
            //transient int age;//transient 瞬时的,不能序列化瞬时的属性
            //static String address="北京";//静态变量不能被序列化
            public Student() {
                super();
                // TODO Auto-generated constructor stub
            }
            
            public Student(int stuNo, String name) {
                super();
                StuNo = stuNo;
                this.name = name;
            }
    
            public int getStuNo() {
                return StuNo;
            }
            public void setStuNo(int stuNo) {
                StuNo = stuNo;
            }
            public String getName() {
                return name;
            }
            public void setName(String name) {
                this.name = name;
            }
            
    }

      

    使用对象类序列化和反序列化学生类:

    package com.test;
    
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.ObjectInputStream;
    import java.io.ObjectOutputStream;
    
    public class SerializeDemo {
    
        public static void main(String[] args) throws IOException, ClassNotFoundException {
            //序列化过程:
            //1.创建序列化对象
            Student stu=new Student(1101,"小明");
            //2.创建文件输出流
            FileOutputStream fos=new FileOutputStream("E:\receive.bin");
            //3.创建对象流接入输出流
            ObjectOutputStream oos=new ObjectOutputStream(fos);
            //4.对象流输出序列化对象保存在文件中
            oos.writeObject(stu);
            oos.close();
            //反序列化过程:
            //1.创建对象流
            FileInputStream fis=new FileInputStream("E:\receive.bin") ;
            ObjectInputStream ois=new ObjectInputStream(fis);
            //2.反序列化
            Student stu1=(Student)ois.readObject();
            ois.close();
            System.out.println("学号:"+stu1.getStuNo());
            System.out.println("姓名:"+stu1.getName());
        }
    }

    控制台输出信息(表明反序列化成功):

  • 相关阅读:
    4 Apr 18 软件开发目录 logging模块的使用 序列化(Json, Pickle) os模块
    3 Apr 18 内置函数 列表生成式与生成器表达式 模块的使用之import 模块的使用之from…import…
    2 Apr 18 三元表达式 函数递归 匿名函数 内置函数
    30 Mar 18 迭代器 生成器 面向过程的编程
    29 Mar 18 函数 有参、无参装饰器
    28 Mar 18 函数
    27 Mar 18 函数的参数
    26 Mar 18 函数介绍
    23 Mar 18 文件处理
    22 Mar 18 补充数据类型+字符编码+文件处理
  • 原文地址:https://www.cnblogs.com/loober/p/10187714.html
Copyright © 2011-2022 走看看