JAVA进阶学习12

一、File类

File对象主要是为了对文件进行简单的处理和存储

1.1 File对象的构造

构造File对象的时候既可以有路径，也可以没有

public static void main(String[] args) {
        //1.根据字符串表示的路径，变成File对象
        String str = "C:\\Users\\Desktop\\a.txt";
        File f1 = new File(str);
        System.out.println(f1);//C:\Users\Desktop\a.txt

        //2.父级路径：C:\Users\Desktop
        //子级路径：a.txt
        String parent = "C:\\Users\\Desktop";
        String child = "a.txt";
        File f2 = new File(parent,child);
        System.out.println(f2);//C:\Users\Desktop\a.txt

        File f3 = new File(parent + "\\" + child); //可以替代方法二
        System.out.println(f3);//C:\Users\Desktop\a.txt
        
        //3.把一个File表示的路径和String表示路径进行拼接
        File parent2 = new File("C:\\Users\\Desktop");
        String child2 = "a.txt";
        File f4 = new File(parent2,child2);
        System.out.println(f4);//C:\Users\Desktop\a.txt
    }

注意：此时new只是生成了File对象，还需要用创建方法将其实实在在地创建在电脑的内存中

1.2 File对象的常见方法

判断功能的方法

• public boolean exists() ：此File表示的文件或目录是否实际存在。
• public boolean isDirectory() ：此File表示的是否为目录。
• public boolean isFile() ：此File表示的是否为文件。

方法演示，代码如下：

public class FileIs {
    public static void main(String[] args) {
        File f = new File("d:\\aaa\\bbb.java");
        File f2 = new File("d:\\aaa");
      	// 判断是否存在
        System.out.println("d:\\aaa\\bbb.java 是否存在:"+f.exists()); //d:\aaa\bbb.java 是否存在:true
        System.out.println("d:\\aaa 是否存在:"+f2.exists()); //d:\aaa 是否存在:true
      	// 判断是文件还是目录
        System.out.println("d:\\aaa 文件?:"+f2.isFile()); //d:\aaa 文件?:false
        System.out.println("d:\\aaa 目录?:"+f2.isDirectory()); //d:\aaa 目录?:true
    }
}

获取功能的方法

• public String getAbsolutePath() ：返回此File的绝对路径名字符串。

• public String getPath() ：将此File转换为路径名字符串。

• public String getName() ：返回由此File表示的文件或目录的名称。

• public long length() ：返回由此File表示的文件的长度。

  方法演示，代码如下：

  public class FileGet {
      public static void main(String[] args) {
          File f = new File("d:/aaa/bbb.java");     
          System.out.println("文件绝对路径:"+f.getAbsolutePath()); //文件绝对路径:d:\aaa\bbb.java
          System.out.println("文件构造路径:"+f.getPath()); //文件构造路径:d:\aaa\bbb.java
          System.out.println("文件名称:"+f.getName()); //文件名称:bbb.java
          System.out.println("文件长度:"+f.length()+"字节"); //文件长度:636字节
  
          File f2 = new File("d:/aaa");     
          System.out.println("目录绝对路径:"+f2.getAbsolutePath()); //目录绝对路径:d:\aaa
          System.out.println("目录构造路径:"+f2.getPath()); //目录构造路径:d:\aaa
          System.out.println("目录名称:"+f2.getName()); //目录名称:aaa
  目
          System.out.println("目录长度:"+f2.length()); //目录长度:4096
      }
  }

API中说明：
length()获取文件的大小，单位是字节，该方法不能获取文件夹的大小
getName()的调用者是文件夹返回文件夹的名字，若是文件返回文件名加文件的扩展名

绝对路径和相对路径

• 绝对路径：从盘符开始的路径，这是一个完整的路径。
• 相对路径：相对于项目目录的路径，这是一个便捷的路径，开发中经常使用。

public class FilePath {
    public static void main(String[] args) {
      	// D盘下的bbb.java文件
        File f = new File("D:\\bbb.java");
        System.out.println(f.getAbsolutePath());
      	
		// 项目下的bbb.java文件
        File f2 = new File("bbb.java");
        System.out.println(f2.getAbsolutePath());
    }
}
输出结果：
D:\bbb.java
D:\idea_project_test4\bbb.java

创建删除功能的方法

• public boolean createNewFile() ：当且仅当具有该名称的文件尚不存在时，创建一个新的空文件。
• public boolean delete() ：删除由此File表示的文件或目录。
• public boolean mkdir() ：创建由此File表示的目录。
• public boolean mkdirs() ：创建由此File表示的目录，包括任何必需但不存在的父目录。

方法演示，代码如下：

public class FileCreateDelete {
    public static void main(String[] args) throws IOException {
        // 文件的创建
        File f = new File("aaa.txt");
        System.out.println("是否存在:"+f.exists()); // false
        System.out.println("是否创建:"+f.createNewFile()); // true
        System.out.println("是否存在:"+f.exists()); // true
		
     	// 目录的创建
      	File f2= new File("newDir");	
        System.out.println("是否存在:"+f2.exists());// false
        System.out.println("是否创建:"+f2.mkdir());	// true
        System.out.println("是否存在:"+f2.exists());// true

		// 创建多级目录
      	File f3= new File("newDira\\newDirb");
        System.out.println(f3.mkdir());// false
        File f4= new File("newDira\\newDirb");
        System.out.println(f4.mkdirs());// true
      
      	// 文件的删除
       	System.out.println(f.delete());// true
      
      	// 目录的删除
        System.out.println(f2.delete());// true
        System.out.println(f4.delete());// false
    }
}

注意：

1. createNewFile()：
   如果当前路径的文件不存在创建成功，存在则创建失败
   如果父级路径不存在会产生IOException的异常
   该方法创建的一定是文件，不会是文件夹（可以是一个没有后缀名的文件）
2. mkdir()：
   路径的创建一定是惟一的
   该方法每次只能创建单级文件夹，多级文件夹会创建失败
3. mkdirs()：
   在底层会先尝试创建单级文件夹
4. delete()：
   可以删除文件或文件夹
   如果此File表示目录，则目录必须为空才能删除

1.3 File的常用遍历方法

public static void main(String[] args) {
        //public File[] listFiles()       获取当前该路径下所有内容
        //1.创建File对象
        File f = new File("D:\\aaa");
        //2.listFiles方法
        //作用：获取aaa文件夹里面的所有内容，把所有的内容放到数组中返回
        File[] files = f.listFiles();
        for (File file : files) {
            //file依次表示aaa文件夹里面的每一个文件或者文件夹
            System.out.println(file);
        }
    }

1.4 File获取并遍历的其他方法

  public static void main(String[] args) {

      /*
        public static File[] listRoots()                列出可用的文件系统根
        public String[] list()                          获取当前该路径下所有内容
        public String[] list(FilenameFilter filter)     利用文件名过滤器获取当前该路径下所有内容
        （掌握）public File[] listFiles()                获取当前该路径下所有内容
        public File[] listFiles(FileFilter filter)      利用文件名过滤器获取当前该路径下所有内容
        public File[] listFiles(FilenameFilter filter)  利用文件名过滤器获取当前该路径下所有内容
      */


        //1.listRoots  获取系统中所有的盘符
        File[] arr = File.listRoots();
        System.out.println(Arrays.toString(arr));//[C:\, D:\]

        //2.list()    获取当前该路径下所有内容(仅仅能获取名字)
        File f1 = new File("D:");
        String[] arr2 = f1.list();
        for (String s : arr2) {
            System.out.println(s);
        }
        //注意其返回的是string类型的数组

        //3.list(FilenameFilter filter)  利用文件名过滤器获取当前该路径下所有内容
        //需求：我现在要获取D：\\aaa文件夹里面所有的txt文件
        File f2 = new File("D:\\aaa");
        //accept方法的形参，依次表示aaa老肉肉文件夹里面每一个文件或者文件夹的路径
        //参数一：父级路径
        //参数二：子级路径
        //返回值：如果返回值为true，就表示当前路径保留
        //        如果返回值为false，就表示当前路径舍弃不要
        String[] arr3 = f2.list(new FilenameFilter() {
            @Override
            public boolean accept(File dir, String name) {
                File src = new File(dir,name);
                    return src.isFile() && name.endsWith(".txt");
            }
        });

        System.out.println(Arrays.toString(arr3));
        
    }

1.5 用法举例

1 创建文件

public static void main(String[] args) throws IOException {
        //需求：在当前模块下的aaa文件夹中创建一个a.txt文件

        //1.设置a.txt的父级路径
        File file = new File("myfile\\aaa");
        //2.创建父级路径
        //如果aaa是存在的，那么此时创建失败的。
        //如果aaa是不存在的，那么此时创建成功的。
        file.mkdirs();
        //3.拼接父级路径和子级路径
        File src = new File(file,"a.txt");
        boolean b = src.createNewFile();
        if(b){
            System.out.println("创建成功");
        }else{
            System.out.println("创建失败");
        }

    }

2 判断文件类型

判断当前目录中是否有txt文件
File[] files = file.listFiles();
//遍历数组获取里面的每一个元素
for (File f : files) {
    //f：依次表示aaa文件夹里面每一个文件或者文件夹的路径
    if(f.isFile() && f.getName().endsWith(".txt")){
    	return true;
    }
}

3 删除文件夹的通用方式
前面所讲的delete只能删除空的文件夹或文件

/*
    * 作用：删除src文件夹
    * 参数：要删除的文件夹
    * */
    public static void delete(File src){
        //1.先删除文件夹里面所有的内容
        //进入src
        File[] files = src.listFiles();
        //遍历
        for (File file : files) {
            //判断,如果是文件，删除
            if(file.isFile()){
                file.delete();
            }else {
                //判断,如果是文件夹，就递归
                delete(file);
            }
        }
        //2.当前文件夹为空时，删除自己
        src.delete();

二、IO流

IO流指的是数据的传输流，按照流动的方向，以内存为基准，分为输入input 和输出output ，即流向内存是输入流，流出内存的输出流。
Java中I/O操作主要是指使用java.io包下的内容，进行输入、输出操作。输入也叫做读取数据，输出也叫做作写出数据。

2.1 IO的分类

根据数据的流向分为：输入流和输出流。

• 输入流 ：把数据从其他设备上读取到内存中的流。
• 输出流 ：把数据从内存 中写出到其他设备上的流。

格局数据的类型分为：字节流和字符流。

• 字节流 ：以字节为单位，读写数据的流，针对所有类型的文件。
• 字符流 ：以字符为单位，读写数据的流，针对纯文本文件。
  
  其中的四个蓝框中的类都是抽象类，在使用时常使用其子类

2.2 字节流的方法概述

一切文件在存储时，都是以一个一个的字节二进制数字的形式保存，同理在传输时也是以二进制比特的形式存储的。所以，字节流可以传输任意文件数据。在操作流的时候，我们要时刻明确，无论使用什么样的流对象，底层传输的始终为二进制数据。

2.2.1 FileOutputStream

它是OutputStream的子类，即对该抽象类的具体实现

该类的基础用法

 public static void main(String[] args) throws IOException {
    /*
          字节输出流的细节：
              1.创建字节输出流对象
                    细节1：参数是字符串表示的路径或者是File对象都是可以的
                    细节2：如果文件不存在会创建一个新的文件，但是要保证父级路径是存在的。
                    细节3：如果文件已经存在，则会清空文件
              2.写数据
                    细节：write方法的参数是整数，但是实际上写到本地文件中的是整数在ASCII上对应的字符
                    97-->a                  
              3.释放资源
                    每次使用完流之后都要释放资源,否则该文件会一直被java占用

    */
        //1.创建对象
        FileOutputStream fos = new FileOutputStream("D:\\a.txt");
        //2.写出数据
        fos.write(97);
        fos.write(55);
        //3.释放资源
        fos.close();
        //while(true){}//让程序不断保持运行去看看他的运行情况
    }

FileOutputStream的三种写出方式：

public static void main(String[] args) throws IOException {
        /*
           void write(int b)                       一次写一个字节数据
           void write(byte[] b)                    一次写一个字节数组数据
           void write(byte[] b, int off, int len)  一次写一个字节数组的部分数据
                        数组     起始索引    个数
        */

        //1.创建对象
        FileOutputStream fos = new FileOutputStream("myio\\a.txt");
        //2.写出数据
        fos.write(97); // a
        fos.write(98); // b
        byte[] bytes = {97, 98, 99, 100, 101};
        fos.write(bytes);

        fos.write(bytes,1,2);// b c
        //3.释放资源
        fos.close();
    }

换行和续写

public static void main(String[] args) throws IOException {
        /*
            换行写：
                再次写出一个换行符就可以了
                windows： \r\n回车换行符老肉肉
                Linux:    \n
                Mac:      \r
            细节：/
                在windows操作系统当中，java对回车换行进行了优化。
                虽然完整的是\r\n，但是我们写其中一个\r或者\n，
                java也可以实现换行，因为java在底层会补全。
            续写：
                如果想要续写，打开续写开关即可
                开关位置：创建对象的第二个参数
                默认false：表示关闭续写，此时创建对象会清空文件
                手动传递true：表示打开续写，此时创建对象不会清空文件

        */
        //1.创建对象
        FileOutputStream fos = new FileOutputStream("D:\\a.txt",true);//此处的参数表示追加写
        //2.写出数据
        String str = "zaixiedain";
        byte[] bytes1 = str.getBytes();
        fos.write(bytes1);

        //再次写出一个换行符就可以了
        String wrap = "\r\n";
        byte[] bytes2 = wrap.getBytes();
        fos.write(bytes2);

        String str2 = "666";
        byte[] bytes3 = str2.getBytes();
        fos.write(bytes3);

        //3.释放资源
        fos.close();
    }

2.2.2 FileInputStream

用于将文件中的数据读取出来

基本的文件读取

public static void main(String[] args) throws IOException {
        /*
         * 实现步骤：
         *       创建对象
         *       读取数据
         *       释放资源
         * */      
        //1.创建对象
        FileInputStream fis = new FileInputStream("myio\\a.txt");
        //2.读取数据
        int b1 = fis.read();
        System.out.println((char)b1);
        int b2 = fis.read();
        System.out.println((char)b2);
        int b3 = fis.read();
        System.out.println((char)b3);
        int b4 = fis.read();
        System.out.println((char)b4);
        int b5 = fis.read();
        System.out.println((char)b5);
        int b6 = fis.read();//当读到的数据为空时返回-1
        System.out.println(b6);//-1
        //3.释放资源
        fis.close();
    }

注意：

1. 如果文件不存在，在读取时会直接报错
2. 每次读取一个字符，读完后指针自动后移，读到空时返回-1

循环读取

int b;//此处需要自定义一个第三方变量记录读取的值
while ((b = fis.read()) != -1) {
      System.out.println((char) b);
}

如果在程序中同时开启多个流进行操作，一般先创建的流最后释放

IO流的多行读取
在读取时一次可以进行多行的读取，增加读写的速度（含参的读对象）

//1.创建对象
FileInputStream fis = new FileInputStream("myio\\a.txt");
//2.读取数据
byte[] bytes = new byte[2];
//一次读取多个字节数据，具体读多少，跟数组的长度有关
//返回值：本次读取到了多少个字节数据
int len = fis.read(bytes);
System.out.println(len);//2
String str1 = new String(bytes,0,len);
System.out.println(str1);