IO流

IO介绍

1.File类：
    File类: 文件或目录(文件夹)的**路径名。
    构造方法：
        public File(String pathname) : 创建了一个File对象, 表示的是参数中路径所代表的文件(文件夹)。
        public File(String parent, String child) : 创建了一个File对象, 表示的是父级路径和子级路径拼接起来之后所代表的文件(文件夹)。
        public File(File parent, String child) : 创建了一个File对象, 表示的是File中的父级路径和子级路径拼接起来之后所代表的文件(文件夹)。
    代码演示：
        public class FileDemo01 {
            public static void main(String[] args) {
                //createFileMethod1();
                //createFileMethod2();
                createFileMethod3();


            }

            private static void createFileMethod3() {
                //构造方法三：文件路径=File对象路径+子路径 拼接而成
                File parentFile = new File("d:\\java");
                File file = new File(parentFile, "a.txt");
                System.out.println(file.exists());
            }

            private static void createFileMethod2() {
                //构造方法二：文件路径=父路径+子路径 拼接而成
                File file = new File("d:", "java\\a.txt");
                System.out.println(file.exists());
            }

            private static void createFileMethod1() {
                //构造方法一：直接new，直接指定具体的文件路径，如果存在该文件，则file.exists()方法返回true
                File file = new File("d:\\a.txt");
                System.out.println(file.exists());
            }
        }
    成员方法：
        路径：
        绝对路径：从盘符开始, 一直表示到最后的文件(文件夹)。
        相对路径：相对于某一个位置开始, 表示的路径。
        常用方法：
            获取方法：
            public String getAbsolutePath() : 获取绝对路径
            public String getPath() : 获取File构造方法中的路径 
            public String getName() : 获取File对象中最后所表示的文件(文件夹)的名字
            public long length() : 获取文件的字节个数, 不能获取文件夹的字节个数.
                UTF-8中: 一个中文字符占3个字节；
                GBK中: 一个中文字符占2个字节；
                代码演示：
                public class FileDemo02 {
                    public static void main(String[] args) {
                        File file = new File("D:\\java\\a.txt");
                        //获取绝对路径
                        System.out.println(file.getAbsolutePath());
                        //获取构造方法中指定的路径，也就是：D:\java\a.txt
                        System.out.println(file.getPath());
                        //获取文件或文件夹的名字
                        System.out.println(file.getName());
                        //获取文件的字节个数,不能获取文件夹的字节个数
                        System.out.println(file.length());
                    }
                }
            判断方法：
                public boolean exists() : 判断File表示的文件(文件夹)是否存在
                public boolean isFile() : 判断File表示的内容是否是文件
                public boolean isDirectory() : 判断File表示的内容是否是文件夹
            创建方法：
                注意：创建了一个File对象, File对象表示的文件(文件夹)不一定存在.
                public boolean createNewFile() : 当File表示的文件不存在的时候, 创建这个新文件.
                public boolean mkdir() : 创建单级文件夹
                public boolean mkdirs() : 创建多级文件夹(也可以创建单级)
                代码演示：
                public class FileDemo03 {
                    public static void main(String[] args) throws IOException {
                        //createNewFile();
                        //singleDir();
                        manyDirs();


                    }

                    private static void manyDirs() {
                        //创建File对象，指定路径，路径对应的文件夹不一定存在
                        File path = new File("d:\\lyle\\ly\\web");
                        //创建多级文件夹，也可以用于创建单级文件夹
                        //调用mkdirs()方法，如果文件夹不存在，则创建文件夹
                        path.mkdirs();
                    }

                    private static void singleDir() {
                        //创建File对象，指定路径，路径对应的文件夹不一定存在
                        File path = new File("d:\\lyle");
                        //创建单级文件夹
                        //调用mkdir()方法，如果文件夹不存在，则创建单级文件夹
                        path.mkdir();
                    }

                    private static void createNewFile() throws IOException {
                        //创建File对象，指定路径，路径对应的文件不一定存在
                        File path = new File("d:\\a.txt");
                        //调用createNewFile方法，如果文件不存在，则创建这个文件
                        path.createNewFile();
                    }
                }
            删除方法：
                public boolean delete() : 删除文件和文件夹
                注意事项:
                    1. 只能删除空文件夹;
                    2. 删除的内容不走回收站
                public class FileDemo04 {
                    public static void main(String[] args) {
                        //deleteFile();
                        deleteDir();


                    }

                    private static void deleteDir() {
                        //删除文件夹，注意该方法只能删除空文件夹，而且删除后不进回收站
                        File file = new File("d:\\lyle");
                        boolean delete = file.delete();
                        System.out.println(delete);
                    }

                    private static void deleteFile() {
                        //删除文件
                        File file = new File("d:\\a.txt");
                        file.delete();
                    }
                }
            遍历文件夹：
                方法：
                public String[] list() : 获取文件夹中的所有文件和文件夹的名称, 把它们存放到返回的String数组中.
                public File[] listFiles() : 获取文件夹中的所有文件和文件夹, 把它们以File对象的方式存放到返回的File数组中.
                代码演示：
                    public class FileDemo05 {
                        public static void main(String[] args) {
                            //list();
                            //常用方法：listFiles()，获取文件对象的数组
                            File file = new File("d:\\java");
                            File[] files = file.listFiles();
                            for (File file1 : files) {
                                System.out.println(file1);
                            }

                        }

                        private static void list() {//获取指定文件夹中的所有文件和文件夹的名称，组成字符串数组返回，该方法并不常用
                            File file = new File("d:\\java");
                            String[] list = file.list();
                            for (String s : list) {
                                System.out.println(s);
                            }
                        }
                    }
                
2.递归介绍：
    递归：方法调用方法本身。
    注意事项：
        递归必须有出口；
        递归的次数不能过多；
    
    实例：递归求阶乘
        public class Factorial {
            public static void main(String[] args) {
                //System.out.println(fun(5));
                System.out.println(fun2(5));
            }

            /**
             * 求n 的阶乘
             * for循环方式
             * @param n
             * @return
             */
            public static int fun(int n) {
                int result = 1;
                if (n == 0 || n == 1) {
                    return result;
                } else {
                    for (int i = n; i > 0; i--) {
                        result *= i;
                    }
                    return result;
                }
            }
            /**
             * 求n 的阶乘
             * 递归方式
             * @param n
             * @return
             */
            public static int fun2(int n) {
                int result = 1;
                if (n == 0 || n == 1) {
                    return result;
                } else {
                    return result=n*fun2(n-1);
                }
            }
        }
        
    递归获取所有文件夹和文件：
        public class FileDemo {
            public static void main(String[] args) {
                getAllFiles(new File("d:\\java"));
            }

            public static void getAllFiles(File dir){
                File[] files = dir.listFiles();
                for (File file : files) {
                   // System.out.println(file);
                    if (file.isFile()){
                        //System.out.println("是文件，直接打印");
                        System.out.println(file);
                    }else {
                        System.out.println("是文件夹，递归遍历");
                        getAllFiles(file);
                    }
                }
            }
        }
    
IO:
    作用：数据的传输
    分类：
        根据数据的流向分为：**输入流**和**输出流**。
            - **输入流** ：把数据从`其他设备`上读取到`内存`中的流。 
            - **输出流** ：把数据从`内存` 中写出到`其他设备`上的流。
        根据数据的类型分为：**字节流**和**字符流**。
            - **字节流** ：以字节为单位，读写数据的流。
            - **字符流** ：以字符为单位，读写数据的流。
            
    字节输出流：OutputStream
        public class FileOutPut {
            public static void main(String[] args) throws Exception{
                //字符输出流关联的文件如果不存在，则会自动创建该文件
                //如果该文件存在，则会清空该文件里面的内容
                OutputStream os=new FileOutputStream(new File("d:\\java\\a.txt"));
                byte[] b=("十步杀一人，千里不留行。\n" +
                        "事了拂衣去，深藏身与名。")
                        .getBytes();
                os.write(b);
                os.flush();
                os.close();
            }
        }
        
    字节输入流：InputStream
        public class FileInput {
            public static void main(String[] args) throws Exception{
                //输入流关联的文件如果找不到，则会报异常（文件找不到）
                InputStream is=new FileInputStream("d:\\java\\a.txt");
                int b;
                
                while ((b=is.read())!=-1){//如果读取到文件末尾，返回-1
                    System.out.println(b);
                }

                is.close();

            }
        }
        
    文件拷贝：一个字节一个字节的拷贝，速度很慢
        public class FileCopy {
            public static void main(String[] args) throws Exception{
                //创建输入流读取文件
                InputStream is=new FileInputStream("d:\\java\\a.txt");
                //创建输出流写出文件
                OutputStream os=new FileOutputStream("d:\\java\\b.txt");
                //读取文件
                int b;
                while ((b=is.read())!=-1){
                    //写出文件
                    os.write(b);
                }
                //关流
                os.close();
                is.close();
            }
        }
        
    字节数组拷贝文件：速度比较快
        public class FileArrayCopy {
            public static void main(String[] args) throws Exception{
                //创建输入流读取文件
                InputStream is=new FileInputStream("d:\\java\\Gmm.gif");
                //创建输出流写出文件
                OutputStream os=new FileOutputStream("d:\\java\\copyGmm.gif");
                //读取文件
                //定义字节数组，存储字节
                byte[] b=new byte[1024*8];
                int len;//读取长度
                long start = System.currentTimeMillis();
                while ((len=is.read(b))!=-1){
                    //写出文件
                    os.write(b,0,len);
                }
                long end = System.currentTimeMillis();
                System.out.println((end-start));
                //关流
                os.close();
                is.close();
            }
        }