6.5（java学习笔记）其他流（字节数组流,数据流,对象流,打印流）

一、字节数组流

　　之前使用输入输出流的操作的对象是文件，而这里字节数组流操作的对象是内存，内存可以看做是一个字节数组。

　　使用字节数组流读写就可以看做是从内存A到内存B的读写，对象时内存即字节数组。

　　

　　1.1构造方法

　　　　ByteArrayOutputStream()//创建一个字符数组输出流

　　　　ByteArrayInputStream(byte[] buf)//创建一个字节数组输入流，这里面的buff可看做内存对象即字符数组

　　

　　2.2主要方法

　　　　ByteArrayInputStream:

　　　　read(byte[] bu)//读取输入流中的数据，放入bu中。

　　　　ByteArrayOutputStream:

　　　　public void write(byte[] bu)//将bu（可看做内存对象数据），写入输出流。

　　　　byte[] toByteArray()//创建一个新的字节数组，并将输出流中数据放入其中。

　　2.3例子

　　　　

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

public class ByteArrayStream {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        read(write());
    }
    public static void read(byte[] by){
        int len = 0;
        //将内存对象B放入输入流
        InputStream r = new BufferedInputStream(new ByteArrayInputStream(by));//把这里的by看做内存对象
        byte[] flush = new byte[1024];//把flush看做另外一个内存对象
        try {
            //将内存对象B与输入流关联，来后通过输入流读取对象B数据放入flush中
            while(-1 != (len = r.read(flush))){//读取输入流中的数据放入flush，即读取内存对象B中的数据
                System.out.println(new String(flush,0,len));//打印出读取的数据
            }
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    
    public static byte[] write(){
        byte[] by = null;//内存对象B
        byte []info = "字节数组流".getBytes();//内存对象A
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        try {
            bos.write(info);//将内存A块内容写入输出流
            by = bos.toByteArray();//内存对象B接收输出流中的数据
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return by;//返回内存对象B
    }
    
}

运行结果：
字节数组流

wtire:首先将内存A的数据写入输出流，然后内存B获取输入流中的数据，最后将内存B作为返回值。

read:将内存B放入输入流，然后通过输入流读取内存B中的数据放入flush中，然后将flush转为字符打印出来。

这里在一个程序中运行看着有点奇怪而且不好理解，我们就把内存A内存B看着是两台电脑各自内存，这样便于理解一些。

二、数据流

　　采用数据流进行读写可以允许将原始java数据类型写入流中，即既保持了数据也保存了数据类型。

　　2.1构造方法

　　　　DataInputStream（InputStream  in）

　　　　DataOutputStream(OutStream out)

　　2.2主要方法

　　　　void writeInt(int v)//写入int型数据

　　　　void writeLong(long v)//写入long型数据

　　　　void writeUTF(String str)//将字符串以UTF-8格式写入输出流

　　　　

　　　　int readInt()//读取Int型数据并返回

　　　　long readLong()//读取long型数据并返回

　　　　String readUTF()//读取UTF-8转换的字符串

　　　　基本操作方法与文件读写无太大差别，只是加上了数据类型，这些方法时DataStream独有的方法，故调用它们要避免多态。

　　2.3例子

　　　　

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class DateStream {

    public static void main(String[] args) throws IOException {
        // TODO Auto-generated method stub
        write();
        read();
    }
    public static void read() throws IOException{
        DataInputStream dis = new DataInputStream(//数据流
                                    new BufferedInputStream(//缓冲流
                                            new FileInputStream(
                                                    new File("F:\依风\Desktop\data.txt")
                                                    )
                                            )
                                    );
        //注意：这里读取类型的顺序要和写入时的类型顺序对应，不然会出现错误。
        long lo = dis.readLong();//将不同类型用对应方法读出。
        int in = dis.readInt();
        String str = dis.readUTF();
        dis.close();
        System.out.println(lo + "-->" + in +"-->" + str);
    }
    
    public static void write() throws IOException{
        long lo = 100L;
        int in = 21;
        String str = "DataStream";
        DataOutputStream dos = new DataOutputStream(//数据流
                                     new BufferedOutputStream(//缓冲流
                                         new FileOutputStream(
                                             new File("F:\依风\Desktop\data.txt")
                                         )
                                     )
                               );
        dos.writeLong(lo);//将不同类型用对应的方法写入
        dos.writeInt(in);
        dos.writeUTF(str);
        dos.flush();
        dos.close();
    }
}

运行结果：
100-->21-->DataStream

这里一开始往文件中写入的是long型，然后是int类型最后是String

那么读取时也应该先读long,然后int最后String。

如果写入和读取的顺序不一致可能会导致读取的数据有误，也可以出现EOFException。

这里写入的数据不是给人类看的，而是给机器识别的。我可以打开写入的文件会发现里面会有乱码。

三、对象流

　　　　使用对象流，可以写入、读出对象的信息以及属性属性。对象流和之前输入输出流功能类似，

　　　　不过是将之前的文件换成了对象,这里的对象时我们通过new创建的对象。

　　　　将对象写如文件实质是是将对象转换为字节序列，然后将字节序列写入文件，这个称为序列化。

　　　　读取字节序列然后转换为对象就称为反序列化。

　　　　对象被序列化必须实现java.io.Serializable接口，改接口表示可以序列化。对象的类没有实现这个接口会出现一次次。

　　　　对象中某些属性不想被序列化可以加transient修饰，transient修饰就代表这个属性不参加序列化。

　　　　3.1构造方法

　　　　Public ObjectOutputStream(OutputStream out)

　　　　Public ObjectInputStream(InputStream in)

　　　　

　　　　3.2主要方法

 　　　　Object readObject()//从输入流中读取对象

　　　　 void writeObject(Object obj)//将obj写入输出流

　　　　3.3例子　

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
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 ObjectStream {
    public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException{
        read(write());
    }
    //将对象写入指定文件，并返回指定文件路径信息
    public static String write() throws FileNotFoundException, IOException{
        String filePath = "F:\依风\Desktop\ObjectStream.txt";
        ObjectOutputStream oos = new ObjectOutputStream(//使用独有方法，不发生多态
                                    new BufferedOutputStream(
                                        new FileOutputStream(
                                            new File(filePath))));
        oos.writeObject(new Employ("hcf",4000));//传入对象
        oos.flush();
        oos.close();
        return filePath;
    }
    
    //接受指定文件路径信息，并读取文件中的对象
    public static void read(String filePath) throws FileNotFoundException, IOException, ClassNotFoundException{
        ObjectInputStream ois = new ObjectInputStream(
                                    new BufferedInputStream(
                                        new FileInputStream(
                                            new File(filePath))));
        Employ em = (Employ)ois.readObject();//将读取的对象强制转型
        System.out.println(em.getName() + ":" + em.getMoney());//输出对象信息
    }
}


class Employ implements java.io.Serializable{//必须实现接口
    private transient String name;//姓名没有被序列化
    private int money;
    public Employ(){}
    public Employ(String name,int money){
        setName(name);
        setMoney(money);
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getMoney() {
        return money;
    }
    public void setMoney(int money) {
        this.money = money;
    }
}

运行结果：
null:4000

我们可以看到没有被序列化的属性显示为null

比如一个矩形类中有长、宽属性，还有面积属性，

那么序列化时可以不序列化面积属性，因为面积属性可以通过长宽计算出来。　　

四、打印流

　　　　打印流(PraintStream)类似输出流，但打印流使用方便而且可以打印出任何类型的数据。

　　　　想我们平常使用很多的System.out.println()就是调用打印流中的println（）方法。

　　　　4.1构造函数

　　　　PrintStream(OutputStream out)//创建打印流

　　　　PrintStream(OutputStream out, boolean autoFlush)//创建打印流，autoFlush为true代表自动刷新缓冲区
　　　　PrintStream(File fileName, String csn)//创建指定文件的打印流，csn为编码方式

　　　　4.3主要方法

　　　　print(......);//打印参数内容，几乎可为任何形式参数，末尾不加回车。

　　　　println(......)//打印参数内容，末尾加回车。

　　　　

　　　　

　　　　4.4例子　

import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.PrintStream;
import java.io.UnsupportedEncodingException;
import java.util.Scanner;

public class Print {
    public static void main(String[] args) throws FileNotFoundException, UnsupportedEncodingException{
        PrintStream ps = new PrintStream(//常规初始化
                new BufferedOutputStream(
                    new FileOutputStream(
                        new File("F:\依风\Desktop\print.txt"))));
        PrintStream pc = new PrintStream("F:\依风\Desktop\printCsn.txt","GBK");//指定编码
        PrintStream pf = new PrintStream(//自动刷新
                new BufferedOutputStream(
                    new FileOutputStream(
                        new File("F:\依风\Desktop\printFlush.txt"))),true);
        pf.println("autoFlush");
        pf.close();
        pc.print("GBK");
        pc.flush();
        pc.close();
        ps.print("print
"+1.3);
        ps.flush();
        ps.close();
    }
}

运行结果：

4.5 Sytem.out和 System.in

我们平常调用System.out.println（）函数打印，打印的内容是显示在控制台上的，System.out也是一个打印流。

而这个打印流关联的就是控制台，可以把控制台也看做一个文件，平常打印出来的数据就是往控制台这个文件打印。

那么我们能否将这个文件换成别的文件呢，即调用System.out.println()不是向控制台输出信息，而是向我们指定的文件输入信息。

答案是可以的，System里面提供了一个方法System.SetOut(PrintStream out)方法，可以设置System.out。

可以看到参数是一个打印流。

设置指定的参数后，Sytem.out.println()就会将内容打印到指定的打印流中。

public class Print {
    public static void main(String[] args) throws FileNotFoundException, UnsupportedEncodingException{
        System.setOut(new PrintStream(new FileOutputStream(new File("F:\依风\Desktop\print.txt"))));
        System.out.println("setOut");
    }
}

还有System.in，这个比较常用的用法就是作为Scanner的参数，表示从键盘输入。

System.in其实就是一个输入流（InputStream），而System.in默认是键盘，这里可以把键盘也看做一个文件，就是从键盘这个文件读取内容。

那么同样的，我们也可以将System.in修改为其他文件。

就需要用到System.setIn(InputStream in).这时就是读取设置之后的输入流

import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.PrintStream;
import java.io.UnsupportedEncodingException;
import java.util.Scanner;

public class Print {
    public static void main(String[] args) throws FileNotFoundException, UnsupportedEncodingException{
        //重定向了System.in将原来的将键盘输入更改为其他输入
        System.setIn(new BufferedInputStream(new FileInputStream(new File("F:\依风\Desktop\print.txt"))));
        Scanner si = new Scanner(System.in);
        System.out.println(si.nextLine());//读取一行
        
    }
}

运行结果：
setOut//根据文件内容决定

那么我么修改了Sytem.in(键盘输入)和System.out(控制台输出)为其他的文件后是否可以还原它们，当然是可以的，之前说了键盘、控制台都是文件

（在windows中一切都可以看做是文件），现在的关键就是要找到代表控制台可键盘的文件，然后再次Set就可以了。

我们来看下源码：

其中FileDescriptor.in就代表键盘，....out就代表控制台，

public class Print {
    public static void main(String[] args) throws FileNotFoundException, UnsupportedEncodingException{
        //输出重定向为指定文件
        System.setOut(new PrintStream(new FileOutputStream(new File("F:\依风\Desktop\print.txt"))));
        System.out.println("setSystem.outAndSystem.in");
        System.out.close();
        //输出重定向为控制台
        System.setOut(new PrintStream(new FileOutputStream(FileDescriptor.out)));
        //输入重定向为指定文件
        System.setIn(new BufferedInputStream(new FileInputStream(new File("F:\依风\Desktop\print.txt"))));
        Scanner si = new Scanner(System.in);
        System.out.println(si.nextLine());//内容输出控制台
    }
}

运行结果：
setSystem.outAndSystem.in

还有一个System.err也是一个打印流，这个主要用于打印出错误信息。比如：

这些红色的错误信息就是err打印出来的。

import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileDescriptor;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.PrintStream;
import java.io.UnsupportedEncodingException;
import java.util.Scanner;

public class Print {
    public static void main(String[] args) throws FileNotFoundException, UnsupportedEncodingException{
        System.err.println("错误信息");
    }
}

运行结果：