Java IO 字节流 字符流操作

Java IO 字节流 字符流操作

Java.io 包几乎包含了所有操作输入、输出需要的类。所有这些流类代表了输入源和输出目标。一个流被定义为一个数据序列。输入流用于从源读取数据，输出流用于向目标写数据。

Java.io 包中的流支持很多种格式，比如：基本类型、对象、本地化字符集等等。

一个流可以理解为一个数据的序列。输入流表示从一个源读取数据，输出流表示向一个目标写数据。

Java 为 I/O 提供了强大的而灵活的支持，使其更广泛地应用到文件传输和网络编程中。

InputStream,DataInputStream,ObjectInputStream,ByteArrayInputStream,FileInputStream,BufferedInputStream

OutputStream,DataOutputStream,ObjectOutputStream,ByteArrayOutputStream,FileOutputStream,BufferedOutputStream

InputStream

字节输入流的超类，一般使用它的子类：FileInputStream等；

OutputStream

字节输出流的超类，一般使用它的子类：FileOutputStream等，它能输出字节流；

BufferedInputStream

是带缓冲区的输入流，默认缓冲区大小是8M，能够减少访问磁盘的次数，提高文件读取性能；

BufferedOutputStream是带缓冲区的输出流，能够提高文件的写入效率。

BufferedInputStream与BufferedOutputStream分别是FilterInputStream类和FilterOutputStream类的子类，实现了装饰设计模式。

ByteArrayInputStream、ByteArrayOutputStream

字节数组输入/输出流

ByteArrayInputStream、ByteArrayOutputStream

文件输入/输出流

DataOutputStream

以适当方式将基本 Java 数据类型写入输出流中。

DataInputStream

以与机器无关方式从底层输入流中读取基本 Java 数据类型

ObjectInputStream

对象输入流反序列化

ObjectOutputStream

对象输出流序列化

先序列化，后反序列化，反序列化顺序必须与序列化顺序一致。

不是所有的对象都可以序列化，必须实现Java.io.Serializable接口。

不是所有的属性都需要序列化，不需要使用序列化的属性使用transient

InputStreamReader

是字节流与字符流之间的桥梁，能将字节流输出为字符流，并且能为字节流指定字符集，可输出一个个的字符；

BufferedReader

提供通用的缓冲方式文本读取，readLine读取一个文本行， 从字符输入流中读取文本，缓冲各个字符，从而提供字符、数组和行的高效读取。

示例

ByteArrayInputStream/ByteArrayOutputStream

File fdest  = new File(destPath); //数据输入文件      
        File fsrc = new File(srcPath);  //数据输入文件
        byte[] dest = null; //字节数组输出

        //文件输入流
        InputStream is = new BufferedInputStream(new FileInputStream(fsrc)); 
        //字节数组输出流
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        byte[] flush = new byte];
        int len =;
        while!=(len=is.read(flush))) {
            bos.write(flush,len); //写出到字节数组流中
        }
        bos.flush();

        //获取数据，转换为字节数组输出
        dest = bos.toByteArray();       
        bos.close();
        is.close();

        //字节数组输入流
        InputStream is = new BufferedInputStream(new ByteArrayInputStream(dest));
        //文件输出流
        OutputStream os = new BufferedOutputStream(new FileOutputStream(fdest));
        byte[] flush = new byte];
        int len =;
        while!=(len=is.read(flush))){
            os.write(flush,len); //写出到文件
        }
        os.flush(); 
        os.close();
        is.close();
        //FileUtil.close(os,is);
           

示例 1

DataInputStream/DataOutputStream

byte[] dest = null;
        double point = ;
        long num = L;
        String str  = "data type";

        //字节输出流
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        //数据输出流
        //文件输出
        //DataOutputStream dos = new DataOutputStream(
        //        new BufferedOutputStream(new FileOutputStream(dest))
        //        );
        //字节数组输出
        DataOutputStream dos = new DataOutputStream(
                new BufferedOutputStream(bos));
        dos.writeDouble(point); //写入double数据到流中
        dos.writeLong(num);
        dos.writeUTF(str);
        dos.flush();
        dest =bos.toByteArray();//得到字节数组输出
        dos.close();    

        //数据输入流
        //文件输入
        //DataInputStream dis = new DataInputStream(
        //         new BufferedInputStream(new FileInputStream(src))
        //    );  
        //字节数组输入       
        DataInputStream dis = new DataInputStream(
                new BufferedInputStream(new ByteArrayInputStream(dest)));
        //读取顺序需跟写入顺序相同才能正确读取
        point = dis.readDouble(); 
        num = dis.readLong();
        str = dis.readUTF();
        dis.close(); 
        System.out.println("point="+point+",num="+num+",str="+str);  
           

示例 2

Java序列化是指把Java对象转换为字节序列的过程；

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

ObjectInputStream/ObjectOutputStream

public class Student implements java.io.Serializable{
    private transient String name;  //不需要序列化
    private int age;
    public Student(){
    }
    public Student(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return salary;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

//写入
Student st = new Student("wangxiaoming",);
Student st0 = new Student("lilin",);
//创建源
File dest = new File(destPath);
//对象输出流，序列化到文件，生成字节流
ObjectOutputStream dos = new ObjectOutputStream(
     new BufferedOutputStream(new FileOutputStream(dest)));      
dos.writeObject(st);
dos.writeObject(st0);
dos.close();

//对象输入流，反序列化从文件，生成对象
ObjectInputStream dis = new ObjectInputStream(
                new BufferedInputStream(new FileInputStream(dest)));
//读取流、生成对象
Object obj = dis.readObject();
if(obj instanceof Student){
     Student st= (Student)obj;
     System.out.println("name="st.getName()+",age="+emp.getAge());
}
dis.close();
           

示例3

System.in ： 输入流 键盘输入

System.out： 输出流 标准输出

System.err : 输出流 错误信息输出

字节流 – 转换流 – 字符流

InputStream –> BufferedReader –> BufferedReader

InputStream is = System.in;//字节流
        //InputStreamReader是字节流通向字符流的桥梁
        BufferedReader br = new BufferedReader(new InputStreamReader(is));
        System.out.println("input：");
        String msg = br.readLine();//处理一行
        System.out.println(msg);
           

示例4：

PrintStream 打印流

PrintStream 继承了 OutputStream类，并且实现了方法 write()。write() 可以用来往控制台写操作，控制台的输出由 print( ) 和 println() 完成，这些方法都由类 PrintStream 定义。

//输出到文件
        File src = new File(destPath);
        PrintStream ps = System.out;
        ps.println(false);
        //打印流，输出到文件
        ps = new PrintStream(new BufferedOutputStream(new FileOutputStream(src,true)));  //false覆盖方式输出到文件，true追加方式输出到文件    
        ps.println("print output！");
        ps.close();