JAVASE基础学习第八天

今天学习了File类，递归，IO流（没学完），都不是很难把常用的方法敲一遍就好了

时间: 2022/4/21

File类

构造方法：

方法	说明
public File(String pathname)	指定路径名创建File对象
public File(String parent, String child)	指定父路径和子路径
public File(File parent, String child)	指定父路径和子路径

    public static void main(String[] args) {
        File f1 = new File("D:\\录屏\\测试目录\\test.txt");
        System.out.println(f1);
        File f2 = new File("D:\\录屏\\测试目录", "test.txt");
        System.out.println(f2);
        File f3 = new File("D:\\录屏\\测试目录");
        File f4 = new File(f3, "test.txt");
        System.out.println(f4);
        //打印结果：
       // D:\录屏\测试目录\test.txt
       // D:\录屏\测试目录\test.txt
       // D:\录屏\测试目录\test.txt
    }

绝对路径与相对路径：

绝对路径：
从盘符开始一级一级写的路径就是绝对路径。
如：D:\录屏\测试目录\test.txt
相对路径:
不从盘符开始写的路径就是相对路径，相对路径指的是idea项目！！
因为相对路径是在当前项目下找,所以只有当前项目下文件或文件夹才能使用相对路径
如下图：“day20\abc.txt”

常用方法1：

方法	说明
length()	获取文件的大小(这个方法只能获取文件的大小,不能获取文件夹的大小)
getAbsolutePath()	获取绝对路径
getName()	获取名称

    public static void main(String[] args) {
        File f1 = new File("day20\\abc.txt");
        System.out.println(f1);
        String name = f1.getName();
        System.out.println(name);
        String absolutePath = f1.getAbsolutePath();
        System.out.println(absolutePath);
        long length = f1.length();
        System.out.println(length);
    }
    //结果如下：
   // day20\abc.txt
   // abc.txt
   // E:\JAVAWebExample\javaSimple\day20\abc.txt
   // 2
   //abc.txt文件内如如下
    //ab

常用方法2：

方法	说明
exists()	判断对象的路径是否存在
isFile()	判断对象是否是一个文件
isDirectory()	判断对象是否是一个文件夹

返回值都是布尔类型

    public static void main(String[] args) {
        File f1 = new File("day20\\abc.txt");
          if (f1.exists()){
              System.out.println("存在");
          }else {
              System.out.println("不存在");
          }
        if (f1.isFile()){
            System.out.println("是文件");
        }else {
            System.out.println("不是文件");
        }
        if (f1.isDirectory()){
            System.out.println("是文件夹");
        }else {
            System.out.println("不是文件夹");
        }
    }
    //结果如下:
    //存在
    //是文件
    //不是文件夹

常用方法3：

方法	说明
*createNewFile()	创建一个新文件(方法异常需要抛出或者try…catch) ,创建重名的文件会显示false
*delete()	删除一个文件或空文件夹(不能删除非空文件夹)
mkdir()	创建一层文件夹
*mkdirs()	创建任意层文件夹

返回值都是布尔类型

  public static void main(String[] args) throws IOException {
        File f1 = new File("day20\\abc.txt");
        boolean newFile = f1.createNewFile();
        System.out.println(newFile);
        boolean delete = f1.delete();
        System.out.println(delete);
        File f2 = new File("day20\\my\\you");
        boolean mkdir = f2.mkdir();
        System.out.println(mkdir);
        boolean mkdirs = f2.mkdirs();
        System.out.println(mkdirs);
        //结果:
	    // true
	    // true
	     //false
	     // true
    }

mkdir()和mkdirs()区别如下：
mkdirs()可以建立多级文件夹， mkdir()只会建立一级的文件夹
如下：
new File(“day20\my\you”).mkdirs();
执行后， 会建立day20/my/you三级目录
new File(“day20\my\you”).mkdir();
则不会建立任何目录， 因为找不到day20/my/you目录， 结果返回false
常用方法4：

方法	说明
list()	获取文件夹里面所有内容的名称,返回的是String[]（名称）
listFiles()	获取文件夹里面所有的内容,返回的是File[] (路径)

    public static void main(String[] args) throws IOException {
        File f1 = new File("day20\\my");
        String[] list = f1.list();
        for (String s : list) {
            System.out.println(s);
        }
        File[] f2 = f1.listFiles();
        for (File file : f2) {
            System.out.println(file);
        }
    }
    //结果如下
	//a.txt
	//you
	//day20\my\a.txt
	//day20\my\you

递归

递归是一种算法。用来解决把大问题拆成同类型的小问题的情况,java中递归必须要有结束。

java中递归就是方法调用方法自己本身。
演示5的阶乘:

 public static void main(String[] args) {
        //求5的阶乘,递归是用方法自己调用自己,需要调用方法,我们就得定义一个方法
        int i = qiuJieCheng(5);
        System.out.println(i);
    }
    //定义一个方法 求数字的阶乘
    //参数代表要求几的阶乘
    //返回值代表结果
    public static int qiuJieCheng(int n){
        //不考虑负数,咱们只考虑大于1的数字
        //1的阶乘是1自己
        if(n==1){
            return 1;
        }
        //如何去求n-1的阶乘? 我现在定义的方法就是求阶乘的方法,所以直接调用自己方法就可以了
        int i = qiuJieCheng(n - 1);
        //n的阶乘就是 n * n-1的阶乘
        return n * i;
    }

图解如下：

演示删除文件夹和文件:
注意此删除不走回收站，删完就没了

    public static void main(String[] args) throws IOException {
        File file = new File("C:\\Users\\10857\\Desktop\\测试目录");
        System.out.println(file);
        deleteFile(file);
    }
    public static void deleteFile(File file) {
        File[] files = file.listFiles();
        for (File f1 : files) {
            if (f1.isFile()){
                f1.delete();
            }else {
                deleteFile(f1);
            }
        }
        file.delete();
    }

IO流

什么是IO流:
I是in的意思，代表“入”
O是out的意思，代表“出”
IO流可以把数据在内存和硬盘之间传递

IO的分类:
IO流可以按照方向分：
输入和输出
IO流还可以按照类型分:
字节和字符

今天要学习四种流：
输出字节流
输入字节流
输出字符流
输入字符流

字节流:

字节输出流父类OutputStream:

方法	说明
close()	关闭流资源
write(byte[] b)	把字节数组的内容写出到文件中
write(byte[] b, int off, int len)	把字节数组的一部分写出到文件中,off开始索引,len代表写出个数
write(int b)	把一个字节的内容写出到文件中

*文件输出流子类FileOutputStream:

构造方法	说明
public FileOutputStream(File file)	创建字节输出流对象指向一个路径
public FileOutputStream(String name)*	创建字节输出流对象指向一个路径
public FileOutputStream(File file，boolean b)	创建字节输出流对象指向一个路径，true表示续写
public FileOutputStream(String name,boolean b)*	创建字节输出流对象指向一个路径，true表示续写

注意事项：
输出流:
如果文件不存在的话,输出流会自动创建文件
如果文件已存在的话,输出流会覆盖之前的文件
true代表不覆盖之前的文件,续写
所有流:
IO流对象只能指向一个文件,不能指向文件夹(拒绝访问)
字节输入流父类InputStream：

方法	说明
close()	关闭流资源
read()	一次读取一个字节，返回字节的数值
read(byte[] b)	一次读取多个字节，返回读取的字节个数

文件输入流子类FileInputStream：

构造方法	说明
FileInputStream(File file)	创建输入流对象指向一个文件路径
FileInputStream(String name)*	创建输入流对象指向一个文件路径

注意事项：
输入流:
输入流必须要指向一个存在的文件,如果文件不存在就报错(系统找不到指定的文件)
所有流:
IO流对象只能指向一个文件,不能指向文件夹(拒绝访问)

  public static void main(String[] args) throws IOException {

        //创建文件字节输入流
        FileInputStream f = new FileInputStream("C:\\Users\\Administrator\\Desktop\\text.txt");
        //read()一次读取一个字节，返回字节的数值
        /*
             while((i=f.read()) != -1){
             包含了三个步骤:
                1. f.read()读取一个字节
                2. i=f.read()把读到的结果赋值给i
                3. i != -1 判断结果不等于-1
         */
        int i;
        while((i=f.read()) != -1){
            System.out.println(i);
        }

读取多个字节：

    public static void main(String[] args) throws IOException {
        FileInputStream inputStream = new FileInputStream("day20\\abc.txt");
        byte brr[]=new byte[4];
        int i;
        while ((i=inputStream.read(brr)) != -1){
            System.out.println(Arrays.toString(brr));
        }
        inputStream.close();
    }
    //abc.txt内容为：
    //abcde
    //结果为：
   // [97, 98, 99, 100]
    //[101, 98, 99, 100]

注意：
最后的99，100跟上面数组重复，是因为只是在原来的数组进行覆盖。

文件复制：

public static void main(String[] args) throws IOException {
        //创建文件输入流
        FileInputStream f1 = new FileInputStream("C:\\Users\\Administrator\\Desktop\\美女.png");
        //创建文件输出流
        FileOutputStream f2 = new FileOutputStream("E:\\美女.png");
        //使用f1读取  使用f2输出
        //一次读多个字节
        int i;
        byte[] bys = new byte[1024];   //这里数组创建多大都行,一般是创建1024的整数倍
        //注意要把数组放在read()里面
        while((i=f1.read(bys)) != -1){
            f2.write(bys,0,i);
        }
        //关流
        f1.close();
        f2.close();
    }

字符流

跟字节差不多，这里就不演示了 。

只有文本文档才有字符，字符流是专门操作文本的。
比如汉字, 一个汉字字符其实是多个字节,如果使用字节流读取或输出汉字有可能会有乱码,此时我们就要用字符流来操作.
一个字节只能表示-128~127 而汉字有成千上万个,所以一个字节不可能表示一个汉字

字符输入流父类Reader：

方法	说明
close()	关闭流资源
read()	读取一个字符，返回读到的字符值
read(char[] chs)	读取多个字符，返回读到的字符个数

FileReader类：

构造方法	说明
FileReader(File file)	创建字符输入流对象指定文件路径
FileReader(String fileName)	创建字符输入流对象指定文件路径

---

总结

File类方法很多,不用背,但是用的时候你不能看不懂，IO流还是很重要的，要重点理解什么是流入什么是流出。他的方法的使用很简单但是要注意流入是建立在已经存在的文件，但但是流出可以不存在，Java会自动帮忙建立，要是写true不会覆盖会续写，注意他们都不能是文件夹。