04_IO流（1）：节点流——第一遍扫盲式笔记整理

碎碎念

      内容基本是尚硅谷的视频笔记和ppt内容的整理。叽几的内容只有：蓝色字体的思考分析 + 手写的一些图示。怕涉及到侵权问题，就把链接放在开头高亮！！链接：https://pan.baidu.com/s/1fJIiEhG-NCfgWhn-eyRtZA 提取码：dqvy
      这些流好多，有点难标标题。。。都不知道怎么分类，脑阔疼…

一、File类

1.概念

      ① Java.io.File类：文件和文件目录路径的抽象表示形式，与平台无关。
      ② File能新建、删除、重命名文件和目录，但File不能访问文件内容本身。如果需要访问文件内容本身，则需要使用输入、输出流。
      ③ 想要在Java程序中表示一个真实存在的文件或目录，那么必须有一个File对象，但是Java程序中的一个File对象，可能没有一个真实存在的文件或目录。
      ④ File对象可以作为参数传递给流的构造器，指明读取或写入的"终点"

2.常用构造器

• public File(String pathname)
        以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
  • 绝对路径：是一个固定的路径,从盘符开始
  • 相对路径：是相对于某个位置开始
• public File(String parent,String child)
        以parent为父路径，child为子路径创建File对象。
• public File(File parent,String child)
        根据一个父File对象和子文件路径创建File对象

注意事项：
      当硬盘中真有一个真实的文件或目录存在时，创建File对象时，各个属性会显式赋值。
      当硬盘中没有真实的文件或目录对应时，那么创建对象时，除了指定的目录和路径之外，其他的属性都是取成员变量的默认值
程序理解：

public void test1(){
        //构造器1
        File file1 = new File("hello.txt");//相对于当前module
        File file2 =  new File("D:\\workspace_idea1\\JavaSenior\\day08\\he.txt");
        System.out.println(file1);
        System.out.println(file2);
        
        //构造器2：
        File file3 = new File("D:\\workspace_idea1","JavaSenior");
        System.out.println(file3);

        //构造器3：
        File file4 = new File(file3,"hi.txt");
        System.out.println(file4);
    }

3.路径分隔符

      ① 路径中的每级目录之间用一个路径分隔符隔开
      ② 路径分隔符和系统有关：
            windows和DOS系统默认使用“\”来表示
            UNIX和URL使用“/”来表示
      ③ JAVA程序支持跨平台运行，因此路径分隔符要慎用。为了解决这个隐患，File类提供了一个常量：public static final String separator。根据操作系统，动态的提供分隔符。
      ④ 举例：

File file1 = new File("d:\\atguigu\\info.txt");
File file2 = new File("d:" + File.separator + "atguigu" + File.separator + "info.txt");
File file3 = new File("d:/atguigu");

4.常用方法

4.1 获取

• public String getAbsolutePath()： 获取绝对路径
• public String getPath() ： 获取路径
• public String getName() ： 获取名称
• public String getParent()： 获取上层文件目录路径。若无，返回null
• public long length() ： 获取文件长度（即：字节数）。不能获取目录的长度。
• public long lastModified() ： 获取最后一次的修改时间，毫秒值

如下两个方法适用于文件目录：

• public String[] list() ： 获取指定目录下的所有文件或者文加粗样式件目录的名称数组
• public File[] listFiles() ： 获取指定目录下的所有文件或者文件目录的File数组

4.2 重命名

• public boolean renameTo(File dest)： 把文件重命名为指定的文件路径
        file1.renameTo(file2)为例：要想保证返回true,需要file1在硬盘中是存在的，且file2不能在硬盘中存在。

4.3 判断

• public boolean isDirectory()： 判断是否是文件目录
• public boolean isFile() ： 判断是否是文件
• public boolean exists() ： 判断是否存在
• public boolean canRead() ： 判断是否可读
• public boolean canWrite() ： 判断是否可写
• public boolean isHidden() ： 判断是否隐藏

4.4 创建

• public boolean createNewFile() ： 创建文件。若文件存在，则不创建，返回false
• public boolean mkdir() ： 创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
• public boolean mkdirs() ： 创建文件目录。如果上层文件目录不存在，一并创建

      注意事项：如果你创建文件或者文件目录没有写盘符路径 ， 那么 ， 默认在项目路径下 。

4.5 删除

• public boolean delete()：删除文件或者文件夹

      注意事项：Java中的删除不走回收站。要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录

5.练习

① 判断指定目录下是否有后缀名为.jpg的文件，如果有，就输出该文件名称。

public class FindJPGFileTest {
	@Test
	public void test1(){
		File srcFile = new File("d:\\code");
		
		String[] fileNames = srcFile.list();
		for(String fileName : fileNames){
			if(fileName.endsWith(".jpg")){
				System.out.println(fileName);
			}
		}
	}
	@Test
	public void test2(){
		File srcFile = new File("d:\\code");
		
		File[] listFiles = srcFile.listFiles();
		for(File file : listFiles){
			if(file.getName().endsWith(".jpg")){
				System.out.println(file.getAbsolutePath());
			}
		}
	}
	/*
	 * File类提供了两个文件过滤器方法
	 * public String[] list(FilenameFilter filter)
	 * public File[] listFiles(FileFilter filter)
	 */
	@Test
	public void test3(){
		File srcFile = new File("d:\\code");
		File[] subFiles = srcFile.listFiles(new FilenameFilter() {
			
			@Override
			public boolean accept(File dir, String name) {
				return name.endsWith(".jpg");
			}
		});
		
		for(File file : subFiles){
			System.out.println(file.getAbsolutePath());
		}
	}
}

② 遍历指定目录所有文件名称，包括子文件目录中的文件。
      拓展1：并计算指定目录占用空间的大小
      拓展2：删除指定文件目录及其下的所有文件

public class ListFilesTest {

	public static void main(String[] args) {
		// 递归:文件目录
		/** 打印出指定目录所有文件名称，包括子文件目录中的文件 */

		// 1.创建目录对象
		File dir = new File("E:\\teach\\01_javaSE\\_尚硅谷Java编程语言\\3_软件");

		// 2.打印目录的子文件
		printSubFile(dir);
	}

	public static void printSubFile(File dir) {
		// 打印目录的子文件
		File[] subfiles = dir.listFiles();

		for (File f : subfiles) {
			if (f.isDirectory()) {// 文件目录
				printSubFile(f);
			} else {// 文件
				System.out.println(f.getAbsolutePath());
			}

		}
	}

	// 方式二：循环实现
	// 列出file目录的下级内容，仅列出一级的话
	// 使用File类的String[] list()比较简单
	public void listSubFiles(File file) {
		if (file.isDirectory()) {
			String[] all = file.list();
			for (String s : all) {
				System.out.println(s);
			}
		} else {
			System.out.println(file + "是文件！");
		}
	}

	// 列出file目录的下级，如果它的下级还是目录，接着列出下级的下级，依次类推
	// 建议使用File类的File[] listFiles()
	public void listAllSubFiles(File file) {
		if (file.isFile()) {
			System.out.println(file);
		} else {
			File[] all = file.listFiles();
			// 如果all[i]是文件，直接打印
			// 如果all[i]是目录，接着再获取它的下一级
			for (File f : all) {
				listAllSubFiles(f);// 递归调用：自己调用自己就叫递归
			}
		}
	}

	// 拓展1：求指定目录所在空间的大小
	// 求任意一个目录的总大小
	public long getDirectorySize(File file) {
		// file是文件，那么直接返回file.length()
		// file是目录，把它的下一级的所有大小加起来就是它的总大小
		long size = 0;
		if (file.isFile()) {
			size += file.length();
		} else {
			File[] all = file.listFiles();// 获取file的下一级
			// 累加all[i]的大小
			for (File f : all) {
				size += getDirectorySize(f);// f的大小;
			}
		}
		return size;
	}

	// 拓展2：删除指定的目录
	public void deleteDirectory(File file) {
		// 如果file是文件，直接delete
		// 如果file是目录，先把它的下一级干掉，然后删除自己
		if (file.isDirectory()) {
			File[] all = file.listFiles();
			// 循环删除的是file的下一级
			for (File f : all) {// f代表file的每一个下级
				deleteDirectory(f);
			}
		}
		// 删除自己
		file.delete();
	}
}

二、IO流原理及流的分类

1.原理

      ① I/O是Input/Output的缩写， I/O技术是非常实用的技术，用于处理设备之间的数据传输。如读/写文件，网络通讯等。
      ② Java程序中，对于数据的输入/输出操作以 “流(stream)” 的方式进行。
      ③ java.io包下提供了各种“流”类和接口，用以获取不同种类的数据，并通过标准的方法输入或输出数据。
      ④ 输入input： 读取外部数据（磁盘、光盘等存储设备的数据）到程序（内存）中。
      ⑤ 输出output： 将程序（内存）数据输出到磁盘、光盘等存储设备中。

2.分类

• 按操作数据单位不同分为：字节流（8 bit），字符流（16 bit）
• 按数据流的流向不同分为：输入流，输出流
• 按流的角色的不同分为：节点流，处理流

抽象基类	字节流	字符流
输入流	InputStream	Reader
输出流	OutoutStream	Writer

① Java的IO流共涉及40多个类，实际上非常规则，都是从4个抽象基类派生的。
② 由这四个类派生出来的子类名称都是以其父类名作为子类名后缀

3.节点流和处理流

• ① 节点流： 直接从数据源或目的地读写数据
• ② 处理流： 不直接连接到数据源或目的地，而是“连接”在已存在的流（节点流或处理流）之上，通过对数据的处理为程序提供更为强大的读写功能。

4.输入流和输出流

4.1 输入流

• InputStream 和 Reader 是所有输入流的基类。
• InputStream（典型实现：FileInputStream）；
  • int read()
  • int read(byte[] b)
  • int read(byte[] b, int off, int len)
• Reader（典型实现：FileReader）
  • int read()
  • int read(char [] c)
  • int read(char [] c, int off, int len)
• 程序中打开的文件 IO 资源不属于内存里的资源，垃圾回收机制无法回收该资源，所以应该显式关闭文件 IO 资源。
• FileInputStream 从文件系统中的某个文件中获得输入字节。FileInputStream用于读取非文本数据之类的原始字节流。要读取字符流，需要使用 FileReader。

① InputStream

• int read()：
  从输入流中读取数据的下一个字节。返回 0 到 255 范围内的 int 字节值。如果因为已经到达流末尾而没有可用的字节，则返回值 -1。
• int read(byte[] b)：
  从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中。如果因为已经到达流末尾而没有可用的字节，则返回值 -1。否则以整数形式返回实际读取的字节数。
• int read(byte[] b, int off,int len)：
  将输入流中最多 len 个数据字节读入 byte 数组。尝试读取 len 个字节，但读取的字节也可能小于该值。以整数形式返回实际读取的字节数。如果因为流位于文件末尾而没有可用的字节，则返回值 -1。
• public void close() throws IOException：
  关闭此输入流并释放与该流关联的所有系统资源。

② Reader

• int read()：
  读取单个字符。作为整数读取的字符，范围在 0 到 65535 之间 (0x00-0xffff)（2个字节的Unicode码），如果已到达流的末尾，则返回 -1
• int read(char[] cbuf)：
  将字符读入数组。如果已到达流的末尾，则返回 -1。否则返回本次读取的字符数。
• int read(char[] cbuf,int off,int len)：
  将字符读入数组的某一部分。存到数组cbuf中，从off处开始存储，最多读len个字符。如果已到达流的末尾，则返回 -1。否则返回本次读取的字符数。
• public void close() throws IOException：
  关闭此输入流并释放与该流关联的所有系统资源。

4.2 输出流

• OutputStream 和 Writer 也非常相似：
  • void write(int b/int c);
  • void write(byte[] b/char[] cbuf );
  • void write(byte[] b/char[] buff, int off, int len);
  • void flush();
  • void close(); 需要先刷新，再关闭此流
• 因为字符流直接以字符作为操作单位，所以 Writer 可以用字符串来替换字符数组，即以 String 对象作为参数
  • void write(String str);
  • void write(String str, int off, int len);
• FileOutputStream 从文件系统中的某个文件中获得输出字节。FileOutputStream用于写出非文本数据之类的原始字节流。要写出字符流，需要使用 FileWriter

① OutputStream

• void write(int b)：
  将指定的字节写入此输出流。write 的常规协定是：向输出流写入一个字节。要写入的字节是参数 b 的八个低位。b 的 24 个高位将被忽略。 即写入0~255范围的。
• void write(byte[] b)：
  将 b.length 个字节从指定的 byte 数组写入此输出流。write(b) 的常规协定是：应该与调用 write(b, 0, b.length) 的效果完全相同。
• void write(byte[] b,int off,int len)：
  将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流。
• public void flush()throws IOException：
  刷新此输出流并强制写出所有缓冲的输出字节，调用此方法指示应将这些字节立即写入它们预期的目标。
• public void close() throws IOException：
  关闭此输出流并释放与该流关联的所有系统资源。

② Writer

• void write(int c)：
  写入单个字符。要写入的字符包含在给定整数值的 16 个低位中，16 高位被忽略。 即写入0 到 65535 之间的Unicode码。
• void write(char[] cbuf)：
  写入字符数组。
• void write(char[] cbuf,int off,int len)：
  写入字符数组的某一部分。从off开始，写入len个字符
• void write(String str)：
  写入字符串。
• void write(String str,int off,int len)：
  写入字符串的某一部分。
• void flush()：
  刷新该流的缓冲，则立即将它们写入预期目标。
• public void close() throws IOException：
  关闭此输出流并释放与该流关联的所有系统资源。

三、节点流（或文件流）

1.文件读取（FileReader）

1.1 步骤

① 建立一个流对象，将已存在的一个文件加载进流
② 创建一个临时存放数据的数组。
③ 调用流对象的读取方法将流的数据读入到数组中。
④ 关闭资源

FileReader fr = new FileReader(new File("Test.txt"));//创建对象
char[] ch = new char[1024];//创建临时存放的数组
fr.read(ch);//读入到数组中
fr.close();//关闭资源

1.2 说明

      ① read()的理解： 返回读入的一个字符。如果达到文件末尾，返回-1。
      ② 异常的处理： 为了保证流资源一定可以执行关闭操作。需要使用try-catch-finally处理。
      ③ 读入的文件一定要存在，否则就会报FileNotFoundException。

1.3 读取练习

      ① 问题： 将day09下的hello.txt文件内容（内容为：helloworld123）读入程序中，并输出到控制台
      ② 初始版本程序：一个一个读入

	public void testFileReader(){
        FileReader fr = null;
        '注意点1'：为了保证流资源一定可以执行关闭操作。
        需要使用try-catch-finally处理
        try {
            //1.实例化File类的对象，指明要操作的文件
            File file = new File("hello.txt");//相较于当前Module
            //2.提供具体的流
            fr = new FileReader(file);

            //3.数据的读入
            //read():返回读入的一个字符。如果达到文件末尾，返回-1
            //方式一：一个一个读入
//        int data = fr.read();
//        while(data != -1){
//            System.out.print((char)data);
//            data = fr.read();
//        }

            //方式二：语法上针对于方式一的修改（效率没变，只是代码更简洁）
            int data;
            while((data = fr.read()) != -1){
                System.out.print((char)data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4.流的关闭操作
            '注意点2'：只有当文件不为null时才可以进行关闭，不然会报错，
            所以这里要加if来进行对文件是否为null的判断
//            try {
//                if(fr != null)
//                    fr.close();
//            } catch (IOException e) {
//                e.printStackTrace();
//            }
            //或（if放在try的里面或外面都可以）
            if(fr != null){
                try {
                    fr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

      分析：
      ① 这个版本并不是最好的，对字符一个一个读入，效率很慢。程序上的改进也只是从语法层次上的改进，并没有提高效率
      ② 为了保证流资源一定可以执行关闭操作。需要使用try-catch-finally处理。（如果用throws的话，出现异常，就会向上抛出，后面的部分就不会执行，所以出异常之后，资源就不会被关闭）
      ③ 在finally中要关闭资源。首先要注意，fr.close()本身就会报异常，所以在finally中还要嵌套一个try-catch。其次只有在文件不为null的情况下才可以进行关闭操作，不然会报错，所以这里要加个if来进行对文件是否为null的判断。最后，这个if放在嵌套try-catch的里面或者外面都可以。

      ③ 改进版本：使用read的重载方法

	public void testFileReader1()  {
        FileReader fr = null;
        try {
            //1.File类的实例化
            File file = new File("hello.txt");

            //2.FileReader流的实例化
            fr = new FileReader(file);

            //3.读入的操作
            //read(char[] cbuf):返回每次读入cbuf数组中的字符的个数。如果达到文件末尾，返回-1
            char[] cbuf = new char[5];
            int len;
            while((len = fr.read(cbuf)) != -1){
                //方式一：
                //错误的写法
//                for(int i = 0;i < cbuf.length;i++){
//                    System.out.print(cbuf[i]);
//                }
                //正确的写法
//                for(int i = 0;i < len;i++){
//                    System.out.print(cbuf[i]);
//                }
                //方式二：
                //错误的写法,错误和方式一一样
//                String str = new String(cbuf);
//                System.out.print(str);
                //正确的写法
                String str = new String(cbuf,0,len);
                System.out.print(str);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(fr != null){
                //4.资源的关闭
                try {
                    fr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

      分析：
      ① 在遍历时不能将限制条件写成 i < cbuf.length ，不然的话输出的就是helloworld123ld。所以当改成 i < len 时（len为每次读取的数组的字符的个数），比如最后一次遍历时，读取了三个字符“123”，那么len就为3。
      ② 方式二的错误和方式一相似。String有一个方法，提取从n到m的字符，这里的修改用的就是这个方法。

2.文件写入（FileWriter）

2.1 步骤

① 创建流对象，建立数据存放文件
② 调用流对象的写入方法，将数据写入流
③ 关闭流资源，并将流中的数据清空到文件中

 FileWriter fw = new FileWriter(new File(“Test.txt”));
 fw.write(“atguigu-songhongkang”);
 fw.close();

2.2 说明

① 输出操作，对应的File可以不存在的，并不会报异常
② File对应的硬盘中的文件如果不存在，再输出的过程中，会自动创建此文件。
     File对应的硬盘中的文件如果存在：
            如果流使用构造器是：FileWriter(file,false) / FileWriter(file)——对原有文件的覆盖
            如果流使用的构造器是：FileWriter(file,true)——不会对原有文件覆盖，而是在原有文件基础上追加内容

2.3 写入练习

	public void testFileWriter() {
        FileWriter fw = null;
        try {
            //1.提供File类的对象，指明写出到的文件
            File file = new File("hello1.txt");

            //2.提供FileWriter的对象，用于数据的写出
            fw = new FileWriter(file,false);

            //3.写出的操作
            fw.write("I have a dream!\n");
            fw.write("you need to have a dream!");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4.流资源的关闭
            if(fw != null){
                try {
                    fw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

3.文件的读写（复制）

	public void testFileReaderFileWriter() {
        FileReader fr = null;
        FileWriter fw = null;
        try {
            //1.创建File类的对象，指明读入和写出的文件
            File srcFile = new File("hello.txt");
            File destFile = new File("hello2.txt");

            //不能使用字符流来处理图片等字节数据
//            File srcFile = new File("爱情与友情.jpg");
//            File destFile = new File("爱情与友情1.jpg");

            //2.创建输入流和输出流的对象
            fr = new FileReader(srcFile);
            fw = new FileWriter(destFile);

            //3.数据的读入和写出操作
            char[] cbuf = new char[5];
            int len;//记录每次读入到cbuf数组中的字符的个数
            while((len = fr.read(cbuf)) != -1){
                //每次写出len个字符
                fw.write(cbuf,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4.关闭流资源
            //方式一：这两种方式都可以
//            try {
//                if(fw != null)
//                    fw.close();
//            } catch (IOException e) {
//                e.printStackTrace();
//            }finally{
//                try {
//                    if(fr != null)
//                        fr.close();
//                } catch (IOException e) {
//                    e.printStackTrace();
//                }
//            }
            //方式二：
            try {
                if(fw != null)
                    fw.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
			//谁先关闭没有特殊的说法，建议从后往前，先关写出，再关读取
            try {
                if(fr != null)
                    fr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

4.非文本文件的读写（复制）

4.1 程序实现

    //指定路径下文件的复制
    public void copyFile(String srcPath,String destPath){
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            File srcFile = new File(srcPath);
            File destFile = new File(destPath);

            fis = new FileInputStream(srcFile);
            fos = new FileOutputStream(destFile);

            //复制的过程
            byte[] buffer = new byte[1024];
            int len;
            while((len = fis.read(buffer)) != -1){
                fos.write(buffer,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(fos != null){
                //
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(fis != null){
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    @Test
    public void testCopyFile(){
        long start = System.currentTimeMillis();
        String srcPath = "C:\\Users\\Administrator\\Desktop\\01-视频.avi";
        String destPath = "C:\\Users\\Administrator\\Desktop\\02-视频.avi";
//        String srcPath = "hello.txt";
//        String destPath = "hello3.txt";
// 复制文件其实也行。之前测试不行，是因为在控制台“看了”。此时的字节流就相当于一个搬运工

        copyFile(srcPath,destPath);


        long end = System.currentTimeMillis();

        System.out.println("复制操作花费的时间为：" + (end - start));//618

    }

4.2 方法

• 基本步骤和文本文件的读取一样，不再重复
• 对于文本文件(.txt,.java,.c,.cpp)，使用字符流处理：FileReader，FileWriter（如果这个文本文件只是想复制，用字节流也可以，只要不在内存层面（控制台）去“看”，只是做“搬运工”，在内存层面看过之后就会乱码）
• 对于非文本文件(.jpg,.mp3,.mp4,.avi,.doc,.ppt,…)，使用字节流处理：FileInputStream，FileOutputStream（不管什么时候，对于非文本文件都不能用字符流）有点绕，明天看一下

5.总结

• 定义文件路径时，注意：可以用“/”或者“\”。
• 在写入一个文件时，如果使用构造器FileOutputStream(file)，则目录下有同名文件将被覆盖。
• 如果使用构造器FileOutputStream(file,true)，则目录下的同名文件不会被覆盖，在文件内容末尾追加内容。
• 在读取文件时，必须保证该文件已存在，否则报异常。
• 字节流操作字节，比如：.mp3，.avi，.rmvb，mp4，.jpg，.doc，.ppt
• 字符流操作字符，只能操作普通文本文件。最常见的文本文
  件：.txt，.java，.c，.cpp等语言的源代码。尤其注意.doc,excel,ppt这些不是文本文件。