JavaSE基础之IO流

	输入流	输出流
字节流	InputStream	OutputStream
字符流	Reader	Writer

1.字节流:(类后缀以OutpuStream、InputStream结尾)

        字节输入流:FileInputStream

                i.read():读文件

        FileInputStream fis = null;
        try {

            //FileInputStream  fis = new FileInputStream (文件路径);
            fis = new FileInputStream("./src/cn/IOTest.java");

            // 跳过多少字节不读取
            fis.skip(20);

            int flag = 0;

            //read():从输入流读取下一个数据字节,如果到达文件末尾,返回-1
            while ((flag = fis.read()) != -1) {
                System.out.print((char) flag);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (fis != null) {
                try {
                    //关闭流
                    fis.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }

                ii.read(byte[] b):

        FileInputStream fis = null;
        try {
            fis = new FileInputStream("./src/cn/IOTest.java");
            
            //定义byte数组
            byte[] bytes = new byte[1024];

            int temp = 0;
            //read(byte[]):从输入流中读取一定数量的字节并将其存储在缓冲区数组bytes中,返回读取的数据个数
            while ((temp = fis.read(bytes)) != -1) {
                System.out.println(new String(bytes, 0, temp));
            }

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (fis != null) {
                try {
                    fis.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }

        字节输出流:FileOutputStream:会自动创建文件,但是不会自动创建目录

        try {

            // 1.打开流
            FileOutputStream fos = new FileOutputStream("./src/cn/text_01.txt", true);// 2.设置覆盖还是追加:true是追加,false是覆盖(默认是覆盖)

            byte[] bytes = { 1, 2, 3 };

            
            //write(int b):将指定的字节写入此输出流
            // 3.write(byte[] bytes):写出
            fos.write(bytes);

            // 4.flush():刷缓存
            fos.flush();

            // 5.关闭流
            fos.close();
        } catch (Exception e) {
            e.printStackTrace();
        }

2.字符流:用于纯文本读取,汉字比较多,否则使用字节容易出现乱码问题(类后缀以Writer(写)、Reader(读)结尾)

        字符输入流:FileReader

        try {

            FileReader fr = new FileReader("./src/cn/IOTest.java");

            char[] chars = new char[512];
            int temp = 0;

            // read():读取单个字符
            // read(char[] chars):将字符读入数组
            while ((temp = fr.read(chars)) != -1) {
                System.out.print(new String(chars, 0, temp));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

        字符输出流:FileWriter

        try {
            FileWriter fw = new FileWriter("./src/cn/text_01.txt");

            char[] chars = { 'a', 'b', 'c' };

            // write(String str):写入字符串
            // write(int c):写入单个字符
            // write(char[] chars):写入字符数组
            fw.write(chars);

            fw.flush();
            fw.close();
        } catch (Exception e) {
            e.printStackTrace();
        }

3.缓冲流:

	字节流	字符流
文件输入流	BufferedInputStream	BufferedReader
文件输出流	BufferedOutputStream	BufferedWriter

        try {
            // 文件输入流
            FileReader fr = new FileReader("./src/cn/java/IO1/IO_01_Test.java");

            // 缓冲流
            BufferedReader br = new BufferedReader(fr);
            String temp = null;

            // readLine():读一行,读到文件末尾,返回null
            while ((temp = br.readLine()) != null) {
                System.out.println(temp);
            }

            // 关闭流顺序:先关最外层的流
            br.close();
            fr.close();
        } catch (Exception e) {
            e.printStackTrace();
        }

4.转换流:将字节流转为字符流

输入流	输出流
InputStreamReader	OutputStreamWriter

        File file = new File("./src/cn/java/IO1/IOTest.java");

        FileInputStream fis = new FileInputStream(file);

        // 转换流
        InputStreamReader ins = new InputStreamReader(fis);
        BufferedReader br = new BufferedReader(ins);

        String line = null;
        while ((line = br.readLine()) != null) {
            System.out.println(line);
        }

        //关闭流
        br.close();
        ins.close();
        fis.close();

5.其他流:

        数据流:DataOutputStream、DataInputStream

        // 数据输出流
        DataOutputStream dos = new DataOutputStream(new FileOutputStream("./src/cn/java/text_02.txt"));
        double d = 2.3;
        float f = 1.3F;
        int i = 10;
        boolean flag = false;
        char ch = 'a';
        String str = "abc";
        // 输出
        dos.writeInt(i);
        dos.writeDouble(d);
        dos.writeFloat(f);
        dos.writeBoolean(flag);
        dos.writeChar(ch);
        dos.writeUTF(str);
        /**
         * 注:如果用DataInputStream读取数据时,必须按照输出顺序一次读取,否则报错
         */

        数组流:ByteArrayInputStream、ByteArrayOutputStream

        对象流:即为以Java对象为传输主体的IO过程,这就要求Java对象必须被序列化才可以进行传输。

输入流	输出流
ObjectInputStream	ObjectOutputStream

                1).序列化与反序列化:

                        序列化:就是把对象保存到硬盘中的过程,即实现Serializable接口

public class User implements Serializable {
    /**
     * serialVersionUID:(用一句话描述这个变量表示什么).
     */
    private static final long serialVersionUID = 1L;

    // 加上transient后,该属性不能被序列化,访问该属性时,一直是默认值
    transient String name;

    int age;

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

    @Override
    public String toString() {
        return "User [name=" + name + ", age=" + age + "]";
    }

}

        User user = new User("张三", 18);
        // 创建序列化流
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("./src/cn.java.IO3.txt"));

        // 将user对象写出
        oos.writeObject(user);
        // 刷缓存
        oos.flush();
        // 关闭流
        oos.close();

                        反序列化:就是把硬盘中的对象,载入到堆内存的过程

        // 反序列化流
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("./src/cn.java.IO3.txt"));

        // 读对象
        Object object = ois.readObject();
        // 关闭流
        ois.close();

        /**
         * User [name=null, age=18]:<br>
         * 之所以name为null,是因为User对象在序列化的时候用transient修饰了name属性,所以name为默认值
         */
        System.out.println(object);

6.Flie文件处理操作:

        File file = new File("./src/cn/java/IO2");

        /**
         * getAbsolutePath():获取文件全路径
         * 
         * F:\software\eclipse\daima\JavaSE_09_IO\.\src\cn\java\IO2\FileTest.
         * java
         */
        System.out.println(file.getAbsolutePath());

        /**
         * getName():获取文件名/目录名 包含后缀
         * 
         * FileTest.java
         */
        System.out.println(file.getName());

        /**
         * getParent():获取父路径
         * 
         * .\src\cn\java\IO2
         */
        System.out.println(file.getParent());

        /**
         * isFile(): 是否是文件
         * 
         * true
         */
        System.out.println(file.isFile());

        /**
         * isDirectory():是否是目录
         * 
         * false
         */
        System.out.println(file.isDirectory());

        File file2 = new File("D:/a.txt");

        // createNewFile():不能创建目录,只能创建文件
        // 返回true 说明是新创建的,否则就返回false
        System.out.println(file2.createNewFile());

        // delete():删除,删除成功返回true
        file2.delete();

        // listFiles():获取所有的子文件对象
        File[] fs = file.listFiles();

        // length:有多少个子文件
        System.out.println(fs.length);