十七、IO流

 1、File类
（1）File类的几种构造方法；
    //创建文件和文件夹
    public static void createFile() throws IOException {
        //文件操作
        //File file = new File("file.txt");
        //创建
        //boolean b = file.createNewFile();
        //删除
        //boolean b = file.delete();
        //是否存在
        //boolean b = file.exists();

        //创建文件夹
        File dir = new File("c:\\abc");
        boolean b = dir.mkdir();
        System.out.println("b="+b);
    }

（2）获取文件信息（略）
    获取名称，
    获取路径，
    获取大小，
    获取时间。

（3）判断（略）
    文件是否可读；
    文件是否可写；
    文件是否可执行；
    文件是否隐藏；

（4）文件的创建和删除以及该文件是否存在；

（5）练习列出子目录中的内容（递归）；
    //递归遍历文件夹
    public static void printFiles(File dir,int count){
        System.out.println(getSpace(count)+dir.getName());
        count++;
        File[] files = dir.listFiles();
        if(files != null){
            for(File file:dir.listFiles()){
                if(file.isDirectory()){
                    printFiles(file,count);
                }else{
                    System.out.println(getSpace(count)+file.getName());
                }
            }
        }
    }

    //计算空格
    public static String getSpace(int count){
        StringBuilder builder = new StringBuilder();
        for(int i=0;i例子：
    FileWriter fw = new FileWriter("demo.txt");
    fw.write("abcdef");
    fw.flush();
    fw.write("haha");
    fw.close();

    <2>flush()和close()有什么区别？
    flush()：仅将缓冲区中的数据刷新到目的地。流对象可以继续使用。
    close()：将缓冲区中的数据刷到目的地后，直接关闭资源，流无法继续使用。

    <3>IO异常的基本处理方式：
    FileWriter fw = null;
    try {
        fw = new FileWriter("demo.txt",true);
        fw.write("abcdef");
        fw.flush();
        fw.write("ha\r\nha");

    } catch (IOException e) {
        e.printStackTrace();
    }finally {
        if(fw != null){
            try {
                fw.close();
            } catch (IOException e) {
                throw new RuntimeException("字符流关闭失败");
            }
        }
    }

3、字节流
    InputStream，OutputStream

4、转换流，打印流，对象序列化，编码等)
    （1）PrintStream和PrintWriter：可直接操作流和文件

    （2）序列流SequenceInputStream：对多个流进行合并

    （3）操作对象
        <1>ObjectInputStream与ObjectOutputStream
        //被操作的对象需要实现Serializable；

        <2>对象的序列化
        Serializable使用的时候生成的序列号，建议显示声明，防止编译器不同时，发生错误；
        
        注意：
        （1）类中的静态成员变量是不能被序列化的，因为静态成员变量不再堆中。
        （2）如果希望非静态数据不被初始化，可以使用transient修饰对象。

    （4）文件分割

    （5）RandomAccessFile

    （6）管道流
        特点：
            <1>单线程容易造成死锁。
            
        示例：
        public class PipedStreamDemo {

            public static void main(String[] args) throws IOException {
                PipedInputStream inputStream = new PipedInputStream();
                PipedOutputStream outputStream = new PipedOutputStream();
                inputStream.connect(outputStream);
                Input input = new Input(inputStream);
                Output output = new Output(outputStream);
                new Thread(output).start();
                new Thread(input).start();
            }

        }

        class Input implements Runnable{
            private PipedInputStream in;

            public Input(PipedInputStream in){
                super();
                this.in = in;
            }

            @Override
            public void run() {
               byte[] buf = new byte[1024];
                int len = 0;
                try {
                    len = in.read(buf);
                    String str = new String(buf,0,len);
                    System.out.println("read:"+str);
                    in.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

        class Output implements Runnable{
            private PipedOutputStream out;

            public Output(PipedOutputStream out) {
                this.out = out;
            }

            @Override
            public void run() {
                try {
                    out.write("hello piped!".getBytes());
                    out.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    （7）操作基本数据类型的流
        private static void operateData() throws IOException {
        //        FileOutputStream fos = new FileOutputStream("data.txt");
        //        DataOutputStream dos = new DataOutputStream(fos);
        //        dos.writeInt(98);
        //        dos.writeBoolean(true);
        //        dos.close();

            DataInputStream dis = new DataInputStream(new FileInputStream("data.txt"));
            int num = dis.readInt();
            boolean b = dis.readBoolean();
            System.out.println("num = "+num);
            System.out.println("boolean = "+b);
            dis.close();
        }

    （8）操作字节数组的流
        private static void operateData() {
            ByteArrayInputStream bis = new ByteArrayInputStream("abc".getBytes());
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            
            int ch = 0;
            while ((ch=bis.read())!=-1){
                bos.write(ch);
            }
            System.out.println(bos.toString());
        }

5、IO流使用总结
（1）明确源和目的。
    源：InputStream Reader 一定是被读取的。
    目的:OutputStream Writer 一定是被写入的。

（2）处理的数据是否是基本数据？
    是：使用字符流。Reader Writer
    否：使用字节流。InputStream OutputStream

（3）明确数据所在设备：
    源设备：
    键盘（System.in）
    硬盘（FileXXX）FileReader FileInputStream
    内存（数组）ByteArrayInputStream CharArrayReader StringReader
    网络（Socket）

    目的设备：
    显示器（控制台System.out）
    硬盘（FileXXX）FileWriter FileOutputStream
    内存（数组）ByteArrayOutputStream CharArrayWriter StringWriter
    网络（Socket）

（4）明确是否需要额外功能？
    <1>是否需要高效？缓冲区Buffered四个。
    <2>是否需要转换？转换流 InputStreamReader OutputStreamWriter
    <3>是否操作基本数据类型？DataInputStream DataOutputStream
    <4>是否操作对象（对象序列化）？ObjectInputStream  ObjectOutputStream
    <5>需要对多个源合并吗？SequenceInputStream
    <6>需要保证数据的表现形式到目的吗？PrintWriter
    <7>如果数据有规律，并且源和目的都是file，需要随机访问时，可以使用RandomAccessFile工具类。