Java IO流（三）

接上一篇

6：字符流，要明白以下问题：

1）：编码问题

2）：认识文本和文本文件。java的文本(char)是16位无符号整数，是字符的Unicode编码（双字节编码），文件是byte byte byte..的数据序列。文本文件是文本序列按照某种编码方法序列化为byte的存储的结果

3）：字符流(Reader ,Writer)，字符的处理，一次处理一个字符，字符的底层任然是基本的字节序列

4）：基本实现

InputStreamReader

完成byte流解析为char流，按照编码解析

OutputStreamWriter

完成char流解析为byte流，按照编码解析

7:FileReader 和 FileWriter

public class FrAndFwUtil {
    public static void main(String[] args)throws Exception{
        FileReader fr=new FileReader("javaio\\a.txt");
        FileWriter fw=new FileWriter("javaio\\a2.txt",true);//true表示新增的内容append到源文件中

        char[] buff=new char[8*1024];
        int b;
        while((b=fr.read(buff,0,buff.length))!=-1){
            fw.write(buff,0,b);
            fw.flush();
        }
        fr.close();
        fw.close();
    }
}

8:字符流的过滤器

BufferedReader-->readLine一次读一行

BufferedWriter/PrintWriter-->写一行

public class BufferedUtil {
    public static void main(String[] args) throws IOException{
        BufferedReader br=new BufferedReader(new InputStreamReader(new FileInputStream("javaio\\a.txt")));
        //BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(new FileOutputStream("javaio\\buffered.txt")));

        PrintWriter pw=new PrintWriter("javaio\\buffered1.txt");//底层就是封装了BufferedWriter
        String line;
        while((line=br.readLine())!=null){
            System.out.print(line);
            pw.println(line);
            pw.flush();
//            bw.write(line);//一次读一行 但是不能识别换行
//            //换行工作
//            bw.newLine();
//            bw.flush();
        }
        br.close();
        //bw.close();
        pw.close();
    }
}

9:对象的序列化，反序列化

1）：对象序列化就是将Object转换成byte序列，反之就叫做对象的反序列化

2）：序列化流(ObjectOutputStream),是过滤流---writewriteObject

反序列化流(ObjectInputStream)----InputObject

3）：序列化接口

对象必须实现序列化接口，才能进行序列化，否则将出现异常，这个接口，没有任何方法，只是一个标准

public class ObjectSerial {
    public static void main(String[] args)throws IOException ,ClassNotFoundException{
        String file="javaio\\obj.dat";

        //对象的序列化
        ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream(file));

        Student stu=new Student("tgd","1254",20);
        oos.writeObject(stu);
        oos.flush();
        oos.close();


        //对象的反序列化
        ObjectInputStream ois=new ObjectInputStream(new FileInputStream(file));

        Student student=(Student) ois.readObject();
        System.out.println(student);
        ois.close();
    }
}

有时候，我们不希望对象中的所以属性都被序列化，这时候我们就需要在该属性前面加上transient

1）：transient修饰后的属性，jvm是默认不会做序列化操作，但是不代表不可以做序列化操作，可以用ArrayList来解决

这两个方法都是ArrayList中的

    private transient  int age;//该元素不会被jvm默认序列化

    //序列化
    private void writeObject(java.io.ObjectOutputStream s) throws java.io.IOException{
        s.defaultWriteObject();//把jvm能默认序列化的元素进行序列化操作
        s.writeInt(age);//自己完成age的序列化
    }

    //反序列化
    private void readObject(java.io.ObjectInputStream s)throws IOException,ClassNotFoundException{
        s.defaultReadObject();
        this.age=s.readInt();
    }

一个类实现了序列化接口，那么他的子类都能直接进行序列化。

javaio的所有代码

猜你喜欢