IO流

1、IO流之File类（管理文件夹与文件）

分隔符：

 都是静态方法，所以类名.方法名
 与系统有关的路径分隔符 这是需要拼串时用到，
 win ; linux :
System.out.println(File.pathSeparator);
与系统有关的名称分隔符
 windows  linux /
System.out.println(File.separator);

windows的写法

 如何创建File类：

构造函数：

 最常用的

　　　　 File file = new File("D:\demo0611\a.txt"); 最常用的
        System.out.println(file);
        File file2 = new File("D:\demo0611", "a.txt");
        System.out.println(file2);
        File file3=new File(new File("D:\demo0611"),"a.txt");
        System.out.println(file3);

 因为是构造方法，所以在创建时就可以传参数。

 File类的方法：

File file=new File("D:\demo06\a.txt");
        String abpath=file.getAbsolutePath();
        System.out.println(abpath);
        //获取文件名 //自动调取tostring
        String fileName=file.getName();
        System.out.println(fileName);
        //获取后缀→转换为字符串
        String filePath=file.getPath();
        System.out.println(filePath);
        //获取文件大小
        System.out.println(file.length());

 File类文件操作：

 这里包含的是文件和文件夹的内容，其中比较常用的是创建新文件，测试文件或者文件夹是否存在。

我们分开书写的话就是：

System.out.println("=======文件操作==========");
        File file=new File("D:\demo0611\e\t\y");
        //创建文件  不能创建文件夹 不会覆盖掉之前的文件
        //file.createNewFile();   这里可以直接创建文件
        //判断file对象封装的文件或文件夹是否存在
        System.out.println(file.exists());//返回布尔值
        //删除文件、文件夹
        file.delete();
        //创建按文件夹 不加s不支持全部，加s支持一次更新好几个文件夹
        //file.mkdir();
        file.mkdirs();一次创建好几个文件夹
        //判断文件对象是否是文件夹
        System.out.println(file.isDirectory());
        //判断文件对象是否是文件夹
        System.out.println(file.isFile());
    }

　　

 File类文件夹操作listFiles（遍历，求一个文件夹下的文件和文件夹的数量）：

 1、返回一个字符串数组

String [] files=file.list();
        //增强for遍历
        for(String s:files ){
            System.out.println(s);
        }

2、返回一个抽象路径数组

//获取路径下的所有文件和文件夹的File[] 路径,获取文件对象，可以操作file对象下的各种方法
        File[] files=file.listFiles();
        //遍历
        for(File f:files){
            System.out.println(f);
        }

 这里可以获取到全部的路径，就可以通过f操作File类下的操作了。

文件过滤器

这是判断文件是否包含在内

 

 

---

 案例一、获取.java后缀的文件

//继承FileFilter来创建过滤的条件
public class Java implements FileFilter{

    public boolean accept(File pathname) {
            //如果是文件夹，直接返回return true
        if(pathname.isDirectory()){
            return true;
        }
        //开始判断带.java的文件
        String name=pathname.getName();
        //开始转为小写，让大小写的都出来
        String endname=name.toLowerCase();
        return endname.endsWith(".java");
    }
}
=========测试类==========
public class CeShi {
    public static void main(String[] args) {
        //先创建File类
                File file=new File("D:\demo0611");
                //调取getFile方法
                getFile(file);
    }
    public static void getFile(File file){
        //传入过滤器
        File [] files=file.listFiles(new Java());
        //开始获取文件数组，这里用到递归
        for(File f:files){
            //首先判断是否是文件夹
            if(f.isDirectory()){
                getFile(f);
            }else{
                System.out.println("这是文件"+f);
            }
        }

流程图：

“D：\demo0611”==File pathname

这个小案例可以得出，当我们创建一个自定义类来实现FileFilter接口时，除了重写了accept方法，并且在accept方法中建立了一个文件过滤条件，从而通过    File [] files=file.listFiles(new Java());将文件多走一边流程经过过滤器，晒选出满足过滤条件的文件，再进入遍历数组。加入递归是因为，我们需要不停的遍历总文件夹下的剩余文件夹里的文件，所以需要不停的调取自己进行二次遍历，直到没有相关的文件夹为止。最终实现效果。

---

递归：

递归，自己里面调用自己的方法

  必须有出口，否则没有意义

 构造方法不能递归

 递归的次数不能过多

如果过多回报内存不足异常。

递归练习：

 计算1-3的值

public static void main(String[] args) {
        int sum=get(3);
        System.out.println(sum);
        //用递归的方式计算1-100的和
        //100+99+98+97+96+。。。1
        //100+（100-1）+(99+1)....1
        //计算5！=5*4*3*2*1
    }
    public static int get(int n){
        if(n==1){
            return 1;
        }
        return n+get(n-1);
    }
============值6=========

     //递归是从3开始走的
    //1                                           3     走第二遍 int n=2 走第三遍  int i=1
    public static int get(int n){
        if(n==1){
            return 1;    //走第三遍   1  
        }
        return n+get(n-1); //3+get（2）  第二遍 2+get（1）
    /*    当n==1的时候是出口，这时候有一个确认的值，ger（1）=1，
     * 所以求的确定值之后，第一遍return 给调用者get（n-1）处，
     * 是 2+（get（1））=2+1=3 ，这时求出了1+2的值
     * 第二遍return 是（n=3）+（get（n-1））=3+（get（2））=3+（get（1）+get（2））=3+3=6，
     * 这一边是求3的值
     * */
                                            
    }

兔子事件

        public static void main(String[] args) {
            int sum=get(12);
            System.out.println(sum);
        }
        public static int get(int n){
            if(n==1){
                return 1;
                //递归的出口，当=1出去
            }
                if(n==2){
                    return 1;
                }
                return get(n-1)+get(n-2);
            }
    }
=======144=============