Java中的IO流③——转换流、序列化流、反序列化流、打印流

    public static void main(String[] args) throws IOException {
        /*
        利用转换流按照指定字符编码读取(了解)

        因为JDK11：这种方法已经被淘汰了。替代方案(掌握)：
         */

        /*第一种//创建对象
        InputStreamReader isr = new InputStreamReader(new FileInputStream("E:\\Java学习\\day29-IO（其他流）\\资料\\gbkfile.txt"),"GBK");
        //读取数据
        int ch;
        while ((ch = isr.read()) != -1){
            System.out.print((char)ch);
        }
        //释放资源
        isr.close();*/

        //创建对象
        FileReader fr = new FileReader("E:\\Java学习\\day29-IO（其他流）\\资料\\gbkfile.txt", Charset.forName("GBK"));
        //读取数据
        int ch;
        while ((ch = fr.read()) != -1){
            System.out.print((char)ch);
        }
        //释放资源
        fr.close();
    }

利用转换流写出-->

    public static void main(String[] args) throws IOException {
        /*
        利用转换流按照指定字符编码写出(了解)

        因为JDK11：这种方法已经被淘汰了。替代方案(掌握)：
         */

        /*//创建对象
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("myio\\b.txt"),"GBK");
        //写出数据
        osw.write("你好你好");
        //释放资源
        osw.close();*/

        //创建对象
        FileWriter fr = new FileWriter("myio\\b.txt", Charset.forName("GBK"));
        //写出数据
        fr.write("你好你好");
        //释放资源
        fr.close();
    }

将本地文件中的GBK文件，转成UTF-8

    public static void main(String[] args) throws IOException {
        /*
        将本地文件中的GBK文件，转成UTF-8
         */

        //JDK11以前的方案
        /*InputStreamReader isr = new InputStreamReader(new FileInputStream("E:\\Java学习\\day29-IO（其他流）\\资料\\gbkfile.txt"),"GBK");
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("myio\\c.txt"),"UTF-8");

        //读取和写出
        int b;
        while ((b = isr.read()) != -1){
            osw.write(b);
        }

        osw.close();
        isr.close();*/

        //JDK11开始的方案
        FileReader fr = new FileReader("E:\\Java学习\\day29-IO（其他流）\\资料\\gbkfile.txt", Charset.forName("GBK"));
        FileWriter fw = new FileWriter("myio\\d.txt",Charset.forName("UTF-8"));

        //读取和写出
        int b;
        while ((b = fr.read()) != -1){
            fw.write(b);
        }

        fw.close();
        fr.close();

    }

利用字节流读取文件中的数据，每次读一整行，而且不能出现乱码

    public static void main(String[] args) throws IOException {
        /*
        利用字节流读取文件中的数据，每次读一整行，而且不能出现乱码
         */

        BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("E:\\Java学习\\day29-IO（其他流）\\资料\\csb.txt")));
        String line;
        while ((line = br.readLine()) != null){
            System.out.println(line);
        }
        br.close();
    }

总结

序列化流&反序列化流

序列化流

构造和成员方法

细节

代码演示

利用序列化流/对象操作输出流，把一个对象写到本地文件中-->

package com.qiong.myobjectstream;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;

public class ObjectStreamDemo1 {
    public static void main(String[] args) throws IOException {
        /*
            需求：
                利用序列化流/对象操作输出流，把一个对象写到本地文件中
            构造方法：
                public ObjectOutputStream(OutputStream out)     把基本流变成高级流
            成员方法：
                public final void writeObject(Object obj)       把对象序列化(写出)到文件中去
         */

        //创建对象
        Student stu = new Student("张三", 23);

        //创建序列化流的对象/对象操作输出流
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("myio\\a.txt"));

        //写出数据
        oos.writeObject(stu);

        //释放资源
        oos.close();
    }
}

package com.qiong.myobjectstream;

import java.io.Serializable;

public class Student implements Serializable {
    /*
        Serializable接口里面是没有抽象方法的，标记型接口
        一旦实现了这个接口，就表示当前的类可以被序列化
     */
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

    public String toString() {
        return "Student{name = " + name + ", age = " + age + "}";
    }
}

结果：

�� sr  com.qiong.myobjectstream.Student�=?�.� I ageL namet Ljava/lang/String;xp   t 张三

反序列化流

代码演示

package com.qiong.myobjectstream;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.ObjectInputStream;

public class ObjectStreamDemo2 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        /*
            需求：
                利用反序列化流/对象操作输入流，把文件中的对象读取到程序当中
         */

        //创建对象
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("myio\\a.txt"));

        //读取数据
        Object o = ois.readObject();

        //打印对象
        System.out.println(o);

        //释放资源
        ois.close();
    }
}

结果-->

Student{name = 张三, age = 23}

序列化流和反序列化流细节

综合练习

package com.qiong.myobjectstream;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.util.ArrayList;

public class ObjectStreamDemo3 {
    public static void main(String[] args) throws IOException {
        /*
            需求：
                将多个自定义对象序列化到本地文件中，但是对象的个数不确定，该如何操作呢？
         */

        //序列化多个对象
        Student s1 = new Student("张三", 23, "南京");
        Student s2 = new Student("李四", 24, "重庆");
        Student s3 = new Student("王五", 25, "北京");

        ArrayList<Student> list = new ArrayList<>();
        list.add(s1);
        list.add(s2);
        list.add(s3);

        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("myio\\a.txt"));
        oos.writeObject(list);

        oos.close();
    }
}

package com.qiong.myobjectstream;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.util.ArrayList;

public class ObjectStreamDemo1 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //创建反序列化流对象
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("myio\\a.txt"));
        //读取数据
        ArrayList<Student> list = (ArrayList<Student>) ois.readObject();
        //打印数据
        for (Student student : list) {
            System.out.println(student);
        }
        /*
        结果：
            Student{name = 张三, age = 23, address = 南京}
            Student{name = 李四, age = 24, address = 重庆}
            Student{name = 王五, age = 25, address = 北京}
         */
        //释放资源
        ois.close();

    }
}

打印流

字节打印流

构造方法-->

成员方法-->

代码演示

package com.qiong.myprintStream;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.PrintStream;
import java.nio.charset.Charset;

public class PrintStreamDemo1 {
    public static void main(String[] args) throws FileNotFoundException {
        //创建对象
        PrintStream ps = new PrintStream(new FileOutputStream("myio\\a.txt"), true, Charset.forName("UTF-8"));

        //写出数据
        ps.println(97);
        ps.print(true);
        ps.printf("%s爱上了%s", "阿珍", "阿强");
        /*
            结果：
                97
                true阿珍爱上了阿强
         */

        //释放资源
        ps.close();
    }
}

字符打印流

构造方法

成员方法

代码演示

package com.qiong.myprintStream;

import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;

public class PrintStreamDemo2 {
    public static void main(String[] args) throws IOException {
        //创建对象
        PrintWriter pw = new PrintWriter(new FileWriter("myio\\a.txt"), true);

        //写出数据
        pw.println("今天你终于叫我名字了，虽然叫错了，但是没关系，我马上改");
        pw.print("你好你好");
        pw.printf("%s爱上了%s","阿珍","阿强");

        /*
        结果：
            今天你终于叫我名字了，虽然叫错了，但是没关系，我马上改
            你好你好阿珍爱上了阿强
         */

        //释放资源
        pw.close();
    }
}

总结

文章来源:https://blog.csdn.net/qingwan_91/article/details/134915566
本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若内容造成侵权/违法违规/事实不符，请联系我的编程经验分享网邮箱：veading@qq.com进行投诉反馈，一经查实，立即删除！