第十三周笔记

1. File类

• java.io.File类是文件和目录途径名的抽象表示，主要用于文件和目录的创建，查找和删除等操作。

• java把电脑中的文件和文件夹（目录）封装为了一个File类，我们可以使用File类对文件和文件夹进行操作。

• File类是一个与系统无关的类，任何的操作系统都可以使用这个类中的方法。

file：文件
directory：文件夹/目录
path：路径

1.1 File类的静态成员变量

static String pathSeparator： 与系统有关的路径分隔符，为了方便，它被表示为一个字符串；
static char pathSeparatorChar： 与系统有关的路径分隔符。

static String separator： 与系统有关的默认名称分隔符，为了方便，它被表示为一个字符串；
static char separatorChar： 与系统有关的默认名称分隔符。

public class Demo01File {
    public static void main(String[] args) {
        String pathSeparator = File.pathSeparator;
        System.out.println(pathSeparator);  //路径分隔符 Windows：分号； Linux：冒号：

        String separator = File.separator;
        System.out.println(separator);     //文件名称分隔符 Windows：反斜杠\ Linux：正斜杠/
    }
}

操作路径： 路径不能写死了。
Windows：C:\develop\a\a.txt
Linux：C:/develop/a/a.txt
通用：“C:” + File.separator + “develop” + File.separator + “a” + File.separator + “a.txt”

1.2 绝对路径和相对路径

绝对路径： 一个完整的路径，以盘符开始的路径。
相对路径： 一个简化的路径，相对指的是相对于当前项目的根目录，如果使用当前项目的根目录，就可以简化书写。

注意：

1. 路径不区分大小；
2. 路径中的文件名称分隔符Windows使用反斜杠，反斜杠是转义字符，两个反斜杠代表一个普通的反斜杠。

1.3 File类的构造方法

1. File(String pathname) 通过将给定路径名字符串转换为抽象路径名来创建一个新File实例。
   参数String pathname： 字符串的路径名称，路径可以是以文件结尾，也可以是以文件夹结尾，路径可以是相对路径，也可以是绝对路径，路径可以是存在的，也可以是不存在的，创建File对象，只是把字符串路径封装为File对象，不考虑路径的真假情况。
2. File(String parent, String child) 根据parent路径名和child路径名创建一个新File实例。
   参数： String parent,：父路径 String child：子路径
   好处： 父路径和子路径，可以单独书写，使用起来非常灵活。
3. File(File parent, String child) 根据parent抽象路径名和child路径名创建一个新File实例。
   参数： File parent,：父路径 String child：子路径
   好处： 父路径和子路径，可以单独书写，使用起来非常灵活。父路径是File类型，可以使用File的方法对路径进行一些操作，再使用路径创建对象。

public class Demo02File {
    public static void main(String[] args) {
        demo1();
        demo2("D:\\", "week13");
        demo3();
    }
    public static void demo1(){
        File f1 = new File("D:\\wenjian\\Project01\\src\\week13");
        System.out.println(f1);  //重写了Object类的toString方法,D:\wenjian\Project01\src\week13
    }
    public static void demo2(String parent, String child){
        File f1 = new File(parent, child);
        System.out.println(f1);  //D:\week13
    }
    public static void demo3(){
        File parent = new File("D:\\");
        File f = new File(parent, "week13");
        System.out.println(f); //D:\week13
    }
}

1.4 File类获取功能的方法

• public String getAbsolutePath()：返回此File的绝对路径名字符串；
• public String getPath()：将此File转换为路径名字符串；
• public String getName()：返回由此File表示的文件或目录的名称；
• public long length()：返回由此File表示的文件的长度（指定文件的大小，以字节为单位）。

public class Demo03File {
    public static void main(String[] args) {
        demo1();
        demo2();
        demo3();
        demo4();
    }

    public static void demo1(){
        File f1 = new File("D:\\wenjian\\Project01\\src\\week13");
        String s1 = f1.getAbsolutePath();
        System.out.println(s1);  //D:\wenjian\Project01\src\week13

        File f2 = new File("week13");
        String s2 = f2.getAbsolutePath();
        System.out.println(s2);  //D:\wenjian\Project01\week13
    }

    public static void demo2(){
        File f1 = new File("D:\\wenjian\\Project01\\src\\week13");
        String s1 = f1.getPath();
        System.out.println(s1);  //D:\wenjian\Project01\src\week13

        File f2 = new File("week13");
        String s2 = f2.getPath();
        System.out.println(s2);  //week13
    }

    public static void demo3(){
        File f1 = new File("D:\\wenjian\\Project01\\src\\week13");
        String s1 = f1.getName();
        System.out.println(s1);  //week13

        File f2 = new File("D:\\wenjian\\Project01\\src");
        String s2 = f2.getName();
        System.out.println(s2);  //src
    }

    public static void demo4(){
        File f = new File("D:\\wenjian\\Project01\\src\\week13\\Demo01File.java");
        long l = f.length();
        /*
        注意：
        文件夹是没有大小概念的，不能获取文件夹的大小
        如果构造方法中给出的路径不存在，则返回0
         */
        System.out.println(l);  //433
    }
}

1.5 File类判断功能的方法

• public boolean exists()： 判断此File表示的文件或目录是否实际存在；
• public boolean isDirectory()： 判断此File表示的是否为目录，即判断构造方法中给定的路径是否以文件夹结尾；
• public boolean isFile()： 判断此File表示的是否为文件，即判断构造方法中给定的路径是否以文件结尾。

public class Demo04File {
    public static void main(String[] args) {
        File f1 = new File("D:\\wenjian\\Project01\\src\\week13");
        System.out.println(f1.exists());  //true
        System.out.println(f1.isDirectory());  //true
        //这两个方法的结果互斥，如果路径不存在则都为false
        System.out.println(f1.isFile());  //false
    }
}

1.6 File类类创建删除功能的方法

• public boolean createNewFile() 当且仅当具有该名称的文件不存在时，创建一个新的空文件，此方法只能创建文件，不能创建文件夹，创建文件的目录必须存在，否则会抛出异常；
• public boolean delete() 删除由此File表示的文件或文件夹，如果文件夹中有内容，则不会删除，直接从硬盘中删除，不走回收站；
• public boolean mkdir() 创建由此File表示的文件夹，只能创建单级文件夹，创建文件夹的目录必须存在，否则会抛出异常；
• public boolean mkdirs() 创建由此File表示的文件夹，可以创建多级文件夹，创建文件夹的目录必须存在，否则会抛出异常。

1.7 File类遍历目录功能

• public String[] list()： 返回一个String数组，表示该File目录中所有的子文件或目录；
• public File[] listFiles()： 返回一个File数组，表示该File目录中的所有的子文件或目录。

注意：

1. list和listFiles方法遍历的是构造方法中给出的目录；
2. 如果构造方法中给出的目录的路径不存在，会抛出空指针异常；
3. 如果构造方法中给出的路径不是一个目录，也会抛出空指针异常。

public class Demo05File {
    public static void main(String[] args) {
        File f1 = new File("D:\\wenjian\\Project01\\src\\week13");
        String[] arr = f1.list();
        for (String fileName: arr) {
            System.out.println(fileName);  //打印的是文件名/目录名
        }

        File[] file = f1.listFiles();
        for (File fileName: file) {
            System.out.println(fileName);  //打印的是文件名/目录名的路径
        }
    }
}

1.8 练习—文件搜索

练习：遍历D:\wenjian\Project01\src文件夹，及src文件夹的子文件夹，只要.java结尾的文件

public class FilePractice {
    public static void main(String[] args) {
        File file = new File("D:\\wenjian\\Project01\\src");
        getAllFile(file);
    }
    public static void getAllFile(File file) {
        System.out.println(file);
        File[] files = file.listFiles();
        for (File f: files) {
            if(f.isDirectory()){
                getAllFile(f);
            } else {
                //只要.java结尾的文件
                String s = f.getName();
                Boolean b = s.endsWith(".java");
                if(b) {
                    System.out.println(f);
                }
            }
        }
    }
}

1.9 FileFilter过滤器的原理和使用

我们可以使用过滤器来实现上个练习

File[] listfiles(FileFilter filter)
java.io.FileFilter接口： 用于抽象路径名（File对象）的过滤器；
作用： 用来过滤文件；
方法： boolean accept(File pathname) 测试指定抽象路径名是否应该包含在某个路径名列表中；参数File pathname：使用ListFiles方法遍历目录，得到的每一个文件对象。

File[] listfiles(FilenameFilter filter)
java.io.FilenameFilter接口： 实现此接口的类实例可用于过滤器文件名；
作用： 用来过滤文件名称；
方法： boolean accept(File dir, String name) 测试指定文件是否应该包含在某一文件列表中；参数File dir：构造方法中传递的被遍历的目录， String name：使用ListFiles方法遍历目录，得到的每一个文件/文件夹名称。

注意： 两个过滤器接口是没有实现类的，需要我们自己写实现类，重写过滤的方法accept，在方法中定义自己过滤的规则。

public class FileFilterImpl implements FileFilter {
    @Override
    public boolean accept(File pathname) {
        if(pathname.isDirectory()){
            return true;
        }
        return pathname.getName().endsWith(".java");
    }
}

public class FilePractice {
    public static void main(String[] args) {
        File file = new File("D:\\wenjian\\Project01\\src");
        getAllFile(file);
    }
    public static void getAllFile(File file) {
        System.out.println(file);
        File[] files = file.listFiles(new FileFilterImpl());
        for (File f: files) {
            if(f.isDirectory()){
                getAllFile(f);
            } else {
                System.out.println(f);
            }
        }
    }
}

1.10 FileNameFilter过滤器的使用和Lambda的优化程序

public class FilePractice {
    public static void main(String[] args) {
        File file = new File("D:\\wenjian\\Project01\\src");
        getAllFile(file);
    }
    public static void getAllFile(File file) {
        System.out.println(file);
        /*
        File[] files = file.listFiles(new FileFilter() {
            @Override
            public boolean accept(File pathname) {
                return pathname.getName().endsWith(".java") || pathname.isDirectory();
            }
        });
        //使用Lambda表达式
        File[] files = file.listFiles((pathname) -> pathname.getName().endsWith(".java") || pathname.isDirectory());
        */
        /*
        File[] files = file.listFiles(new FilenameFilter() {
            @Override
            public boolean accept(File dir, String name) {
                return new File(dir, name).isDirectory() || name.endsWith(".java");
            }
        });
        */
        //使用Lambda表达式
        File[] files = file.listFiles((dir,name) -> new File(dir,name).isDirectory() || name.endsWith(".java"));
        for (File f: files) {
            if(f.isDirectory()){
                getAllFile(f);
            } else {
                System.out.println(f);
            }
        }
    }
}

2. IO概述

	输入流	输出流
字节流	InputStream	OutputStream
字符流	Reader	Writer

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

2.1 OutputStream类&FileOutputStream类

java.io.OutputStream抽象类是表示字节输出流的所有类的超类，将指定的字节信息写出到目的地，它定义了字节输出流的基本功性功能方法。

• public void close()： 关闭此输出流并释放与此流相关联的任何系统资源；
• public void flush()： 刷新此输出流并强制任何缓冲的输出字节被写出；
• public void write(byte[] b)： 将b.length字节从指定的字节数组写入此输出流；
• public void write(byte[] b, int off, int len)： 从指定的字节数组写入len字节，从偏移量off开始输出到此输出流；
• public abstract void write(int b)： 将指定的字节输出流。

java.io.FileOutPutStream extends OutputStream

FileOutPutStream： 文件字节输出流。

作用： 把内存中的数据写入到硬盘的文件中。

构造方法：

• FileOutPutStream(String name) 创建一个向具有指定名称的文件写入数据的输出文件流；
• FileOutPutStream(File file) 创建一个向指定File对象表示的文件写入数据的文件输出流。

参数： String name：目的地是一个文件的路径， File file：目的地是一个文件

2.2 字节输出流写入数据到文件

写入数据的原理： （内存->硬盘）
java程序->JVM->OS（操作系统）->OS调用写数据的方法->把数据写入文件中

public class DemoOutPutStream {
    public static void main(String[] args) throws IOException {
        //1. 创建一个FileOutputStream对象，构造方法中传递写入数据的目的地
        FileOutputStream fos = new FileOutputStream("D:\\wenjian\\a.txt");
        //2. 把数据写入文本中
        fos.write(10);
        //3. 释放资源
        fos.close();
    }
}

字节存储的原理和记事本打开文件的原理

2.3 字节输出流写多个字节的方法

一次写多个字节的方法：

• public void write(byte[] b)：将b.length字节从指定的字节数组写入此输出流；
  一次写多个字节，如果第一个字节是正数（0-127），那么显示的时候会查询ASCII表，如果写的第一个字节是负数，那么第一个字节和第二个字节，两个字节组成一个中文显示，查询系统默认码表（GBK）
• public void write(byte[] b, int off, int len)：从指定的字节数组写入len字节，从偏移量off开始输出到此输出流
  int off：数组的开始所以
  int len：写几个字节

public class DemoOutPutStream {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream("D:\\wenjian\\a.txt");
        /*
        //byte[] bytes = {65, 66, 67, 68}; //ABCD
        byte[] bytes = {-65, 66, 67, 68};  //緽CD
        fos.write(bytes);
        //fos.write(bytes, 1, 2);  //BC
        fos.close();
        */
        
		/*
		写入字符的方法：可以使用String类中的方法，把字符串转换为字节数组
		byte[] getBytes() 把字符串转换成字节数组
		*/
		byte[] bytes2 = "你好".getBytes();
        fos.write(bytes2);
        fos.close();
    }
}

2.4 InputStream类&FileInputStream类

java.io.InputStream：字节输入流，此抽象类是表示字节输入流的所有类的超类，定义了所有子类共性的方法。

• public abstract int read()： 从输入流中读取数据的下一个字节；
• public int read(byte[] b)： 从输入流中读取一定数量的字节，并将其存储在缓冲区数组b中；
• public void close()： 关闭此输入流并释放与此相关联的所有系统资源。

java.io.FileInputStream extends InputStream

FileInputStream： 文件字节输入流；
作用： 把硬盘文件中的数据，读取到内存中使用；
构造方法：

• FileInputStream(String name)，String name：文件的路径；
• FileInputStream(File file)，File file：文件。

public class DemoInputStream {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("D:\\wenjian\\a.txt");
        int len = fis.read();
        System.out.println(len);  //65 A
        len = fis.read();
        System.out.println(len);  //66 B
        len = fis.read();
        System.out.println(len);  //67 C
        //读到文件的末尾返回-1
        fis.close();
    }
}

字节输入流一次读取一个字节的原理

字节输入流一次读取多个字节的原理

• public int read(byte[] b)：从输入流中读取一定数量的字节，将其存储在缓存区数组b中

1. 方法的参数byte[]的作用？
   起到缓冲作用，存储每次读取的多个字节，数组的长度一般定义为1024（1kb）或者1024的整数倍。
2. 方法的返回值int是什么？
   每次读取的有效字节个数。

public class DemoInputStream {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("D:\\wenjian\\a.txt");
        /*
        byte[] b = new byte[3];
        int len = fis.read(b);
        System.out.println(len);  //3
        System.out.println(Arrays.toString(b));  //[65, 66, 67]
        System.out.println(new String(b)); //ABC
        fis.close();
        */
		byte[] bytes = new byte[1024];
		int lens = 0;
		while((lens = fis.read(bytes)) != -1){
			System.out.println(new String(bytes, 0, lens));
		}
		fis.close();
    }
}