Java学习 DAY19 字符流，字节流，缓冲流，系统流、转换流

硬盘

字符流

给硬盘上.txt文件写入数据 文件 字符输出流—FileWriter
从硬盘上.txt文件读取数据 文件 字符输出流—FileReader

package cn.tedu.io.file;


import java.io.FileReader;
import java.io.IOException;

public class FileReaderDemo1 {
    public static void main(String[] args) throws IOException {
        //创建文件字符输入流对象
        //底层没有自带的缓冲区
        FileReader reader=new FileReader("D:\\a.txt");

        //返回单个字符的编码值
        /*System.out.println(reader.read());
        System.out.println(reader.read());
        System.out.println(reader.read());
        //读取完毕的标值---返回-1
        System.out.println(reader.read());*/

        //通过循环实现
        int i=-1;
        //把方法返回值（读取到的字符编码之）赋值给新变量，再让新变量和-1进行比较
        while ((i=reader.read())!=-1){
            //输出新变量的值（方法读到的字符编码值）
            System.out.println(i);
        }

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

字节流（常见）

给硬盘上.txt文件写入数据 文件 字节输出流—FileOutputStream

package cn.tedu.io.file;

import java.io.FileOutputStream;
import java.io.IOException;

public class FileOutputStreamDemo {
    public static void main(String[] args) throws IOException {
        //创建文件字节输出流对象
        //底层没有自带的缓冲区
        //如果不指定append那么默认false就是每次新建空文件覆盖之前的内容
        //如果指定append为true那么每次就是追加数据
        FileOutputStream fos=new FileOutputStream
                ("D:\\3.txt",true);

        //调用方法写出数据
        fos.write("你好".getBytes());


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

从硬盘上.txt文件读取数据 文件字节输入流FileInputStream

package cn.tedu.io.file;

import java.io.FileInputStream;

import java.io.IOException;

public class FileInputStreamDemo {
    public static void main(String[] args) throws IOException {
        //创建文件字节输入流
        FileInputStream fis=new FileInputStream("D:\\1.txt");


        //返回一个字节对应的编码值
       /* System.out.println(fis.read());
        System.out.println(fis.read());
        System.out.println(fis.read());
        System.out.println(fis.read());
        System.out.println(fis.read());
        System.out.println(fis.read());*/

        //自建缓冲区
        byte[] bs=new byte[10];
        int len=-1;
        //返回读取到的字节数，遇到-1读取完毕[0
        while ((len=fis.read(bs))!=-1){
            System.out.println(new String(bs,0,len));
        }
        //关流
        fis.close();
    }
}

缓冲流（给别的流提供缓冲区）

BufferedReader-----给字符输入流提供缓冲区
readLine（）—读取一行

package cn.tedu.io.buffer;

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class BufferedReaderDemo {
    public static void main(String[] args) throws IOException {
        //创建缓冲流对象
        //BufferedReader和FileReader都是Reader的子类---同类
        //同类对象给本类对象增强（完善）功能---装饰者设计模式
        BufferedReader br=new BufferedReader(
                new FileReader("D:\\b.txt"));
        //读取数据
        //读取一行数据
        /*System.out.println(br.readLine());
        System.out.println(br.readLine());
        System.out.println(br.readLine());
        //当读取完毕时返回null
        System.out.println(br.readLine());*/


        //用循环实现
        String str="";
        while ((str=br.readLine())!=null){
            System.out.println(str);
        }


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

BufferedWrite—提供一个更大的缓冲区
newLine()—换行

package cn.tedu.io.buffer;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

public class BufferedWriterDemo {
    public static void main(String[] args) throws IOException {
        //创建缓冲流对象
        BufferedWriter bw=new BufferedWriter
                (new FileWriter("D:\\b.txt"));

        //写出数据
        bw.write("avs");
        //换行
        //Windows---/r/n
        //Linux---/n
        bw.newLine();

        bw.write("3216");


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

模式：遇到统一问题时给出统一的解决方式
设计模式：在软件开发中，遇到统一问题给出统一的解决方案
装饰者设计模式：同类对象给本类对象增强（完善）功能

转换流

OutputStreamWriter—把字符流转成字节流

package cn.tedu.io.transform;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;

public class OutputStreamWriterDemo {
    public static void main(String[] args) throws IOException {
        //创建转换流对象
        //转换流的对象由文件字节输出流对象构建
        //底层真正来进行传输是文件字节输出流对象
        //接收准备数据时用的是字符流，底层真正往外写出数据用的是字节流
        //转换流---字符流转成字节流
        OutputStreamWriter osw=new OutputStreamWriter
                (new FileOutputStream("D:\\123.txt"));


        //写出数据
        //往外写出数据需要先准备数据
        //事先需要准备数据都是字符形式的数据---需要提供字符流来操作数据
        osw.write("你好");


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

InputStreamReader—把字节流转成字符流

package cn.tedu.io.transform;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;

public class InputStreamReaderDemo {
    public static void main(String[] args) throws IOException {
        //创建转换对象
        //转换流对象由文件字节输入流对象来构建
        //底层真正来读取数据的是文件字节输入流
        //先根据文件字节输入流来读取数据
        //再根据字符流来提供展示数据
        //转换流---字节流转成字符流
        InputStreamReader isr=new InputStreamReader
                (new FileInputStream("D:\\b.txt"));


        //读取数据
        char[]cs=new char[10];//自建缓冲区
        int len=-1;
        //展示数据---字符形式数据
        //展示的数据由提供字符流来获取
        while ((len=isr.read(cs))!=-1){
             //
             System.out.println(new String(cs,0,len));
         }
        //关流
        isr.close();
    }
}

系统流

out、err、in（都是字节流）
系统流都是静态的流对象，使用完毕之后不能关流

package cn.tedu.io.system;

import java.util.Scanner;

public class SystemDemo {
    public static void main(String[] args) {
       /* //输出正确结果  黑色
        //out-----字节输出流对象
        System.out.println(1);
        //输出错我结果  红色
        //err-----字节输出流对象
        System.err.println(1);
        //in------字节输入流对象
        new Scanner(System.in);*/





        //
        Scanner sc1=new Scanner(System.in);
        int num1=sc1.nextInt();
        System.out.println(num1);
        //关流
        //in是静态流对象  如果关闭了其他地方都不能使用
        sc1.close();
        Scanner sc2=new Scanner(System.in);
        int num2=sc2.nextInt();
        System.out.println(num2);
    }
}

打印流

print方法以及println方法都是定义在打印流里

package cn.tedu.io.print;

import java.io.IOException;
import java.io.PrintStream;

public class PrintDemo {
    public static void main(String[] args) throws IOException {
        //创建打印流对象
        PrintStream ps=new PrintStream("D:\\5.txt");


        //写出数据
        ps.print(22);
        ps.println("abc");
        ps.write("466".getBytes());

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

序列化与反序列化

序列化：把对象以及相关信息转成字节数组 存储到硬盘（持久化）

package cn.tedu.io.serial;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
public class ObjectOutputStreamDemo {
    public static void main(String[] args) throws IOException {
        //创建对象
        //如果路径信息没有盘符---当前工程
        ObjectOutputStream oos=new ObjectOutputStream
                (new FileOutputStream("p.data"));
        //提供对象
        Person p=new Person();
        p.setName("豆豆");
        p.setAge(10);
        //把对象转成字节数组进行序列化
        oos.writeObject(p);
        //关流
        oos.close();
    }
}

反序列化：把字节数组转成相应的对象

package cn.tedu.io.serial;

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

public class ObjectInputStreamDemo {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //创建对象
        ObjectInputStream ois=new ObjectInputStream
                (new FileInputStream("p.data"));


        //读取字节数组转成对应对象---反序列化
        Person p=(Person)ois.readObject();

        //关流
        ois.close();

        //展示信息
        System.out.println(p.getName()+","+p.getAge());
    }
}

注意：
1.类实现Serializable产生对象才能做序列化
2.如果属性被static/transient修饰不能被序列化过去
3.serialVersionUID（序列化版本号）
在序列化之前会根据类里的属性和方法来计算出一个版本号，随着对象一起序列化过去。在反序列化之前会再次根据类里属性和方法来计算出一个版本号，根据前后两个版本号进行对比，如果对比结果一致可以进行正常的反序列化，如果对比结果不一致则进行反序列化失败。（指定版本号private static final long seriaVersionUID=1534321534L;）
4.集合对象和映射对象都不能直接进行序列化，只能依次遍历元素一一进行序列化。

package cn.tedu.io.serial;

import java.io.Serializable;


//类实现Serializable接口产生对象才能做序列化
public class Person implements Serializable {


    private static final long serialVersionUID = 1494936044942872395L;
    //提供版本号---java就不再计算版本号
    //private static final long seriaVersionUID=1534321534L;


    //属性
    private String name;
    private int age;
    //属性会被序列化
    //private char gender;
    //强制属性不被序列化过去
    //transient double weight;
    //静态属性不会被序列化
    //private static String classroom;

    //
    //private static

    //方法不会被序列化
    //public void m(){}

    //提供get/set方法
    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}