Java IO流(2)

字节数组流(节点流)：
ByteArrayInputStream


ByteArrayOutputStream
新增方法:toByteArray()


public class TestByteArray {
    public void read() throws IOException{
        InputStream is=new BufferedInputStream(new ByteArrayInputStream("hello world".getBytes()));
        byte[] bytes=new byte[1024];
        while(-1!=(is.read(bytes))){
            /*
            * 输入操作与文件流操作相同
            * 
            * */
        }
    }
    public void write() throws IOException{
        ByteArrayOutputStream output=new ByteArrayOutputStream();
        output.write("hello world".getBytes());
        byte[] bytes=output.toByteArray();
        /*
        *输出操作与文件流不同
        */
    }
}


处理基本数据类型流

注：读取的顺序要与写入的顺序一致

DataInputStream
新增方法：
read(),readUTF(),readChar(),readBoolean()等
DataOutputStream
新增方法：
write(),writeUTF(),writeChar(),writeBoolean()等


例：


package TestIO;
import java.io.*;


public class TestData {
    public void write() throws IOException{
        DataOutputStream dataOutputStream=new DataOutputStream
                (new FileOutputStream(new File("c:/users/lenovo/desktop/hello.txt")));
        dataOutputStream.writeBoolean(true);
        dataOutputStream.writeChar('h');
        dataOutputStream.write(1);
        dataOutputStream.writeUTF("hello");
        dataOutputStream.close();
    }
    public void read() throws IOException{
        DataInputStream dataInputStream=new DataInputStream(new FileInputStream(new File("c:/users/lenovo/desktop/hello.txt")));
        System.out.println(dataInputStream.readBoolean());
        System.out.println(dataInputStream.readChar());
        System.out.println(dataInputStream.read());
        System.out.println(dataInputStream.readUTF());
        dataInputStream.close();
    }
}


引用类型(对象)流 保留数据+类型


序列化：输出流 ObjectOutputStream 新增方法：writeObject()
反序列化：输入流 ObjectInputStream 新增方法：readObject()
使用顺序：先序列化，在反序列化，反序列化应该与序列化的顺序一致
若要序列化一个对象，则该对象的类需要实现java.io.Serializable接口，若该类的某些属性或方法不需要序列化，则可以在该属性和方法前加上transient


例如：
package TestIO;




import java.io.*;
import java.util.Date;


class SeriaObject implements Serializable {
    String name;
    transient int age;
    boolean sex;
    public SeriaObject(String name, int age, boolean sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }
}
public class TestObjectStream {
    public void write(SeriaObject[] objs) throws IOException {
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(new BufferedOutputStream(new FileOutputStream(new File("hello.txt"))));
        for (SeriaObject temp : objs) {
            objectOutputStream.writeObject(temp);
        }
        objectOutputStream.writeObject(new Date());
        objectOutputStream.writeObject(new Object());
    }
    public void read() throws IOException,ClassNotFoundException{
        ObjectInputStream objectInputStream=new ObjectInputStream(new BufferedInputStream(new FileInputStream(new File("c:/users/lenovo/desktop/hello.txt"))));
        for(int i=0;i<3;i++){
            SeriaObject object=(SeriaObject) objectInputStream.readObject();
        }
        Date date=(Date)objectInputStream.readObject();
        Object object=objectInputStream.readObject();
    }

}

打印流：
File file=new File("c:/users/lenovo/desktop/hello.txt");
        PrintStream printStream=new PrintStream(new BufferedOutputStream(new FileOutputStream(file)));
        printStream.print("hello");
        printStream.close();
System.err :PrintStream类型，标准错误输出流
System.in：InputStream类型，标准输入流
System.out:PrintStream类型，标准输出流
重定向输出流：System.setOut(PrintStream,true);
控制台输入流：FileDescriptor.in
控制台输出流：FileDescriptor.out


装饰设计模式
类与类之间的关系：
依赖：形参以及局部变量
关联：属性
    聚合：属性 整体与部分 不一致的生命周期
    组合：属性 整体与部分 一致的生命周期
继承：父类与子类之间的关系
实现：接口与实现类的关系