IO的对象流,转换流,打印流

对象流
按照对象或基本类型模式往文件写入读取内容,是一种处理流(使用的时候需要创建节点流(文件流))

ObjectInputStream	ObjectOutStream
对象输入流	对象输出流

定义对象的时候,一定要实现Serializable接口

	序列化:用ObejcetOutputStream类保存对象的机制
		将一个自定义对象写入到文件中,该类要实现Serializable接口
	反序列化:用ObjectInputStream类读取对象的机制

	
	案例: 往test文件写入几个对象

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

//序列化案例
public class ObjectDemo01 {
    //java程序-->文件 ObjectOutputStream
    public static void main(String[] args) throws IOException {
        //1.创建文件对象
//        File file=new File("D:\\test.txt");
        //2.创建流
        //2.1创建节点流(对象流是字节流,所以需要创建文件字节输出流)
//        FileOutputStream fos=new FileOutputStream(file);
//        //2.2通过节点流创建对象流
//        ObjectOutputStream oos=new ObjectOutputStream(fos);
        //上述两步操作结合
        ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream(new File("D:\\test.txt")));
        //3.写
        oos.writeInt(10);
        oos.writeBoolean(false);
        oos.writeDouble(7.16);
        oos.writeObject(new Date());
        oos.writeObject(new User("小泽",19));

        //4.关流
        oos.close();

    }
}
//创建类,并将Serializable接口的实现
class User implements Serializable{
    String name;
    int id;

    public User(String name, int id) {
        this.name = name;
        this.id = id;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        User user = (User) o;
        return id == user.id &&
                Objects.equals(name, user.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, id);
    }

    public String getName() {
        return name;
    }

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

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", id=" + id +
                '}';
    }
}

运行结果:

所写入的内容:是写给计算机的,以二进制的形式存储到计算机中,打开显示乱码,我们需要通过ObjectInputStream进行读取
反序列化案例:

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.util.Date;
//反序列化案例
public class ObjectDemo02 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //1.创建文件对象
        //2.创建对象流
        ObjectInputStream ois=new ObjectInputStream(new FileInputStream(new File("D:\\test.txt")));
        //3.读
        int a=ois.readInt();
        System.out.println(a);
        boolean b=ois.readBoolean();
        System.out.println(b);
        double c=ois.readDouble();
        System.out.println(c);
        Date data= (Date) (ois.readObject());
        System.out.println(data);
        //读取
        User u=(User) ois.readObject();
        System.out.println(u);
        //读取时,按照写入顺序读取

        //关流
        ois.close();
    }
}

通过上述,我们不难看出,如果采用一个对象一个对象的写读,非常麻烦,

		能不能采用一次性的写读入操作?
		有没有什么办法可以将这些一个个对象存起来,然后一次性写读
		
		我们通过使用集合可以解决这种情况,使用集合来实现一次的写,使用集合遍历来实现读
		
		来看下面的案例,

package SE.day0311;

import java.io.*;
import java.util.ArrayList;

public class ObjectDemo03 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        
        //1.创建集合,将要写入到文件中的对象添加到集合中
        ArrayList list=new ArrayList();
        list.add(1);
        list.add(false);
        list.add(new User("十堰",20));
        list.add("你好啊");


		//1.创建文件
        //2.创建流
        ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream(new File("D:\\test.txt")));
        //3.将集合写入到文件中
        oos.writeObject(list);
        //4.关流
        oos.close();

		//读取文件中的内容,看有没有添加成功
        //读
        ObjectInputStream ois=new ObjectInputStream(new FileInputStream(new File("D:\\test.txt")));
        ArrayList arrayList=(ArrayList) ois.readObject();
        //遍历集合
        for (Object o:arrayList) {
            System.out.println(o);
        }
        ois.close();

    }
}

运行结果如下:

在此多说一句:使用ObejcetOutputStream类保存自定义对象的时候,一定要实现Serializable接口

转换流
它是一种处理流，提供了字节流和字符流之间的转换

InputStreamReader	OutputStreamWriter
字节输入流–>字符输入流	字符输出流–>字节输出流

案例:

package SE.day0311;

import java.io.*;

/*
    转换流:
        转换流提供了字节流与字符流之间的转换
        java api 中提供了两个转换流
        InputStreamReader:将InputStream转为Reader
            实现将字节输入流按照指定字符集编码转为字符输入流
        OutputStreamWriter:将writer转为OutputStream
            实现将字符输出流按照指定字符编码转为字节输出流
        java:
 */
public class ISR_OSW_Demo01 {
    public static void main(String[] args) throws IOException {
        //1.创建文件路径
        File file=new File("D:\\test.txt");
        File file1=new File("D:\\test_copy.txt");

//        InputStreamReader isr=new InputStreamReader(
//                                    new FileInputStream(
//                                        new File("D:\\test.txt")),"gbk");
        //2.创建流
            //2.1创建节点流
        FileInputStream fis=new FileInputStream(file);
        FileOutputStream fos=new FileOutputStream(file1);
          //2.2创建缓冲流
        InputStreamReader isr=new InputStreamReader(fis,"gbk");
        OutputStreamWriter osw=new OutputStreamWriter(fos,"utf-8");
        //3.读写
        char[] chs=new char[10];
        int length;
        while((length=isr.read(chs))!=-1){
            osw.write(chs,0,length);
        }
        //4.关流
        isr.close();
        osw.close();
    }
}

打印流:

    将基本类型数据或者其他类型,转换为字符串输出
    PrintStream 字节打印流 :打印的所有字符都是使用平台默认字符编码转为字节
    PrintWriter 字符打印流 :可以按行写出字符串,并且可以自动刷新

package SE.day0311;

import java.io.*;
import java.util.Scanner;

public class PWDemo01 {
    public static void main(String[] args) throws FileNotFoundException, UnsupportedEncodingException {
        //1.创建文件路径
        File file=new File("D:\\test.txt");
        //2.创建流
//        PrintWriter pw=new PrintWriter(file);
            //2.1节点流(操作字节)  追加
        FileOutputStream fos=new FileOutputStream(file,true);
            //2.2创建转换流(操作字符)
        OutputStreamWriter osw=new OutputStreamWriter(fos,"utf-8");
            //2.3缓冲流(提高效率)
        BufferedWriter bw=new BufferedWriter(osw);
            //2.4打印流(可以自动刷新功能)
        //autoFlush表示是否自动刷新
        PrintWriter pw=new PrintWriter(bw,true);
        //3.输出
//        pw.println("good good study,day day");
        System.out.println("请输入你要存的内容");
        Scanner scan=new Scanner(System.in);
        while (true){
            String line=scan.next();
            if ("exit".equals(line)) {
                break;
            }
            pw.println(line);
        }
        //4.关闭流
        pw.close();
    }
}

看到这里的话 , 提个过分的要求 , 麻烦可以点个小小的赞吗 ? 鼓励鼓励小白的我 !