/** * ！！：以后写流的时候一定要加入缓冲！！ * 对文件或其它目标频繁的读写操作，效率低，性能差。 * 缓冲流：好处是能更高效地读写信息，原理是将数据先缓冲起来，然后一起写入或读取出来。 *  * BufferedInputStream：字节缓冲流（有一个内部缓冲区数组，用于缓冲数据） */public class Main {    public static void main(String[] args) {        input();        output();    }        /**     * 使用字节缓冲流进行读取操作     */    public static void input(){        try {            InputStream in = new FileInputStream("c:\\fuck\\javaTest1.txt");            BufferedInputStream bis = new BufferedInputStream(in); //根据字节输入流构造一个字节缓冲流            Reader r= new InputStreamReader(bis);            char[] cs = new char[512];            int len = -1;            StringBuilder sb = new StringBuilder();            while((len=r.read(cs))!=-1){                sb.append(new String(cs));            }            r.close();            bis.close();            in.close();            System.out.println(sb);                    } catch (FileNotFoundException ex) {            ex.printStackTrace();        } catch (IOException ex) {            ex.printStackTrace();        }    }        /**     * 使用字节缓冲流进行写入操作     */    public static void output(){        try {            OutputStream out = new FileOutputStream("c:\\fuck\\javaTest1.txt");            BufferedOutputStream bis = new BufferedOutputStream(out); //根据字节输出流构造一个字节缓冲流            String info = "顶替要夺kasdfas山不在高";            bis.write(info.getBytes());             bis.flush(); //刷新缓冲区（把数据写入文件里）            bis.close(); //关闭了会刷新缓冲区            out.close();                    } catch (FileNotFoundException ex) {            ex.printStackTrace();        } catch (IOException ex) {            ex.printStackTrace();        }    }}

public class Main {    public static void main(String[] args) {//        output();        input();        System.out.println("finished.");    }        /**     * 使用字符缓冲流进行读取操作     */    public static void input(){        try {            Reader r = new FileReader("c:\\fuck\\javaTest1.txt");            BufferedReader br = new BufferedReader(r); //根据字符输入流构造一个字符缓冲流            char[] cs = new char[512];            int len = -1;            StringBuilder sb = new StringBuilder();            while((len=br.read(cs))!=-1){                sb.append(new String(cs));            }            br.close();            r.close();            System.out.println(sb);                    } catch (FileNotFoundException ex) {            ex.printStackTrace();        } catch (IOException ex) {            ex.printStackTrace();        }    }        /**     * 使用字符缓冲流进行写入操作     */    public static void output(){        try {            Writer w = new FileWriter("c:\\fuck\\javaTest1.txt");            BufferedWriter bw = new BufferedWriter(w); //根据字符输出流构造一个字符缓冲流            bw.write("abcde i love u 丁");            bw.flush();            w.close();                    } catch (FileNotFoundException ex) {            ex.printStackTrace();        } catch (IOException ex) {            ex.printStackTrace();        }    }}

/** * 打印流：主要功能是用于输出 * PrintStream：字节打印流 * PrintWriter：字符打印流 */public class Main {    public static void main(String[] args) {//        print();        print2();        System.out.println("finished.");    }        /**     * 使用PrintStream打印流     */    public static void print(){        try {            OutputStream out = new FileOutputStream("c:\\fuck\\javaTest1.txt");            BufferedOutputStream bos = new BufferedOutputStream(out);            PrintStream ps = new PrintStream(bos); //构造字节打印流            ps.println(3.14f);            ps.println(188);            ps.println(true);            ps.println("it has.");            ps.flush();            bos.close(); //关掉一个就行了，其它也跟着关了                    } catch (FileNotFoundException ex) {            ex.printStackTrace();        } catch (IOException ex) {            ex.printStackTrace();        }    }        /**     * 使用PrintWriter打印流     */    public static void print2(){        try {            BufferedWriter bw = new BufferedWriter(new FileWriter("c:\\fuck\\javaTest1.txt"));            PrintWriter pw = new PrintWriter(bw);            pw.print("\r\n"); //输出回车换行符            pw.println(105);            pw.println("饥饿营销\"饿\"成笑话");            pw.flush();            pw.close();            bw.close();                     } catch (FileNotFoundException ex) {            Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);        } catch (IOException ex) {            Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);        }    }}

/** * 对象流 * 对象序列化：将一个对象转化成二进制的byte流 * 序列化操作：将对象保存在文件上    ObjectOutputStream * 反序列化操作：将对象从文件中恢复     ObjectInputStream * 被序列化对象所在的类必须实现java.Serializable接口 * 序列化一组对象可采用：对象数组的形式，因为对象数组可以向Object进行转型操作 * transient关键字：声明一个实例变量，当对象存储时，它的值不需要维持。 *      当持久化对象时，可能有一个特殊的对象数据成员，我们不想用serialization机制来保存它。 *      为了在一个特定对象的一个域上关闭serialization，可以在这个域前加上关键字transient。 *      当一个对象被序列化的时候，transient型变量的值不包括在序列化的表示中，然而非transient型的变量是被包括进去的。 */public class Main {    public static void main(String[] args) {//        writerObject();//        readerObject();//        writerObject2();        readerObject2();        System.out.println("finished.");    }        //使用ObjectOutputStream把对象写入文件    public static void writerObject(){        try {            OutputStream out = new FileOutputStream("c:\\fuck\\obj.tmp");            ObjectOutputStream oos = new ObjectOutputStream(out); //根据字节输出流构造一个对象流            oos.writeInt(106);            Dog d1 = new Dog("fish7",15);            oos.writeObject(d1);            oos.close();            out.close();                    } catch (FileNotFoundException ex) {            ex.printStackTrace();        } catch (IOException ex) {            ex.printStackTrace();        }    }        //使用ObjectOutputStream把一组对象写入文件（对象数组）    public static void writerObject2(){        try {            OutputStream out = new FileOutputStream("c:\\fuck\\obj.tmp");            ObjectOutputStream oos = new ObjectOutputStream(out); //根据字节输出流构造一个对象流            Dog[] dogs = {new Dog("fish7",15),new Dog("fish8",16),new Dog("fish9",17)};            oos.writeObject(dogs);            oos.close();            out.close();                    } catch (FileNotFoundException ex) {            ex.printStackTrace();        } catch (IOException ex) {            ex.printStackTrace();        }    }        //使用ObjectInputStream读取文件中的对象    public static void readerObject(){        try {            InputStream in = new FileInputStream("c:\\fuck\\obj.tmp");            ObjectInputStream ois = new ObjectInputStream(in); //根据字节输入流构造一个对象流            int num = ois.readInt();            Dog d1 = (Dog)ois.readObject();            ois.close();            in.close();            System.out.println(num);            System.out.println(d1.name+" "+d1.age);                    } catch (FileNotFoundException ex) {            ex.printStackTrace();        } catch (IOException ex) {            ex.printStackTrace();        } catch (ClassNotFoundException ex) {            ex.printStackTrace();        }    }        //使用ObjectInputStream读取文件中的一组对象（对象数组）    public static void readerObject2(){        try {            InputStream in = new FileInputStream("c:\\fuck\\obj.tmp");            ObjectInputStream ois = new ObjectInputStream(in); //根据字节输入流构造一个对象流            Dog[] dogs = (Dog[])ois.readObject();            ois.close();            in.close();            for(Dog i:dogs)                System.out.println(i.name+" "+i.age);                    } catch (FileNotFoundException ex) {            ex.printStackTrace();        } catch (IOException ex) {            ex.printStackTrace();        } catch (ClassNotFoundException ex) {            ex.printStackTrace();        }    }}/** * 类通过实现java.Serializable接口以启用其序列化功能，标记接口，没有任何方法 */class Dog implements Serializable{    String name;    transient int  age; //使用transient关键字声明的属性，将不会被序列化    public Dog(String name, int age) {        this.name = name;        this.age = age;    }}