关于IO的今天学到的一点东西

学了点关于IO的东西。些许皮毛。

照目前的情况来看，就是字符流+字节流

想要速度快点就带上缓冲。

FileInputStream，FileOutputStream ，字节流

BufferedInputStream ，BufferedOutputStream，缓冲字节流

InputStreamReader，OutputStreamWriter，字符流

PrintWriter，BufferedReader，缓冲字符流

大概就这8个

一开始不知道，out到底是写还是读。后来悟到一点。就这么记“ 读进来。写出去。”

意思就是，in的时候是read，out的时候是write，这么容易记着。

下面写了个玩具代码。把一些具体如何实现写写，也好方便自己查找，注释最好是一行一行放

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.Reader;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;

public class Test {
    
    public static void main(String[] args) throws IOException, ClassNotFoundException {
//        FileOutputStream fos=new FileOutputStream("test.txt");
//        String str="我最近在学习java中的IO流";
//        byte[] byt=str.getBytes();//设置一个数组来接受数据
//        fos.write(byt);//写入数据一个一个字节写入。关闭流后会导出。
//        fos.close();
        System.out.println("------------------壹，字节输出流------------------------");
//        FileInputStream fis=new FileInputStream("test.txt");
//        byte[] byt=new byte[1024];//用来保存数据
//        int r=fis.read(byt1);//用来记录读取的长度
//        String str=new String(byt,0,r);
//        System.out.println(str);//在控制台输出
//        fis.close();
        System.out.println("------------------贰，字节输入流------------------------");
//        FileOutputStream fos=new FileOutputStream("test.txt",true);//加上true，对原文件追加内容，否则会覆盖原文件
//        String str="还是有点难搞懂";
//        byte[] byt=str.getBytes();
//        fos.write(byt);
//        fos.close();
        System.out.println("------------------参，对字节流原文件添加内容------------------------");
//        FileInputStream fis=new FileInputStream("test.txt");
//        FileOutputStream fos=new FileOutputStream("test1.txt");
//        byte[] byt=new byte[1024];
//        int d=-1;
//        while((d=fis.read(byt))!=-1){
//            fos.write(byt,0,d);//需要复制的内容，从0，开始，到数据结尾的长度。
//        }
//        fis.close();
//        fos.close();
        System.out.println("------------------肆，字节流复制文件------------------------");
//        FileOutputStream fos=new FileOutputStream("play.txt");
//        /**
//         * 在这里比较不出速度。因为这里输入的字符太少。
//         * 缓冲字节流会将字节一个一个的放到缓冲区，等到缓冲区放满。然后一次性写出
//         */
//        BufferedOutputStream bos=new BufferedOutputStream(fos);//把fis包装在bos里面
//        String str="好好学习";
//        byte[] byt=str.getBytes();
//        bos.write(byt);
//        bos.flush();
//        bos.close();
        System.out.println("------------------伍，缓冲字节输出流------------------------");
//        FileInputStream fis=new FileInputStream("play.txt");
//        /**
//         *这里写的play.txt内容太短。无法做出比较。
//         *
//         * 可以将之前写的代码复制到文件中，进行测试，就能比较出区别了
//         *
//         * 总之缓冲字符流会提高效率
//         */
//        BufferedInputStream bis=new BufferedInputStream(fis);
//        byte[] byt=new byte[1024*10] ;
//        int d=bis.read(byt);
//        String str=new String(byt,0,d);
//        System.out.println(str);
        System.out.println("------------------陆，缓冲字节输入流------------------------");        
//        FileOutputStream fos=new FileOutputStream("TT.txt");
//        ObjectOutputStream oos=new ObjectOutputStream(fos);
//        List<Tt> list= new ArrayList<Tt>();//创建一个集合，放元素
//        list.add(new Tt(16,"林"));
//        list.add(new Tt(17,"清"));
//        oos.writeObject(list);
//        oos.close();
        System.out.println("------------------柒，序列化（把对象变成字节）------------------------");    
//        FileInputStream fis=new FileInputStream("TT.txt");
//        ObjectInputStream ois=new ObjectInputStream(fis);
//        System.out.println((List<Tt>)ois.readObject());
//        ois.close();
        System.out.println("------------------捌，反序列化------------------------");
//        OutputStreamWriter osw=new OutputStreamWriter(new FileOutputStream("demo.txt"));
//        osw.write("感谢");
//        osw.write("好的");
//        osw.close();
        System.out.println("------------------玖，字符输出流------------------------");
//        InputStreamReader isr =new InputStreamReader(new FileInputStream("demo.txt"));
//        int c=-1;
//        while((c=isr.read())!=-1){
//            System.out.println((char)c);
//        }
//        isr.close();
        System.out.println("------------------拾，字符输出流------------------------");        
//        PrintWriter pw=new PrintWriter("game.txt");
//        pw.println("你好");
//        pw.println("再见");
//        pw.close();
        System.out.println("------------------拾壹，缓冲字符输出流------------------------");
//        BufferedReader br=new BufferedReader(new InputStreamReader(new FileInputStream("game.txt")));
//        /**
//         * 因为bufferedReader（）里面必须是字符串，所以得这样写
//         */
//        String s=null;
//        while((s=br.readLine())!=null){
//            System.out.println(s);
//        }        
//        br.close();
        System.out.println("------------------拾贰，缓冲字符输入流------------------------");
    }
    
    
    
}
class Tt implements Serializable{//要实现序列化，就必须实现Serializable接口。类似于一个身份的象征。
    /**
     *
     */
    private static final long serialVersionUID = 1L;//必须手动加了版本号。防止序列化，和序列化的时候出现错误
    private  transient int age;//修饰符transient，只有在此接口中有用。用来瘦身，不参与序列化
    private String name;
    Tt(){}
    public Tt(int age, String name) {
        super();
        this.age = age;
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String toString(){//此方法一般意义上需要重写
        return age+name;
    }
}

在附上课上自己整理的笔记。以便不时之需

IO流（节点流（实际处理数据）<低级流>，处理流（对数据进行加工）<高级流>）就是数据的写入输出，“读进来，写出去”。
FileInputStream fis=new FileInputStream(文件名)（输入字节流的实现）
    创建一个byte[],规定长度。获取一次读取的长度。转成字符串输出。
FileOutputStream fos=new FileOutputStream(文件名)（输出字节流的实现）{如果创建一个流，对原文件进行追加输入操做，需要追加就得+true}    创建个字符串。把它放进byte[],然后写出去。
复制文件与RandomAccessFile一样。
    创建个byte[]=new byte[100];初始化。while判断。读取为-1时结束，
缓冲字节流（处理流）用来提高运行速度
BufferedInputStream bis=new BufferedInputStream(fis);在fis外面套个缓冲
实际读取时，缓冲流会让处理的流一次性带一组数据回来存入自身提供的数组中，要一个给一个
BufferedOutputStream bos=new BufferedOutputStream(fos);在fos外面套个缓冲
实际写出数据时。数据会暂时存放在缓冲区。没存满不会写出了。若需写出。就需要刷新（bos.flush()）

若创建了一个类（除了基本的变量，构造外，还需重写toString方法）。要用序列化来实现数据的读入和反序列化写出。那么这个类必须实现Serializable（transient这个修饰词只在此接口中有用。用来忽略用该修饰词修饰的变量。那么这个变量就会被忽略）这个接口（类似身份的标记）而且这个类中的成员变量必须手动写好版本号（版本不一致会报错），防止以后成员变量的数据变动，而造成数据无法用缓冲流来读写。
ObjectInputStream ois=new ObjectInputStream(fis);用来实现序列化
（数据类型）ois.readObject();用此方法来读入。（强转）
ObjectOutputStream oos=new ObjectOutputStream（fos）：用来实现序列化
把数据结构转化成字节的过程称为：序列化
将java中的对象转换为字节的过程：对象序列化。相反操作就是反序列化
把内存中的数据写入磁盘中做长久保存的过程称之为持久化
缓冲字符输入流（按行读取字符串）BufferedReader br=new BufferedReader（fis）{（）里的必须是字符类型。所以必须在用ISR流来包裹}以行为单位读取，到换行符之前结束，并将所读取到的内容组成一个字符串带回，若返回值为null，则说明以读取到末尾。
缓冲字符输出流（BufferedWriter，但是BufferedWriter常被PrintWriter包裹，所以常用PrintWriter），PrintWriter pw=new PrintWriter（文件名），pw.println(String s);也可以包装字节输出了（fos，true[写了，表明带了自动行刷功能，调用的是println（）。]），若想改字符集，则必须在BufferedWriter内写。
转化字符集，先用ISR读取原文件（因为是字符流，所以装进字符数组中），再用OSW+字符集类型写出。
字符输出流 OutputStreamWriter osw=new OutputStreamWriter（fos），直接osw.write(String s，字符集（可给可不给）)
字符读取流，InputStreamReader isr=new InputStreamReader（fis），初始化，while判断-1，输出char（值）