java---IO流：特殊操作流

打印流

package IO流.特殊操作流;
/*
        打印流分类：
            字节打印流：PrintStream
            字符打印流：PrintWriter
        打印流特点：
            只负责输出数据，不负责读取数据
            有自己的特有方法
        字节打印流
            PrintStream（String fileName）使用指定的文件名创建新的打印流
            使用继承父类的方法写数据，查看的时候会转码
            使用字节的特有方法写数据，查看的数据原样输出
 */

import java.io.*;

public class 打印流 {
    public static void main(String[] args) throws IOException {
/*        //PrintStream（String fileName）使用指定的文件名创建新的打印流
        PrintStream ps = new PrintStream("idea_text\\ps.txt");

        //写数据
        //字节输出流特有方法
        ps.write(97);
        //使用特有方法写数据
        ps.print(97);
        ps.print(98);
        ps.println(97);
        ps.println(98);

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



 /*       //字符打印流PrintWriter的构造方法
        PrintWriter​(String fileName)
            使用指定的文件名创建一个新的PrintWriter，而不需要自动执行行刷新。
        PrintWriter​(Writer out, boolean autoFlush)
            创建一个新的PrintWriter。
            out字符输出流，autoFlush布尔值，如果为真，则print，println，或format方法将刷新输出缓冲区
*/
        PrintWriter pw=new PrintWriter(new FileWriter("idea_text\\ps.txt"));
        pw.println("hello");
        pw.println("world");





    }
}

复制java文件打印流改进版

package IO流.特殊操作流;

import java.io.*;

public class 复制java文件打印流改进版 {
    public static void main(String[] args) throws IOException {
        //根据数据源创建字符输入流对象
        BufferedReader br = new BufferedReader(new FileReader("1"));
        //根据目的地创建字符输出流对象
        PrintWriter pw=new PrintWriter(new FileWriter("2"));

        //读写数据，复制文件
        String line;
        while ((line = br.readLine()) != null) {
            pw.println(line);
        }

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

    }
}

Properties作为Map集合的使用

package IO流.特殊操作流.Properties;
/*
    Properties概述：
        1，是一个Map体系的集合类
        2，Properties可以保存到流中或从流中加载

 */

import java.util.Properties;
import java.util.Set;

public class Properties作为Map集合的使用 {
    public static void main(String[] args) {
        //创建集合对象--Properties不是泛型
//        Properties<String, String> properties = new Properties<String, String>();
        Properties prop = new Properties();
        //存储元素
        prop.put("001", "z");
        prop.put("002", "x");
        prop.put("003", "c");
        //遍历结合
        Set<Object> keySet = prop.keySet();
        for (Object key : keySet) {
            Object value = prop.get(key);
            System.out.println(key + "," + value);
        }

    }
}

Properties特有方法

package IO流.特殊操作流.Properties;
/*
    Object setProperty​(String key, String value)
        调用 Hashtable方法 put 。
    String getProperty​(String key)
        使用此属性列表中指定的键搜索属性。
    Set<String> stringPropertyNames​()
        从该属性列表中返回一个不可修改的键集，其中键及其对应的值是字符串
 */

import java.util.Properties;
import java.util.Set;

public class Properties特有方法 {
    public static void main(String[] args) {

        Properties prop=new Properties();

        prop.setProperty("001", "z");
        prop.setProperty("002", "x");
        prop.setProperty("003", "c");

        System.out.println(prop.getProperty("001"));

        Set<String> names = prop.stringPropertyNames();
        for (String key : names) {
            String value = prop.getProperty(key);
            System.out.println(key + "=" + value);
        }

    }

}

Properties和IO流结合的方法

package IO流.特殊操作流.Properties;
/*
    void load(InputStream inStream) 从输入字节流读取键值对
    void store(OutputStream out,String comments)
        将键值对写入Properties，以适合于使用load(InputStream)方法的格式写入输出字节流

    void load(Reader reader) 从输入字符流读取键值对
    void store(Writer writer,String comments)
        将键值对写入Properties，以适合于使用load(InputStream)方法的格式写入输出字符流
 */

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Properties;

public class Properties和IO流结合的方法 {
    public static void main(String[] args) throws IOException {
        //把集合中的数据保存文件中
        myStore();

        //把文件中的数据加载到集合
        myload();
    }

    private static void myload() throws IOException {
        Properties prop = new Properties();
        //void load(Reader reader)
        FileReader fr= new FileReader("idea_text\\fw.txt");
        prop.load(fr);
        fr.close();
        System.out.println(prop);
    }

    private static void myStore() throws IOException {
        Properties prop = new Properties();

        prop.setProperty("001","z");
        prop.setProperty("002","x");
        prop.setProperty("003","c");
        //void store(Writer writer,String comments)
        FileWriter fw = new FileWriter("idea_text\\fw.txt");
        prop.store(fw,null);
        fw.close();

    }
}

对象序列化流

package IO流.特殊操作流.对象序列化流;

import java.io.Serializable;

public class Student implements Serializable {
    private String name;
    private int age;

    public Student() {
    }

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

    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;
    }
}

package IO流.特殊操作流.对象序列化流;
/*
    对象序列化流:ObjectOutputStream
        将Java对象的原始数据类型和图形写入OutputStream，可以使用ObjectInputStream读取(重构)对象。
        可以通过使用流的文件来实现对象的持久存储。如果流是网络套接字流，则可以在另一个主机上或另一个进程中重构对象

    构造方法:
        ObjectOutputStream(OutputStreamout):
            创建一个写入指定的OutputStream的ObjectOutputStream

    序列化对象的方法:
        void writeObject(Object obj):将指定的对象写入ObjectOutputStream

    注意:
        一个对象要想被序列化，该对象所属的类必须必须实现Serializable接口
        Serializable是一个标记接口，实现该接口，不需要重写任何方法
 */

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

public class 对象序列化流 {
    public static void main(String[] args) throws IOException {
        //创建一个写入指定的OutputStream的ObjectOutputStream
        ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("idea_text\\oos.txt"));
        //创建对象
        Student s=new Student("zxz",30);
        //void writeObject(Object obj):将指定的对象写入ObjectOutputStream
        oos.writeObject(s);
        //释放资源
        oos.close();


    }



}

对象反序列化流

package IO流.特殊操作流.对象序列化流;
/*
     对象反序列化流:ObjectInputStream
        ObjectInputStream反序列化先前使用ObjectOutputStream编写的原始数据和对象

     构造方法:
        ObjectInputStream(InputStream in):创建从指定的IutStream读取的ObjectInputStream

     反序列化对象的方法:
        Object readObject0:从ObjectInputStream读取一个对象
 */

import java.io.*;

public class 对象反序列化流 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //ObjectInputStream(InputStream in):创建从指定的IutStream读取的ObjectInputStream
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("idea_text\\oos.txt"));
        //Object readObject0:从ObjectInputStream读取一个对象
        Object obj=ois.readObject();

        Student s=(Student) obj;
        System.out.println(s.getName()+","+s.getAge());

        ois.close();


    }
}

对象序列化流的问题

package IO流.特殊操作流.对象序列化流.对象序列化流的问题;

import java.io.Serializable;

public class Student implements Serializable {
    private static final long serialVersionUID =42L;
    private String name;
//    private int age;
    private transient int age;  //age=null;
    public Student() {
    }

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

    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;
    }

    @Override
    public String toString() {//所改变的对象所属的类文件
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

package IO流.特殊操作流.对象序列化流.对象序列化流的问题;
/*
    1,用对象序列化了一个对象后，假如我们修改了对象所属的类文件，读取数据会出现问题吗？
        会出现问题，抛出  InvalidClassException 异常
    2，出问题了，如何解决？
        给对象所属的类加一个SerialVersionUID
        private static final long serialVersionUID =42L;
    3，如果一个对象中的某个成员变量的值不想被序列化，又该如何实现呢？
        给该成员变量加transient关键字修饰，该关键字标记的成员变量不再参与序列化过程

 */

import java.io.*;

public class Demo {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
//       write();
        read();
    }
    //反序列化
    private static void read() throws IOException, ClassNotFoundException {
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("idea_text\\oos.txt"));
        Object obj = ois.readObject();
        Student s=(Student) obj;
        System.out.println(s.getName()+","+s.getAge());
        ois.close();

    }
    //序列化
    private static void write() throws IOException {
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("idea_text\\oos.txt"));
        Student s= new Student("程序员",20);
        oos.writeObject(s);
        oos.close();


    }

}