JavaSE_day16:IO流

IO流：

       Input输入流

       Output输出流

  那么在学习输入输出流的时候，我们先来看一下这个文件File（java.io.File）:他对应实际的文件或者文件夹（目录）

首先要new一个文件目录：    File file=new File(String类型的文件路径);

  比如  （1）File file=new File（“F：\\panda.txt”）;  可以用‘\’符号来分隔，但是要有一个转移符‘\’所以就是“F：\\panda.txt ”

           （2）File file=new File（“F：/panda.txt ”）；也可以用‘/’分隔符。

当然可以用File.separator来获取，不同操作系统的分隔符

那么下来看一下文件对象的一些方法：(以下file均为File的对象)

file.isFile():返回一个boolean值，表示是否是一个文件

file.isDirectory():  返回一个boolean值表示是否是一个目录

  而且File也可以创建不存在的文件

file.mkdir():可以创建一个目录，   

file.mkdirs():可以创建多级目录

              举例：（单个目录）

                           File file =new File(“d:/panda.txt”)；

                           file.mkdir();                       //此时就会在d盘创建一个文件panda.txt

           举例：（多级目录）

                           File file=new File（“d:\\陈小帅\\panda.txt”） ;

                          file.mkdirs();                     //此时就会在d盘创建一个【陈小帅】文件，然后在【陈小帅】文件里在创建一个人panda.txt文件，多级目录。

好，那么现在再看一下怎样判断这个文件是否存在呢？还有就是存在的话，如何将这文件里边的子文件展示出来：

方法：

    file.exists（）：判断文件是否存在

  file.listFiles（）：展示指定文件里边的子文件    

那么就具体看一看这个实际应用：（  file.exists（）：判断文件是否存在）

public class FileDemo {
    public static void main(String[] args) {
        File file2 = new File("F:\\panda.txt");
        System.out.println(file2.exists());
    }
}
这个iiexists方法的返回值是一个boolean类型的，如果在f盘里边有panda.txt文件，那么就会返回一个true，如果不存在的话，那么就会返回false。

再来看一看这个展示子文件的listFiles方法：

import java.io.File;

public class ListFileDemo {
    public static void main(String[] args) {
        File file = new File("F:\\java程序");
        File[] files = file.listFiles();
        for (File f : files) {
            System.out.println(f);
        }
    }
}
这样的话，就会打印出F盘下java程序文件下的所有子文件，如果这个文件的子文件特别多，你想在这些文件中查找一些特别的子文件，那么就要来过滤这些子文件，通常都是通过子文件的名字来过滤的，那么就推出筛选文件的接口------------>FilenameFilter接口

public class FilenameFilterDemo {
    public static void main(String[] args) {
        File file = new File("F:\\\\java程序");
        File[] listFiles = file.listFiles(new FilenameFilter() {
            @Override
            public boolean accept(File dir, String name) {
                if (name.startsWith("demo")) {
                    return true;
                } else {
                    return false;
                }
            }
        });
        for (File f : listFiles) {
            System.out.println(f);
        }
    }
}

通过这个FilenameFilter接口过滤掉了不是以“demo”开头的文件，使得找文件的效率得以提高。

如果说，某个文件不想要了，那么就要使用删除的方法来进行移除文件，delete方法和deleteOnExit方法：两者最大的区别就是，delete对文件直接删除，不留情，但是deleteOnExit方法而言，他可以让程序运行一段时间，等到程序执行结束了再将文件删除。这个是delete方法的使用代码：

public class FileDeleteDemo {
    public static void main(String[] args) {
        File file = new File("panda2.txt");
        System.out.println(file.mkdir());
        System.out.println(file.delete());
    }
}

那么再来看一看deleteOnExit方法的使用：刚才说过，这个方法他是让程序执行一段时间之后才让某个指定的文件删除掉，那么这次就来举一个例子，就是让程序休眠5秒之后，再将某个指定的文件删除掉。

public class FileDeleteDemo {
    public static void main(String[] args) throws InterruptedException {
        File file = new File("panda2.txt");
        System.out.println(file.mkdir());
        Thread.sleep(5000);      //单位是ms
        file.deleteOnExit();
    }
}

还有文件的重命名和移动文件位置：

方法是renameTo（）：

public class RenameToDemo {
    public static void main(String[] args) {
        File file = new File("F:\\测试.txt");
        file.renameTo(new File("F:\\测试3.txt"));
    }
}

文件存储的路径：

1.相对路径：

                File( “panda.txt”)：就是之写出最后的一部分的路径就是相对路径

                    System.out.println(file.getAbsoluteFile());打印出相对路径

2当前路径：

              System.out.println(System.getProperty("user.dir"));

3.绝对路径：

              File("D:\\6.23实训班共享\\代码\\Day16-IO\\1.txt");文件具体存储的位置

IO流：（今天的重难点）

input：输入流：从文件中读取数据，文件对我就是输入流

Output：输出流：从文件中写入数据，文件对我就是输出流

字节流：

InputStream：字节输入流（抽象类，需要子实现类FileInputStream）

OutputStream：字节输出流（抽象类，需要子实现类FileOutputStream）

一次读入一个字节

public class InputStreamDemo {
    public static void main(String[] args) throws IOException {
        InputStream inputStream = new FileInputStream("E:\\ppppp.txt");
        while(true) {                                                                                         //如果这里不使用while循环，那么就要不断的调用read方法，是的代码很臃肿。所以应循环处理下
        int read = inputStream.read();
        if(read==-1) {
            break;
        }
        System.out.print((char)read);
        }
    }
}
一次读入多个字节

public class InputStreamDemo2 {
    public static void main(String[] args) throws IOException {
        FileInputStream fileInputStream = new FileInputStream("E:\\\\ppppp.txt");
        byte[] bys=new byte[3];
        /*int read = fileInputStream.read(bys);
        System.out.println(read);
        System.out.println(Arrays.toString(bys));*/   //这个是单个读取字符，麻烦，用或循环改进
        while(true) {
            int read = fileInputStream.read(bys);
            if(read==-1) {
                break;
            }else {
                System.out.println(Arrays.toString(bys));
            }
        }

     fileInputStream.close();
    }
}

IO流的特点：流是单向的(在程序结束的时候要加上close方法）

输出流实例：

public class OutputStreamDemo {
    public static void main(String[] args) throws IOException {
        FileOutputStream fileOutputStream = new FileOutputStream("E:\\ppppp.txt");
        /*fileOutputStream.write(98);
        fileOutputStream.write(99);
        fileOutputStream.write(100);
        fileOutputStream.write(101);*/
        //覆盖原有内容（此时要注释掉上述代码，否则不会发生覆盖）
//        fileOutputStream.write(new byte[] {95,96,97,98,99});
        //一次写入多个字节，写入数组的一部分，off代表下标，len代表的是长度
        fileOutputStream.write(new byte[] {100,101,102,103,104},0,2);
        //上一句代码意思是：从数组下标为0开始写入长度为2的字节，那么就只有100和101 他俩在ASCII码中对应的是de。
          fileOutputStream.close();
    }
}

文件的复制：

public class CopyFileDemo {
    public static void main(String[] args) throws IOException {
        FileInputStream fileInputStream = new FileInputStream("E:\\ppppp.txt");
        FileOutputStream fileOutputStream = new FileOutputStream("E:\\ppppp2.txt");
        while(true) {
            byte[] bys=new byte[1024];
            int read = fileInputStream.read(bys);
            if(read==-1) {
                break;
            }
            fileOutputStream.write(bys,0,read);
        }
    }
}

此处需要注意的是：ppppp2.txt文件你可以先创建，也可以不创建（就是直接没有）程序会主动给你创建要复制到的文件；还有就是如果没有while循环中的if条件语句，虽然ppppp.txt的内容会复制到ppppp2.txt，但是同时会报出一个异常：IndexOutOfBoundsException【角标越界异常】，那么不影响后续程序的正常运行（当然在当前程序中，程序差不多已经结束了）就必须要加上if语句加以判断

字符流：（重难点）

以字符为单位处理流的内容

Reader字符输入流     InputSreamReader  将字节输入流转换成字符输入流

Writer字符输出流       OutputStreamWriter将字节输出流转换成字符输出流

public class InputStreamDemo {
    public static void main(String[] args) throws IOException {
        FileInputStream fileInputStream = new FileInputStream("E:\\ppppp.txt");
        InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream,"utf-8");
        while(true) {
            char[] ch=new char[1024];
            int read = inputStreamReader.read(ch);
            if(read==-1) {
                break;
            }
            System.out.println(Arrays.toString(ch));
        }
    }

     inputStreamReader.close();
}

ppppp.txt中的字符串是dexswfwgeh

最终的结果是：[d, e, x, s, w, f, w, g, e, h, .......]此处公有1014个空格；

【注意：】最终的文件编码要和读入的文件编码一致，否则出现乱码,最终只需要将外层的输入流文件关闭了就可以，程序内部会将我们将内部类关闭掉。

BufferedReader在InputStreanReader的基础上以行为单位处理字符输入了，与InputStreamReader是平级关系，父类都是Reader

public class BufferedReaderDemo {
    public static void main(String[] args) throws IOException {
        FileInputStream fileInputStream = new FileInputStream("E:\\ppppp.txt");
        InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream,"utf-8");
        BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
        while(true) {
            String readLine = bufferedReader.readLine();
            if(readLine==null) {
                break;
            }
            System.out.println(readLine);
        }
    }
}
要注意的还是InputStreamReader的编码要和上边读入的编码一致

装饰者模式
    装饰者与被装饰者需要有一个共同的父类
    装饰者和被装饰者之间体现的是组合的关系,而不是继承的关系(目的是为了更加灵活)
    装饰者会对被装饰者做功能上的增强