零基础学习java------day16-----文件，递归，IO流（字节流读写数据）

1.File

1.1 构造方法(只是创建已经存在文件的对象，并不能创建没有的文件)

（1）public File(String pathname)

（2）public File(String parent, String child)

（3）public File(File parent, String child)

public class FileDemo1 {
    public static void main(String[] args) {
        File f = new File("e:/a/b");
        System.out.println(f.exists()); //true
        File f1 = new File("e:/G09 result/","H2O"); //此处result后的“/”号有无都可以
        System.out.println(f1.exists()); //true
        File f2 = new File(f1,"H2O.out");
        System.out.println(f2.exists());//true
    }
}

1.2 File类成员方法

1.2.1 创建删除重命名功能

（1）创建功能　　

　　public boolean createNewFile()       创建文件
　　public boolean mkdir()                     创建单层文件夹
　　public boolean mkdirs()                   创建多层文件夹

（2）删除功能

　　public boolean delete()                    删除文件或文件夹(文件夹中有内容无法删除)

（3）重命名功能　

　　public boolean renameTo(File dest)   重命名（移动）

public class FileDemo2 {
    public static void main(String[] args) {
        try {
            File f = new File("e:/G09 result/H2O/t.txt");//创建文件的时候，目录必须存在
            boolean b = f.createNewFile();
            new File("e:/a").mkdir(); //在盘创建了a文件夹
            new File("e:/a/b/c/d").mkdirs();//创建了多层文件夹，此对象代表d这个文件夹
            File f1 = new File("e:/123");
            f1.createNewFile();//得到的是一个文件，文件可以没有后缀名
            File f2 = new File("e:/789.txt");
            f2.mkdir();//得到的是一个文件夹
            f1.delete();
            f2.delete(); // 如果文件夹中有内容是不能被删除的
            f.renameTo(new File("d:/haha.txt")); //将e:/G09 result/H2O/t.txt文件移动到d盘，并重命名为haha.txt
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

1.2.2 判断功能

（1）public boolean isDirectory()：是否是目录

（2）public boolean isFile()：是否是文件

（3）public boolean exists()：是否存在

（4）public boolean canRead()：是否可读

（5）public boolean canWrite()：是否可写

（6）public boolean isHidden():   是否隐藏

public class FileDemo3 {
    public static void main(String[] args) {
        File f = new File("e:/a");
        System.out.println(f.exists()); //true
        System.out.println(f.isDirectory());//true
        System.out.println(f.isFile());//false
        System.out.println(f.canRead()); //true
        System.out.println(f.canWrite()); //true
        System.out.println(f.isHidden()); //false
    }
}

1.2.3  获取功能

a . 基本获取功能

（1）public String getAbsolutePath()：获取绝对路径

（2）public String getPath()：              获取相对路径

（3）public String getName()：            获取文件名

（4）public long  length()：                  获取字节数

（5）public long lastModified：            获取最后修改时间

public class FileDemo4 {
    public static void main(String[] args) throws IOException {
        File f1 = new File("忽然.txt");
        f1.createNewFile();
        System.out.println(f1.getAbsolutePath());//E:\development\workspace\java\javase\javase\忽然.txt
        System.out.println(f1.getPath());//忽然.txt
        System.out.println(f1.getName());//忽然.txt
        System.out.println(f1.length());
        System.out.println(f1.lastModified());//1566540753201
        //先将long类型的毫秒值转为date类型的时间，然后再讲此时间转为特定格式的时间
        System.out.println(new SimpleDateFormat("yyyy-MM-dd hh:mm:ss").format(new Date(f1.lastModified())));
    }
}

b . 高级获取功能

（1）public String[ ]  list():                    获取所有子文件名称（返回值类型为字符串数组）

（2）public File[ ] listFiles():                获取所有子文件对象  （返回值类型为文件类型数组）        

public class FileDemo5 {
    public static void main(String[] args) {
        File f = new File("E:\\exercise");
        System.out.println(f.list());  //[Ljava.lang.String;@279f2327
        System.out.println(Arrays.toString(f.list()));//这样转化后就能打印数组了
        File[] listFiles = f.listFiles();
        System.out.println(f.listFiles());//[Ljava.io.File;@2ff4acd0,需要将其遍历出来
        for(File file:listFiles) {
            System.out.println(file);
        }
    }
}

练习  查询单层文件夹下所有以后缀名(.jpg))结尾的文件，此处，我要查询的文件夹如下：

法一：

public class FindFile {
    public static void main(String[] args) {
        getFile("E:\\exercise",".jpg");
    }
    public static void getFile(String path,String suffix) {
        File f = new File(path);
        File[] listFile = f.listFiles();
        for (File file : listFile) {
　　　　　　　//除了判断后缀，还要判断是不是文件,有大写文件的话，转为小写
            if(file.isFile() && file.getName().toLowerCase().endsWith(suffix)) {
                System.out.println(file.getAbsolutePath());
            }
        }
    }
}

法二（使用过滤器）

public class FindFile {
    public static void main(String[] args) {
        getFile("E:\\exercise",".jpg");
    }
    public static void getFile(String path,String suffix) {
        File f = new File(path);
　　　　　// 带有过滤器为参数的listFiles方法，这里使用了匿名函数来创建过滤器对象
        File[] files = f.listFiles(new FilenameFilter() {
            @Override
            public boolean accept(File dir, String name) {
                File f1 = new File(dir,name);
                if(f1.isFile()&&f1.getName().toLowerCase().endsWith(suffix)) {
                    return true;
                }
                return false;
            }
        });
        for (File file : files) {
            System.out.println(file.getAbsolutePath());
        }
    }
}

 2. 递归

 2.1 递归的思想概述

　　方法定义中调用本身的现象。

注意事项：

　　递归要有出口，否则就是死递归；次数不能太多，否则内存会溢出；构造方法不能递归使用

2.2 递归的思想

　　找到出口；找到规律

2.3 递归练习

1. 有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到三个月后每个月又生一对兔子，假如兔子都不死，问第十个月兔子对数为多少？

本题的本质是斐波那契数列，如下图：

第一个月时，有一对兔子（刚生下来为小兔子，过了一个月后就变成大兔子，再过一个月就能生小兔子），第二个月是总的兔子数还是为1，但此时小兔子变成了大兔子，第三个月大兔子生了一对小兔子，所以第三个月有2对兔子（一大一小），依次类推下去可得斐波那契数列（正如图上的sum行）

public class BornRabbit {
    public static void main(String[] args) {
        System.out.println("10个月后兔子对数："+ rabbitNumber(10));
    }
    public static int rabbitNumber(int month) {
        if(month==1 || month==2) {
            return 1;
        }else {
            return rabbitNumber(month-1)+rabbitNumber(month-2);
        }
    }
}

2.小猴子第一天摘下若干桃子，当即吃掉一半，又多吃一个，第二天早上又将剩下的桃子吃掉一半，又多吃一个，以后每天早上吃前一天剩下的一半以及另一个。到第10天早上猴子想再吃时发现，只剩下一个桃子了，问第一天猴子共摘了多少个桃子？

规律如下图

public class Monkey {
    public static void main(String[] args) {
        System.out.println(eatPeach(1));
    }
    public static int eatPeach(int day) {
        if(day==10) {
            return 1;
        }else {
            return 2*(eatPeach(day+1)+1);
        }
    }
}

3. 递归查找文件（文件夹有多层）

public class RecursionFindFiles {
    public static void main(String[] args) {
        findAllFiles("E:/exercise",".jpg");
    }
    public static void findAllFiles(String path, String suffix) {
        File f = new File(path);
        //如果传入的路径为文件
        if(f.isFile()) {
            if(f.getName().toLowerCase().endsWith(suffix));{
                System.out.println(f.getAbsolutePath());
            }
        }else {   //是文件
            //获取所有子文件
            File[] listFiles = f.listFiles();
            if(listFiles!=null && listFiles.length>0) {
                for (File file : listFiles) {
                    findAllFiles(file.getAbsolutePath(),suffix);
                }
            }
        }
    }
}

变形：递归删除文件夹以及其中的所有文件

public class RecursionDelete {
    public static void main(String[] args) {
        findAllFiles("E:/a");
    }
    public static void findAllFiles(String path) {
        File f = new File(path);
        //如果传入的路径为文件
        if(f.isFile()) {
            f.delete();
        }else {   //是文件
            //获取所有子文件
            File[] listFiles = f.listFiles();
            if(listFiles!=null && listFiles.length>0) {
                for (File file : listFiles) {
                    findAllFiles(file.getAbsolutePath());
                }
            }
            f.delete();
        }
    }
}

3. IO流

3.1 IO流的概述

IO流用来处理设备之间的数据传输（上传文件和下载文件），Java对数据的操作是通过流的方式，此外java用于流的操作对象都在IO包中

3.2 IO流的分类

（1）按照数据流向

　　输入流： 读入数据

　　输出流：写出数据

（2）按照数据类型

　　字节流，字符流

　　一个汉字若按字节流处理，需要处理3次（utf8编码中一个汉字3个字节），若用字符流来处理只需要一次，但字符流一般只能用来处理文本文件，如图片就不能处理，但字节流（任何文件都可以处理）可以，所以字节流较字符流使用范围更广

（3）什么情况下使用哪种流呢？

　　如果数据所在的文件通过windows自带的记事本打开并能读里面的内容，就用字符流。其他用字节流

3.3 IO流常用基类

（1）字节流的抽象基类：

　　InputStream，OutputStream

（2）字符流的抽象基类

　　Reader  ，     Writer

注意：由这四个类派生出来的子类名称都是以其父类名作为类名的后缀

如：InputStream的子类FileInputStream

　　Reader的子类FileReader

3.4 字节流写数据（FileOutputStream）

3.41 FileOutputStream的构造方法：

（1）FileOutputStream（File, file）

（2）FileOutputStream（String name）   //一般用第二种，方便点

3.4.2  FileOutputStream的成员方法

（1）public void write(int b)

（2）public void write(byte[ ] b)

（3）public void write(byte[ ] b，int  off, int len)　　

public class FileOutputStreamDemo {
    public static void main(String[] args) {
        FileOutputStream fos = null;
        try {
            fos = new FileOutputStream("d:/haha.txt");
            fos.write(97);
            fos.write(98);
            fos.write(99);
        } catch (Exception e) {
            e.printStackTrace();
        }finally {   // 关流，即关闭文件
            if(fos != null) {  //此处要判断下不为null
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
运行结果：d盘中的haha.txt写入了abc

但是怎样写入一字符串呢？=====>将字符串转成Byte，改用第二或第三个成员方法

fos.write("忽然就流出泪来".getBytes());//此代码紧接着fos.write(99)哪行写
fos.write("哈哈忽然间想要听到他的声音".getBytes(),6,33);//后面两个int值第一个为偏移量，第二个为从偏移量位置开始写入数据的长度，这里长度以Byte为单位

运行结果：abc忽然就流出泪来，忽然间想要听到她的声音

有上面代码可知，手动关流写起来比较麻烦，JDK1.7以后提供了自动关流的方法，格式如下：

try(流的定义语句){

}catch(){

}

注意：另外创建一个流，并将数据写入原先有数据的文件，会将原先的数据覆盖掉）（如上面例子中haha.txt原先若有内容则会覆盖掉），但一个流中依次写入的数据，后者写入不会覆盖前者写入的数据

让其不覆盖院线数据的方法是：在利用构造方法创建对象时传两个参数，除了路径再传个True(默认是false)，这样就不会覆盖原先的数据了

当将上诉第5行代码换成如下代码时，运行多次程序，会得到多句同样的结果，不会覆盖（原先无论运行几次都是一句话）

fos = new FileOutputStream("d:/haha.txt",true);

3.5 字节流读取数据（FileInputStream）

3.5.1  FileInputStream的构造方法

（1）FileInputStream（File file）

（2）FileInputStream（String）  //一般用第二种，方便点

3.5.1  FileInputStream的成员方法

（1）public int read()         每次读取一个字节并 返回读取一个字节所对应的编码

（2）public int read(byte[] b)   ：每次读取数组的长度个字节，返回读回来的长度（实际读取的内容）

第二个成员方法返回的是buffer（缓存区）  b的长度

 1 public class FileInputStreamDemo {
 2     public static void main(String[] args) {
 3         try(
 4                 FileInputStream fis = new FileInputStream("d:/a.txt"); //啊的内容为 ab
 5                 ){
 6             System.out.println(fis.read()); //97
 7             System.out.println(fis.read());//98
 8             System.out.println(fis.read());//-1 可见当没内容可读取的时候，返回的是-1
 9         } catch (Exception e) {
10             e.printStackTrace();
11         }
12     }
13 }

若将a.txt的内容改为abc大，那么这个中文字“大”怎么读取出来呢？，代码如下

在上面第8行代码后加如下代码

1     int d = fis.read();
2     int e = fis.read();
3     int f = fis.read();
4     // 创建一个Bytes数组，将上面三个字节平成一个byte数组
5     byte[] bs = new byte[] {(byte)d,(byte)e,(byte)f};
6     System.out.println(bs);//[B@279f2327
7     System.out.println(new String(bs));//大

这样一个字节一个字节读取很费经，可以直接1kb的读取，要想1字节的话可以用for循环读取，循环控制条件就是读取数据返回值为-1

若a文件内容还是为”abc大"，这次换成一次性读取1kb，代码如下

public class FileInputStreamDemo {
    public static void main(String[] args) {
        try(
                FileInputStream fis = new FileInputStream("d:/a.txt"); //啊的内容为 ab
                ){
            System.out.println(fis.read()); //97
            System.out.println(fis.read());//98
            System.out.println(fis.read());//99
            byte[] bs1 = new byte[1024]; //数组在每个位置的默认值为0，转为字符串就是空格
            fis.read(bs1);
            System.out.println(new String(bs1)); //将byte数组转为字符串打印出来
            System.out.println(new String(bs1).length());//1022 字符串的长度，说明其将空格也读取出来了
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

字符串长度为1022的由来：空格长度为1024-3=1021，一个汉字（大）长度为1，所以字符串长度为1022+1=1023

怎样让其读取的内容为实际的长度呢？======>让第二个成员方法接收返回值,其返回的是真实的长度

如将上面代码fis.read(bs1)改为System.out.println(fis.read(bs1)),打印的结果为3，可见返回的是真实读取的字节数

下例中把文件的内容为：没有人在热河里谈恋爱

public class FileInputStreamDemo1 {
    public static void main(String[] args) {
        try(
                FileInputStream fis = new FileInputStream("d:/b.txt"); //啊的内容为 ab
                ){
            byte[] bs1 = new byte[1024];
            int len;
            while((len = fis.read(bs1))!=-1) {
                System.out.println(new String(bs1,0,len));//没有人在热河里谈恋爱
                System.out.println(new String(bs1,0,len).length());//10
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

由结果可知，读取的内容是实际的长度，并不会将空格也读出来

拷贝文件，比如将"E:/exercise/haha/天空之城.jpg"拷贝到"E:/exercise/haha/热河.jpg"

public class CopyFile {
    public static void main(String[] args) {
        try(
                FileInputStream fis = new FileInputStream("E:/exercise/haha/天空之城.jpg");
                FileOutputStream fos = new FileOutputStream("E:/exercise/haha/热河.jpg");
                ) {
            byte[] bs = new byte[1024];
            int len;
            while((len = fis.read(bs)) != -1) {  //读取数据，当返回值为-1时，表示读取完毕
                fos.write(bs,0,len);  //写入
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}