IO流的基本使用

IO流

    |--字节流        |--字节输入流            InputStream                int read():一次读取一个字节                int read(byte[] bys):一次读取一个字节数组                |--FileInputStream                |--BufferedInputStream        |--字节输出流            OutputStream                void write(int by):一次写一个字节                void write(byte[] bys,int index,int len):一次写一个字节数组的一部分                |--FileOutputStream                |--BufferedOutputStream    |--字符流        |--字符输入流            Reader                int read():一次读取一个字符                int read(char[] chs):一次读取一个字符数组                |--InputStreamReader                    |--FileReader                |--BufferedReader                    String readLine():一次读取一个字符串        |--字符输出流            Writer                void write(int ch):一次写一个字符                void write(char[] chs,int index,int len):一次写一个字符数组的一部分                |--OutputStreamWriter                    |--FileWriter                |--BufferedWriter                    void newLine():写一个换行符                    void write(String line):一次写一个字符串

案例- - - -复制多极文件夹

/* *  * 数据源：E:\JavaSE\day21\code\demos * 目的地：E:\\ *  * 分析： *      A:封装数据源File *      B:封装目的地File *      C:判断该File是文件夹还是文件 *          a:是文件夹 *              就在目的地目录下创建该文件夹 *              获取该File对象下的所有文件或者文件夹File对象 *              遍历得到每一个File对象 *              回到C *          b:是文件 *              就复制(字节流) */public class CopyFoldersDemo {    public static void main(String[] args) throws IOException {        // 封装数据源File        File srcFile = new File("E:\\JavaSE\\day21\\code\\demos");        // 封装目的地File        File destFile = new File("E:\\");        // 复制文件夹的功能        copyFolder(srcFile, destFile);    }    private static void copyFolder(File srcFile, File destFile)            throws IOException {        // 判断该File是文件夹还是文件        if (srcFile.isDirectory()) {            // 文件夹            File newFolder = new File(destFile, srcFile.getName());            newFolder.mkdir();            // 获取该File对象下的所有文件或者文件夹File对象            File[] fileArray = srcFile.listFiles();            for (File file : fileArray) {                copyFolder(file, newFolder);            }        } else {            // 文件            File newFile = new File(destFile, srcFile.getName());            copyFile(srcFile, newFile);        }    }    private static void copyFile(File srcFile, File newFile) throws IOException {        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(                srcFile));        BufferedOutputStream bos = new BufferedOutputStream(                new FileOutputStream(newFile));        byte[] bys = new byte[1024];        int len = 0;        while ((len = bis.read(bys)) != -1) {            bos.write(bys, 0, len);        }        bos.close();        bis.close();    }}

案例：把a.txt内容复制到当前的b.txt中—-Bufferd-w-r

/*
*
* 数据源：
* a.txt – 读取数据 – 字符转换流 – InputStreamReader – FileReader – BufferedReader
* 目的地：
* b.txt – 写出数据 – 字符转换流 – OutputStreamWriter – FileWriter – BufferedWriter
*/

public class CopyFileDemo2 {    public static void main(String[] args) throws IOException {        // 封装数据源        BufferedReader br = new BufferedReader(new FileReader("a.txt"));        // 封装目的地        BufferedWriter bw = new BufferedWriter(new FileWriter("b.txt"));        // 读写数据        String line = null;        while ((line = br.readLine()) != null) {            bw.write(line);            bw.newLine();            bw.flush();        }        // 释放资源        bw.close();        br.close();    }Properties----------/* * Properties:属性集合类。是一个可以和IO流相结合使用的集合类。 * Properties 可保存在流中或从流中加载。属性列表中每个键及其对应值都是一个字符串。  *  * 是Hashtable的子类，说明是一个Map集合。 */public class PropertiesDemo {    public static void main(String[] args) {        // 作为Map集合的使用        // 如果没有<>，就说明该类不是一个泛型类,在使用的时候就不能加泛型    Properties prop = new Properties();        // 添加元素        prop.put("it002", "hello");        prop.put("it001", "world");        prop.put("it003", "java");        // System.out.println("prop:" + prop);        // 遍历集合        Set<Object> set = prop.keySet();        for (Object key : set) {            Object value = prop.get(key);            System.out.println(key + "---" + value)    /*     * 特殊功能：     * public Object setProperty(String key,String value)：添加元素     * public String getProperty(String key):获取元素     * public Set<String> stringPropertyNames():获取所有的键的集合     */    public class PropertiesDemo2 {    public static void main(String[] args) {        // 创建集合对象        Properties prop = new Properties();        // 添加元素        prop.setProperty("张三", "30");        prop.setProperty("李四", "40");        prop.setProperty("王五", "50");        // public Set<String> stringPropertyNames():获取所有的键的集合        Set<String> set = prop.stringPropertyNames();        for (String key : set) {            String value = prop.getProperty(key);            System.out.println(key + "---" + value);        }    }    /*      class Hashtalbe<K,V> { public V put(K key,V value) { ... } }       class Properties extends Hashtable { public V setProperty(String key,String      value) { return put(key,value); } }     */打印流===    /*     * 需求：DataStreamDemo.java复制到Copy.java中     * 数据源：     *      DataStreamDemo.java -- 读取数据 -- FileReader -- BufferedReader     * 目的地：     *      Copy.java -- 写出数据 -- FileWriter -- BufferedWriter -- PrintWriter     */    public class CopyFileDemo {        public static void main(String[] args) throws IOException {            // 以前的版本            // 封装数据源            // BufferedReader br = new BufferedReader(new FileReader(            // "DataStreamDemo.java"));            // // 封装目的地            // BufferedWriter bw = new BufferedWriter(new FileWriter("Copy.java"));            //            // String line = null;            // while ((line = br.readLine()) != null) {            // bw.write(line);            // bw.newLine();            // bw.flush();            // }            //            // bw.close();            // br.close();        // 打印流的改进版        // 封装数据源        BufferedReader br = new BufferedReader(new FileReader(                "DataStreamDemo.java"));        // 封装目的地        PrintWriter pw = new PrintWriter(new FileWriter("Copy.java"), true);        String line = null;        while((line=br.readLine())!=null){            pw.println(line);        }        pw.close();        br.close();    }}序列化流----/* * NotSerializableException:未序列化异常 *  * 类通过实现 java.io.Serializable 接口以启用其序列化功能。未实现此接口的类将无法使其任何状态序列化或反序列化。 * 该接口居然没有任何方法，类似于这种没有方法的接口被称为标记接口。 *  * java.io.InvalidClassException:  * cn.itcast_07.Person; local class incompatible:  * stream classdesc serialVersionUID = -2071565876962058344,  * local class serialVersionUID = -8345153069362641443 *  * 为什么会有问题呢? *      Person类实现了序列化接口，那么它本身也应该有一个标记值。 *      这个标记值假设是100。 *      开始的时候： *      Person.class -- id=100 *      wirte数据： oos.txt -- id=100 *      read数据: oos.txt -- id=100    *  *      现在： *      Person.class -- id=200 *      wirte数据： oos.txt -- id=100 *      read数据: oos.txt -- id=100 * 我们在实际开发中，可能还需要使用以前写过的数据，不能重新写入。怎么办呢? * 回想一下原因是因为它们的id值不匹配。 * 每次修改java文件的内容的时候,class文件的id值都会发生改变。 * 而读取文件的时候，会和class文件中的id值进行匹配。所以，就会出问题。 * 但是呢，如果我有办法，让这个id值在java文件中是一个固定的值，这样，你修改文件的时候，这个id值还会发生改变吗? * 不会。现在的关键是我如何能够知道这个id值如何表示的呢? * 不用担心，你不用记住，也没关系，点击鼠标即可。 * 你难道没有看到黄色警告线吗? *  * 我们要知道的是： *      看到类实现了序列化接口的时候，要想解决黄色警告线问题，就可以自动产生一个序列化id值。 *      而且产生这个值以后，我们对类进行任何改动，它读取以前的数据是没有问题的。 *  * 注意： *      我一个类中可能有很多的成员变量，有些我不想进行序列化。请问该怎么办呢? *      使用transient关键字声明不需要序列化的成员变量 */public class Person implements Serializable {    private static final long serialVersionUID = -2071565876962058344L;    private String name;    // private int age;    private transient int age;    // int age;    public Person() {        super();    }    public Person(String name, int age) {        super();        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 "Person [name=" + name + ", age=" + age + "]";    }}    /*     * 序列化流：把对象按照流一样的方式存入文本文件或者在网络中传输。对象 -- 流数据(ObjectOutputStream)     * 反序列化流:把文本文件中的流对象数据或者网络中的流对象数据还原成对象。流数据 -- 对象(ObjectInputStream)     */    public class ObjectStreamDemo {        public static void main(String[] args) throws IOException,                ClassNotFoundException {            // 由于我们要对对象进行序列化，所以我们先自定义一个类            // 序列化数据其实就是把对象写到文本文件            // write();        read();    }        private static void read() throws IOException, ClassNotFoundException {            // 创建反序列化对象            ObjectInputStream ois = new ObjectInputStream(new FileInputStream(                    "oos.txt"));            // 还原对象            Object obj = ois.readObject();            // 释放资源            ois.close();            // 输出对象            System.out.println(obj);        }        private static void write() throws IOException {            // 创建序列化流对象            ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(                    "oos.txt"));            // 创建对象            Person p = new Person("林青霞", 27);            // public final void writeObject(Object obj)            oos.writeObject(p);            // 释放资源            oos.close();        }    }(1)字节打印流，字符打印流    (2)特点：        A:只操作目的地,不操作数据源        B:可以操作任意类型的数据        C:如果启用了自动刷新，在调用println()方法的时候，能够换行并刷新        D:可以直接操作文件            问题：哪些流可以直接操作文件呢?            看API，如果其构造方法能够同时接收File和String类型的参数，一般都是可以直接操作文件的    (3)复制文本文件

BufferedReader br = new BufferedReader(new FileReader("a.txt"));    PrintWriter pw = new PrintWriter(new FileWriter("b.txt"),true);         String line = null;    while((line=br.readLine())!=null) {        pw.println(line);    }    pw.close();    br.close();

“`