JavaEE基础第13章IO流

第13章IO流

File类的使用

1.File类的一个对象，代表一个文件或一个文件目录(俗称：文件夹)

2.File类声明在java.io包下

3.File类中涉及到关于文件或文件目录的创建、删除、重命名、修改时间、文件大小等方法，并未涉及到写入或读取文件内容的操作。如果需要读取或写入文件内容，必须使用 IO 流来完成。

4.后续File类的对象常会作为参数传递到流的构造器中，指明读取或写入的“终点”。

使用：

1.如何创建File类的实例

• File(String filePath)
• File(String parentPath,String childPath)
• File(File parentFile,String childPath)

注意实例化只是new一个File的对象，此时还在内存层面，还未在硬盘中创建文件。

2.相对路径：相较于某个路径下，指明的路径

​ 绝对路径：包含盘符在内的文件或文件目录的路径.

说明：

在IDEA中，如果开发使用JUnit中的单元测试方法测试，相对路径即为当前Module下。如果使用main()测试，相对路径即为当前的Project下。（如果文件放在Module下，而使用的又是main()，则相对路径先写指定的Module，找到Module后再在里面找对应的文件。）

究其原因相对路径指的是谁调用的，单元测试方法只在当前Module下生效，而main()在当前Project下都生效。

在Eclipse中：不管使用单元测试方法还是使用main()测试，相对路径都是当前的Project下。

3.路径分隔符：Windows：\ Unix:/ 。但是目前实际上Windows写 / 也可以识别。

• windows和DOS系统默认使用“\”来表示
• UNIX和URL使用“/”来表示

Java程序支持跨平台运行，因此路径分隔符要慎用。
为了解决这个隐患，File类提供了一个常量：
public static final String separator。根据操作系统，动态的提供分隔符。

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

实例化代码示例：

    @Test
    public void test1(){
        //1.如何创建File类的实例
        // File(String filePath)
        // File(String parentPath,String childPath)
        // File(File parentFile,String childPath)

        //2.相对路径：相较于某个路径下，指明的路径
        //  绝对路径：包含盘符在内的文件或文件目录的路径
        File file1 = new File("hello.txt");//(单元测试方法中)相对于当前Module
        //3.路径分隔符：Windows：\\    Unix:/  。但是目前实际上Windows写 / 也可以识别
        File file2 = new File("E:\\workspace\\workspace_base\\Project01\\Senior");
        //创建完对象此时还是在内存层面

        //构造器2：
        File file3 = new File("E:\\workspace\\workspace_base\\Project01","Senior");

        //构造器3
        File file4 = new File(file3,"Senior");
    }

File类常用方法

File类的获取功能

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数组

File file2 = new File("E:\\workspace\\workspace_base\\Project01\\Senior");
        String[] list = file2.list();
        for (String s :
                list) {
            System.out.println(s);
        }

File file2 = new File("E:\\workspace\\workspace_base\\Project01\\Senior");
        File[] files = file2.listFiles();
        for (File f :
                files) {
            System.out.println(f);
        }

File类的重命名功能

public boolean renameTo(File dest):把文件重命名为指定的文件路径

注意是重命名路径也就是说将这个文件移到到另一个路径下。

比如：file1.renameTo(file2)为例,要想保证返回true，需要file1在硬盘中是存在的，且file2不能在硬盘中存在。

    /**
     * public boolean renameTo(File dest):把文件重命名为指定的文件路径
     * 比如：file1.renameTo(file2)为例
     *      要想保证返回true，需要file1在硬盘中是存在的，且file2不能在硬盘中存在。
     */
    @Test
    public void test2(){
        File file1 = new File("hello.txt");
        File file2 = new File("D:\\io\\hi.txt");
        //这样file1就会移动到file2文件目录下，且由于file2是一个文件，那么file1的文件名也会变为file2的文件名
        boolean renameTo = file1.renameTo(file2);
        System.out.println(renameTo);
    }

File类的判断功能

public boolean isDirectory()：判断是否是文件目录
public boolean isFile() ：判断是否是文件
public boolean exists() ：判断是否存在（这里判断是否存在是判断的是否在硬盘上存在。）
public boolean canRead() ：判断是否可读
public boolean canWrite() ：判断是否可写
public boolean isHidden() ：判断是否隐藏

操作文件时最好先通过exists()判断文件是否在硬盘上存在。

File类的创建功能

创建硬盘中对应的文件或文件目录：

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

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

File类的删除功能

删除硬盘中的文件或文件目录：

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

public void test2() throws IOException {
    File file1 = new File("hello.txt");
    if (!file1.exists()){
            //文件的创建
            file1.createNewFile();//需要处理异常
            System.out.println("删除成功");
        }else {
            //删除文件
            file1.delete();
            System.out.println("删除成功");
        }

        //文件目录的创建
        File file3 = new File("d:\\io\\io1\io3");
        //如果此文件目录的上层目录不存在，也不创建。
        boolean mkdir = file3.mkdir();
        if (mkdir){
            System.out.println("创建成功1");
        }

        //如果上层文件目录不存在，一并创建
        boolean mkdirs = file3.mkdirs();
        if (mkdirs){
            System.out.println("创建成功2");
        }


    }

创建对象后属性值的区别

当硬盘中真有一个真实文件或目录存在时，创建File时，各个属性会显式赋值。

当没有真实文件或目录对应时，除了指定的目录和路径外，其他的属性都是取成员变量的默认值。

练习：

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

先利用File类的public String[] list() 获取文件名，再用String类的endwith(String s )方法。

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());
		}
	}
	
}

2.遍历指定目录所有文件名称，包括子文件目录中的文件。
拓展1：并计算指定目录占用空间的大小
拓展2：删除指定文件目录及其下的所有文件（注意删除目录时，目录下面不能有任何内容）

主要思想：递归方法

public class ListFilesTest {

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

		// 1.创建目录对象
		File dir = new File("E:\workspace\workspace_base\Project01\Senior");

		// 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流

IO流概述

输入input：读取外部数据（磁盘、光盘等存储设备的数据）到程序（内存）中。
输出output：将程序（内存）数据输出到磁盘、光盘等存储设备中。

流的分类：

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

其中字节流(0、1代码)适合传输图片，视频…等非文本数据。

字符流(char,2个字节)适合传输文本数据如".txt"…等

直接作用在文件上的流称为节点流；作用在已有的流之上的流称为处理流，处理流可以多层嵌套。

节点流和处理流的区别：

节点流：直接从数据源或目的地读写数据

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

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

(抽象基类)	字节流	字符流
输入流	InputStream	Reader
输出流	OutputStream	Writer

访问文件那一行均为节点流，下面的列均为处理流。

流的结构体系：

抽象基类	节点流(或文件流)	缓冲流(处理流的一种)
InputStream	FileInputStream	BufferedInputStream
OutputStream	FileOutputStream	BufferedOutputStream
Reader	FileReader	BufferedReader
Writer	FileWriter	BufferedWriter

FileReader读入数据的基本操作

将Module下的hello.txt文件内容读入程序中，并输出到控制台

说明点：

1.read()的理解：返回读入的一个字符。如果达到文件的末尾，返回-1

2.异常的处理：为了保证流资源一定可以执行关闭操作。需要使用try-catch-finally处理

3.读入的文件一定要存在，否则就会报FileNotFoundException。

对于流处理异常都需要用try-catch-finally

步骤：

1.实例化File类的对象，指明要操作的文件

2.提供具体的流

3.数据的读入

4.流的关闭操作

    @Test
    public void test1(){
        FileReader fr = null;
        try {
            //1.实例化File类的对象，指明要操作的文件
            File file = new File("hello.txt");//单元测试方法中相较于当前Module
            //2.提供具体的流
            fr = new FileReader(file);
            //3.数据的读入
            //read()：返回读入的一个字符。如果达到文件末尾，返回-1
            //方式一;注意这里面的read可以类比集合中迭代器遍历操作的next()方法
        /*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 {//异常处理要用try-catch-finally，因为流的关闭操作一定要执行，JVM不能自动处理
                    //JVM对其他物理连接，比如数据库连接、输入流输出流、Socket连接无能为力
            //4.流的关闭操作
            /*try {
                //这个判断一定要写，否则可能会报空指针异常。因为前面有可能直接报异常生成异常对象，
                // 程序停止，此时还没有生成字节流对象，不能让其指向关闭操作
                if (fr != null)
                    fr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }*/
            //先try-catch再判断，跟先判断再try-catch没什么区别。
            if (fr != null){
                try {
                    fr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

模板：

    @Test
    public void test2(){
        FileReader fr = null;
        try {
            File file = new File("hello.txt");
            fr = new FileReader(file);
            int data;
            while ((data = fr.read()) != -1) {
                System.out.println((char) data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
        }
        try {
            if (fr != null) 
                fr.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

对read()操作升级：使用read()的重载方法。

前面使用的是read()的空参方法，每次只能读取一个字符，效率太低。使用重载方法，一次读入多个字符。

read()的理解：返回读入的一个字符。如果达到文件的末尾，返回-1

read(char[] cbuf):返回每次读入cbuf数组中字符的个数。如果达到文件末尾，返回-1。

注意两个方法返回值的区别

  //对read()操作升级：使用read()的重载方法。
    @Test
    public void test3() throws FileNotFoundException {
        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]);//HelloWorld123ld
                }*/
                //正确的：这一次读了几个你就遍历几个
                for (int i = 0; i < len; i++) {
                    System.out.print(cbuf[i]);//HelloWorld123
                }

                //方式二：利用字符串，将字符数组转换成字符串
                /*错误的方法，对应着方式一错误的写法
                String str = new String(cbuf);
                System.out.println(cbuf);*/
                //正确的写法
                String str = new String(cbuf,0,len);//将字符数组的从第一个索引位置读到第二个索引位置
                System.out.println(str);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4.资源的关闭
            try {
                if (fr != null)
                    fr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

read(char[] cbuf)传入的是一个参数。意思是每次都将这个数组装满，到文件末尾，如果装不满就将剩下的全部装进去即可。

图解char[]读取数据过程

每次都是将读取的数据去覆盖前面的数据，这就解释了为什么在for循环中的循环条件是i < len ,每次读取几个就遍历几个。

FileWriter写出数据的操作

步骤：

1.提供File类的对象，指明写出到的文件

2.提供FileWriter的对象，用于数据的写出

3.写出的操作

4.流资源的关闭

注意：

1.输出操作，对应的File可以不存在的。并不会报异常

2.File对应的硬盘中的文件如果不存在，在输出的过程中，会自动创建此文件。

​ File对应的硬盘中的文件如果存在：

​ ①如果流使用的构造器是：FileWriter(file,false) / FileWriter(file):对原有文件的覆盖

​ ②如果流使用的构造器是：FileWriter(file,true)：不会对原有文件覆盖，而是在原有文件基础上追加内容

    /*
    从内存中写出数据到硬盘的文件里.
    说明：
    1.输出操作，对应的File可以不存在的。并不会报异常
    2.File对应的硬盘中的文件如果不存在，在输出的过程中，会自动创建此文件。
      File对应的硬盘中的文件如果存在：
        ①如果流使用的构造器是：FileWriter(file,false) / FileWriter(file):对原有文件的覆盖
        ②如果流使用的构造器是：FileWriter(file,true)：不会对原有文件覆盖，而是在原有文件基础上追加内容
     */
    @Test
    public void test4(){
        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 a dream!");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4.流资源的关闭
            try {
                if (fw != null)
                    fw.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

实现文件的复制

使用FileReader和FileWriter实现文件的复制

步骤：

1.创建File类的对象，指明读入和写出的文件

2.创建输入流和输出流的对象

3.数据的读入和写出操作

4.关闭资源流

//使用FileReader和FileWriter实现文件的复制
@Test
public void test5(){
    FileReader fr = null;
    FileWriter fw = null;
    try {
        //1.创建File类的对象，指明读入和写出的文件
        File srcFile = new File("hello.txt");
        File destFile = new File("hello2.txt");
        //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 {
            fw.close();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                fr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }*/
        //方式二
        /*
        这就涉及到对异常处理的理解了
        try-catch是把异常给处理掉了，try-catch外面后面的代码会继续执行。try里面生成异常对象那句代码
        后面的不会再执行，直接进入catch，但是try-catch外面后面的代码会继续执行。
        跟抛出throws不同，throws并不是真正的解决异常，而是抛给调用它的方法去处理。
        生成异常对象后，后续的代码便不会再执行，这就是为什么关闭流资源的代码一定要放在try-catch-finally中
         */
        try {
            fw.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        try {
            fr.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

注意对两个流资源关闭的操作，异常处理部分。

异常处理的理解：

try-catch是把异常给处理掉了，try-catch外面后面的代码会继续执行。try里面生成异常对象那句代码后面的不会再执行，直接进入catch，但是try-catch外面后面的代码会继续执行。跟抛出throws不同，throws并不是真正的解决异常，而是抛给调用它的方法去处理。生成异常对象后，后续的代码便不会再执行，这就是为什么关闭流资源的代码一定要放在try-catch-finally中。

打个比喻：在狼来了的故事中try-catch就好比自己将狼赶跑，throws好比叫来大人帮忙将狼赶跑。

注：不能使用字符流来处理图片等字节数据。

FileInputStream不能读取文本文件的测试

结论：

1.对于文本文件(.txt，.java，.c，.cpp)，使用字符流处理

2.对于非文本文件(.jpg，.mp3，.mp4，.avi，.doc，.ppt，…)，使用字节流处理。(doc算是非文本文件原因是里面可以存放图片等)

补充：如果文本文件只是想复制一份，是可以使用字节流处理的(只要不在内存层面看内容就行)，相当于字节流只是一个搬运工而已。但是非文本文件复制，是不可以使用字符流的。【最好还是处理什么就用对应的。】

使用字符流创建char[] ，使用字节流创建byte[]

使用字节流FileInputStream处理文本文件，可能出现乱码。

如果使用字节流读取文本文件，遇见中文将会出现乱码。原因是英文字母在ASCII码中占8bit，使用字节流也可以读取出来，但是在UTF-8中，中文占3个字节(24bit)，所以读取的时候会出现乱码。总之，不要用字节流去读取文本文件。

FileInputStream和FileOutputStream使用

实现对图片的复制操作:

    //实现对图片的复制操作
    @Test
    public void test6(){
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            //1.实例化文件对象
            File srcFile = new File("图片1.jpg");
            File destFile = new File("图片2.jpg");
            //2.造流
            fis = new FileInputStream(srcFile);
            fos = new FileOutputStream(destFile);
            //3.操作复制的过程
            byte[] buffer = new byte[5];
            int len;
            while ((len = fis.read(buffer)) != -1){
                fos.write(buffer,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4.关闭
            try {
                if (fos != null)
                    fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (fis != null)
                    fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

对复制文件方法的封装：

//对复制文件方法的封装
public void copyFile(String srcPath,String destPath){
    FileInputStream fis = null;
    FileOutputStream fos = null;
    try {
        //1.实例化文件对象
        File srcFile = new File(srcPath);
        File destFile = new File(destPath);
        //2.造流
        fis = new FileInputStream(srcFile);
        fos = new FileOutputStream(destFile);
        //3.操作复制的过程
        byte[] buffer = new byte[5];
        int len;
        while ((len = fis.read(buffer)) != -1){
            fos.write(buffer,0,len);
        }
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        //4.关闭
        try {
            if (fos != null)
                fos.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        try {
            if (fis != null)
                fis.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
//测试
@Test
public void testCopyFile(){

    long start = System.currentTimeMillis();
    String str1 = "1.avi";
    String str2 = "2.avi";
    copyFile(str1,str2);
    long end = System.currentTimeMillis();
    System.out.println(end - start);
}

缓冲流实现非文本复制

处理流之一：缓冲流的使用

1.缓冲流：

• BufferedInputStream

• BufferedOutputStream

• BufferedReader

• BufferedWriter

2.作用：提供流的读取、写入的速度。提高读写速度的原因：内部提供了一个缓冲区 。(BufferedInputStream提供的缓冲区默认大小8192字节)。BufferedOutputStream内部有一个flush()方法可以刷新缓存区。flush()刷新缓冲区。如果不显式调用这个方法，则只有当缓冲区存满时才会刷新缓冲区(清空数据，将数据写入)，但是如果显式的调用这个方法，当执行到这个方法时便会刷新缓冲区，不管满没满都会。

基本上处理输出流中都会有flush()方法，有的处理流没有自动的写flush()就需要我们去写，但是像缓冲流这种自动写了flush()的我们就不需要再写了。

3.处理流，就是”套接“在已有的流的基础上。(已有的流，节点流可以套处理流，处理流还可以套处理流)

步骤：

1.实例化File对象

2.造流。因为处理流是作用在节点流之上的，所以要先有节点流

​ 2.1 造节点流

​ 2.2 造缓冲流

3.操作的实现细节

4.资源关闭。 要求：先关闭外层的流，再关闭内层的流。说明：关闭外层流 的同时，内层流也会自动的进行关闭。关于内层流的关闭，我们可以省略。当然写上是没有错误的。

/**
 * 处理流之一：缓冲流的使用
 * 1.缓冲流：
 * BufferedInputStream
 * BufferedOutputStream
 * BufferedReader
 * BufferedWriter
 *
 * 2.作用：提供流的读取、写入的速度
 *   提高读写速度的原因：内部提供了一个缓冲区 (BufferedInputStream提供的缓冲区默认大小8192字节)
 *   
 */
public class BufferedTest {

    //实现非文本文件的复制
    @Test
    public void test1(){
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;
        try {
            //1.造文件
            File file1 = new File("图片1.jpg");
            File file2 = new File("图片2.jpg");
            //2.造流。因为处理流是作用在节点流之上的，所以要先有节点流
            //2.1 造节点流
            FileInputStream fis = new FileInputStream(file1);
            FileOutputStream fos = new FileOutputStream(file2);
            //2.2 造缓冲流
            bis = new BufferedInputStream(fis);
            bos = new BufferedOutputStream(fos);
            //3.复制的细节
            byte[] buffer = new byte[1024];
            int len;
            while ((len = bis.read(buffer)) != -1){
                bos.write(buffer,0,len);
                    //BufferedOutputStream内部有一个flush()方法
//                bos.flush();//刷新缓冲区。如果不显式调用这个方法，则只有当缓冲区存满时才会刷新缓冲区(清空数据，将数据写入)，
                                //但是如果显式的调用这个方法，当执行到这个方法时便会刷新缓冲区，不管满没满都会

            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4.资源关闭
            //要求：先关闭外层的流，再关闭内层的流
            try {
                if (bos != null)
                    bos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (bis != null)
                    bis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            //说明：关闭外层流 的同时，内层流也会自动的进行关闭。关于内层流的关闭，我们可以省略。当然写上是没有错误的。
//        fos.close();
//        fis.close();
        }
    }
}

调用System.currentTimeMillis()方法比较使用缓冲流和不使用缓冲流复制文件的速度，发现使用缓冲流的速度大大提高。（比较的前提是byte[]数组大小一样。）

缓冲流实现文本复制

使用BufferedReader和BufferedWriter实现文本文件的复制

前面实例化File对象，造节点流，造缓冲流可以写在一起，用匿名类表示。

另外BufferedWriter中除了可以读一个char[]，还有readLine()方法，一次读取一行，到达末尾返回null，且读取内容不包括换行符，需要手动添加换行符"\n" , 或者调用newLine()

    //使用BufferedReader和BufferedWriter实现文本文件的复制
    @Test
    public void test7(){
        BufferedReader br = null;
        BufferedWriter bw = null;
        try {
            //等写熟了之后直接使用匿名类
            br = new BufferedReader(new FileReader(new File("hello.txt")));
            bw = new BufferedWriter(new FileWriter(new File("hello1.txt")));
            //读写操作
            //方式一
            /*char[] cbuf = new char[1024];
            int len;
            while ((len = br.read(cbuf)) != -1){
                bw.write(cbuf,0,len);
                //BufferedReader中缓冲区的大小是8192个char，一个char是2个字节，而在BufferedInputStream中缓冲区大小为8192个字节
    //            bw.flush();//BufferedWriter中有这个方法，不用主动调。
            }*/
            //方式二：BufferedReader还提供了另外的方法
            String data;
            while ((data = br.readLine()) != null){//readLine()一次读一行，读到末尾返回null
                //方法一：
//                bw.write(data + "\n");//data中不包含换行符
                //方法二
                bw.write(data);//data中不包含换行符
                bw.newLine();//提供换行的操作
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //关闭资源
            try {
                if (bw != null)
                    bw.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (br != null)
                    br.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }

总结：

节点流(或文件流)	缓冲流(处理流的一种)
FileInputStream (read(byte[] buffer))	BufferedInputStream (read(byte[] buffer))
FileOutputStream (write(byte[] buffer,0,len))	BufferedOutputStream (write(byte[] buffer,0,len)) / flush()
FileReader (read(char[] cbuf))	BufferedReader ( read(char[] cbuf) / readLine() )
FileWriter (write(char[] cbuf,0,len))	BufferedWriter (write(char[] cbuf,0,len)) / flush()

FileInputStream fis = new FileInputStream(new File("hello.txt"));//构造器FileInputStream(File file)
FileInputStream fis1 = new FileInputStream("hello.txt");//构造器FileInputStream(String name)
//二者都是一样的，第二个也是先把路径转换成文件对象

实现文件的加密操作

练习：实现文件的加密操作（提示：用异或运算。）

图片的加密操作:

    //图片的加密操作
    @Test
    public void test8(){
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            fis = new FileInputStream("图片1.jpg");
            fos = new FileOutputStream("图片3.jpg");

            byte[] buffer = new byte[1024];
            int len;
            while ((len = fis.read(buffer)) != -1){
                //加密操作:需要一个一个字节加密，所以循环实现对字节数组进行修改
                /*
                注意这种写法是错误的，因为foreach是把元素给取出来赋给另一个变量，不能实现对数组本身的修改
                这点需要注意，实现对数组元素的修改，不能使用foreach循环
                for (byte b :
                        buffer) {
                    b = (byte) (b ^ 5);
                }
                 */
                //正确的
                for (int i = 0; i < len; i++) {
                    //byte的范围是-128~127，数组里面存放的也是这些范围，与整型做运算结果为整型，所以需要强转
                    //异或运算，二进制下相同的为0，不同的为1.得到的结果再进行一次异或运算又可以得到原来的值
                    //所以解密代码在这里不需要变。
                    buffer[i] = (byte) (buffer[i] ^ 5);
                }
                fos.write(buffer,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //关闭资源
            try {
                if (fos != null)
                    fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (fis != null)
                    fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

图片的解密操作:

    //图片的解密操作:因为异或运算两次得到的结果跟以前一样，所以核心代码不需要变，只需要将文件路径变一下即可
    //异或运算：比如6 ^ 3 = 5; 5 ^ 3 = 6；又可以得到之前的结果
    @Test
    public void test9(){
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            fis = new FileInputStream("图片3.jpg");
            fos = new FileOutputStream("图片4.jpg");

            byte[] buffer = new byte[1024];
            int len;
            while ((len = fis.read(buffer)) != -1){
                //加密操作:需要一个一个字节加密，所以循环实现对字节数组进行修改
                /*
                注意这种写法是错误的，因为foreach是把元素给取出来赋给另一个变量，不能实现对数组本身的修改
                这点需要注意，实现对数组元素的修改，不能使用foreach循环
                for (byte b :
                        buffer) {
                    b = (byte) (b ^ 5);
                }
                 */
                //正确的
                for (int i = 0; i < len; i++) {
                    //byte的范围是-128~127，数组里面存放的也是这些范围，与整型做运算结果为整型，所以需要强转
                    //异或运算，二进制下相同的为0，不同的为1.得到的结果再进行一次异或运算又可以得到原来的值
                    //所以解密代码在这里不需要变。
                    buffer[i] = (byte) (buffer[i] ^ 5);
                }
                fos.write(buffer,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //关闭资源
            try {
                if (fos != null)
                    fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (fis != null)
                    fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

注意：

1.byte的范围是-128~127，所以byte[]数组存放的数值也是这个范围。类似于int[].

2.foreach循环不能实现对原有数组元素的改变，因为foreach循环是将数组中的元素赋值给一个新的变量，我们用的都是新的变量，做修改也是在新的变量上修改的。

获取文本上每个字符出现的次数

练习：获取文本上每个字符出现的次数。（提示：遍历文本的每一个字符；字符及出现的次数保存在Map中；将Map中数据写入文件）

    /**
     * 练习3:获取文本上字符出现的次数,把数据写入文件
     *
     * 思路：
     * 1.遍历文本每一个字符
     * 2.字符出现的次数存在Map中
     *
     * Map<Character,Integer> map = new HashMap<Character,Integer>();
     * map.put('a',18);
     * map.put('你',2);
     *
     * 3.把map中的数据写入文件
     */

    /*
    说明：如果使用单元测试，文件相对路径为当前module
      如果使用main()测试，文件相对路径为当前工程
    */
    @Test
    public void testWordCount() {
        FileReader fr = null;
        BufferedWriter bw = null;
        try {
            //1.创建Map集合
            Map<Character, Integer> map = new HashMap<Character, Integer>();

            //2.遍历每一个字符,每一个字符出现的次数放到map中
            fr = new FileReader("dbcp.txt");
            int c = 0;
            while ((c = fr.read()) != -1) {
                //int 还原 char
                char ch = (char) c;
                // 判断char是否在map中第一次出现
                if (map.get(ch) == null) {
                    map.put(ch, 1);
                } else {
                    map.put(ch, map.get(ch) + 1);
                }
            }

            //3.把map中数据存在文件count.txt
            //3.1 创建Writer
            bw = new BufferedWriter(new FileWriter("wordcount.txt"));

            //3.2 遍历map,再写入数据
            Set<Map.Entry<Character, Integer>> entrySet = map.entrySet();
            for (Map.Entry<Character, Integer> entry : entrySet) {
                //空格，制表符，回车，换行符对应的ASCII码是不一样的，所以要一一匹配
                switch (entry.getKey()) {
                    case ' ':
                        bw.write("空格=" + entry.getValue());
                        break;
                    case '\t'://\t表示tab 键字符
                        bw.write("tab键=" + entry.getValue());
                        break;
                    case '\r'://
                        bw.write("回车=" + entry.getValue());
                        break;
                    case '\n'://
                        bw.write("换行=" + entry.getValue());
                        break;
                    default:
                        //除了以上四种，其他的都归到这里
                        bw.write(entry.getKey() + "=" + entry.getValue());
                        break;
                }
                bw.newLine();
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4.关流
            if (fr != null) {
                try {
                    fr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }

            }
            if (bw != null) {
                try {
                    bw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }

            }
        }

    }

转换流

本来字节流是不建议处理文本数据的，现在有了转换流，可以将字节流转换为字符流，还可以将字符流转换为字节流。

处理流之二：转换流的使用

1.转换流：属于字符流

​ InputStreamReader:将一个字节的输入流转换为字符的输入流

​ OutputStreamWriter:将一个字符的输出流转换为字节的输出流

从名称的后缀判断是字符流还是字节流。

2.作用：提供字节流与字符流之间的转换

3.解码：字节、字节数组 — > 字符数组、字符串

​ 编码：字符数组、字符串 — > 字节、字节数组

(记住解码是从看不懂的到看的懂的转换；编码是从看的懂的到看不懂的转换。)

编码决定了解码的格式，用什么格式编码，就需要用什么格式解码。

4.字符集

InputStreamReader的使用:

注意构造器中使用哪种字符集。

    //InputStreamReader的使用，实现字节的输入流到字符的输入流的转换
    @Test
    public void test10(){
        InputStreamReader isr = null;
        try {
            FileInputStream fis = new FileInputStream("hello.txt");
            //InputStreamReader isr = new InputStreamReader(fis);//使用系统(IDEA)默认的字符集
            //参数2指明了字符集，具体使用哪个字符集，取决于文件hello.txt保存时使用的字符集
            isr = new InputStreamReader(fis,"UTF-8");
            char[] cbuf = new char[3];
            int len;
            while ((len = isr.read(cbuf)) != -1){
                String str = new String(cbuf,0,len);
                System.out.print(str);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (isr != null)
                    isr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

综合使用InputStreamReader 和OutputStreamWriter

//综合使用InputStreamReader 和OutputStreamWriter
@Test
public void test11(){
    InputStreamReader isr = null;
    OutputStreamWriter osw = null;
    try {
        //实现以UTF-8读文件，GBK写文件
        isr = new InputStreamReader(new FileInputStream("hello.txt"),"UTF-8");
        osw = new OutputStreamWriter(new FileOutputStream("hello_gbk.txt"),"GBK");
        //实现细节
        char[] cbuf = new char[20];
        int len;
        while ((len = isr.read(cbuf)) != -1){
            osw.write(cbuf,0,len);
        }
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        try {
            if (osw != null)
                osw.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        try {
            if (isr != null)
                isr.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

转换流的编码应用：

• 可以将字符按指定编码格式存储
• 可以对文本数据按指定编码格式来解读
• 指定编码表的动作由构造器完成

字符集(了解内容)

编码表的由来：
计算机只能识别二进制数据，早期由来是电信号。为了方便应用计算机，让它可以识别各个国家的文字。就将各个国家的文字用数字来表示，并一一对应，形成一张表。这就是编码表。

常见的编码表：

ASCII：美国标准信息交换码。用一个字节的7位可以表示。
ISO8859-1：拉丁码表。欧洲码表。用一个字节的8位表示。
GB2312：中国的中文编码表。最多两个字节编码所有字符(英文字符还用一个字节表示，中文有的用一个字节表示，有的用两个字节表示)
GBK：中国的中文编码表升级，融合了更多的中文文字符号。最多两个字节编码(英文字符还用一个字节表示，中文有的用一个字节表示，有的用两个字节表示)
Unicode：国际标准码，融合了目前人类使用的所有字符。为每个字符分配唯一的字符码。所有的文字都用两个字节来表示。
UTF-8：变长的编码方式，可用1-4个字节来表示一个字符。

GBK、GB2312等双字节编码方式，用最高位是1或0表示两个字节和一个字节。

Unicode并未真正落地实施。原因Unicode不完美，这里就有三个问题，一个是，我们已经知道，英文字母只用一个字节表示就够了，第二个问题是如何才能区别Unicode和ASCII？计算机怎么知道两个字节表示一个符号，而不是分别表示两个符号呢？第三个，如果和GBK等双字节编码方式一样，用最高位是1或0表示两个字节和一个字节，就少了很多值无法用于表示字符，不够表示所有字符。Unicode在很长一段时间内无法推广，直到互联网的出现。

面向传输的众多 **UTF（UCS Transfer Format）**标准出现了，顾名思义，**UTF-8就是每次8个位传输数据，而UTF-16就是每次16个位。**这是为传输而设计的编码，并使编码无国界，这样就可以显示全世界上所有文化的字符了。

Unicode只是定义了一个庞大的、**全球通用的字符集，**并为每个字符规定了唯一确定的编号，具体存储成什么样的字节流，取决于字符编码方案。推荐的Unicode编码是UTF-8和UTF-16。

UTF-8里中文占三个字节。

ANSI 美国国家标准学会

编码决定了解码的格式，用什么格式编码，就需要用什么格式解码。

客户端/浏览器端<–>后台(java、python…)<—>数据库

要求前前后后使用的字符集都要统一：UTF-8 .

其他流

其他流的使用：

1.标准的输入、输出流

2.打印流

3.数据流

标准的输入、输出流

1.System.in：标准的输入流，默认从键盘输入

System.out：标准的输出流，默认从控制台输出。

​ System.in的类型是InputStream (类型就是返回值的类型)
​ System.out的类型是PrintStream，是FilterOutputStream 的子类，FilterOutputStream又是OutputStream的子类

2.重定向：**通过System类的setIn，setOut方法对默认设备进行改变，**重新指定输入和输出设备。
public static void setIn(InputStream in)
public static void setOut(PrintStream out)

练习：从键盘输入字符串，要求将读取到的整行字符串转成大写输出。然后继续进行输入操作，直至当输入“e”或者“exit”时，退出程序。

方法一：使用Scanner实现，调用next()返回一个字符串

程序中需要注意的点：①字符串判断相同用equals()方法。②为了不出现空指针异常，一般把确定的写前面，变量写后面。“e”.equalsIgnoreCase(str)

/**
 * 从键盘输入字符串，要求将读取到的整行字符串转成大写输出。
 * 然后继续进行输入操作，直至当输入“e”或者“exit”时，退出程序。
 * 方法一：使用Scanner实现，调用next()返回一个字符串
 * 方法二：使用System.in实现。System.in --> 转换流 --> BufferedReader的readLine()
 *          原因System.in返回的是InputStream，是一个字节流，要使用字符流需要先转换
 */

@Test
public void test12(){
    //方法一
    Scanner scanner = new Scanner(System.in);
    while (true){
        System.out.println("请输入要转化为大写的字符串(输入\"e\"或者\"exit\"代表退出程序)：");
        String str = scanner.next();
        //判断字符串相等用equals()
        //为了不出现空指针异常，一般把确定的写前面，变量写后面。
        if ("e".equalsIgnoreCase(str) || "exit".equalsIgnoreCase(str)){//这种方式是最好的
        //if (str.equals("e") || str.equals("exit")){
            System.out.println("退出程序成功！");
            break;
        }
        String toUpperCase = str.toUpperCase();
        System.out.println(toUpperCase);

    }

}

方法二：使用System.in实现。System.in --> 转换流 --> BufferedReader的readLine() 。原因System.in返回的是InputStream，是一个字节流，要使用字符流需要先转换。(注意要使用转换流处理即可)

@Test
public void test13(){
    BufferedReader br = null;
    try {
        //方法二
        InputStreamReader isr = new InputStreamReader(System.in);
        br = new BufferedReader(isr);

        while (true){
            System.out.println("请输入字符串：");
            String str = br.readLine();
            if ("e".equalsIgnoreCase(str) || "exit".equalsIgnoreCase(str)){
                System.out.println("程序结束！");
                break;
            }
            String upperCase = str.toUpperCase();
            System.out.println(upperCase);
        }
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        //关闭资源
        try {
            if (br != null)
                br.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}

练习：Create a program named MyInput.java: Contain the methods for reading int, double, float, boolean, short, byte and String values from the keyboard.

从控制台读取的是字符串类型，要转化为int等需要调用包装类转化为对应的类型。

public class MyInput {
    // Read a string from the keyboard
    public static String readString() {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        // Declare and initialize the string
        String string = "";

        // Get the string from the keyboard
        try {
            string = br.readLine();

        } catch (IOException ex) {
            System.out.println(ex);
        }

        // Return the string obtained from the keyboard
        return string;
    }

    // Read an int value from the keyboard
    public static int readInt() {
        return Integer.parseInt(readString());
    }

    // Read a double value from the keyboard
    public static double readDouble() {
        return Double.parseDouble(readString());
    }

    // Read a byte value from the keyboard
    public static double readByte() {
        return Byte.parseByte(readString());
    }

    // Read a short value from the keyboard
    public static double readShort() {
        return Short.parseShort(readString());
    }

    // Read a long value from the keyboard
    public static double readLong() {
        return Long.parseLong(readString());
    }

    // Read a float value from the keyboard
    public static double readFloat() {
        return Float.parseFloat(readString());
    }
}

解决IDEA中在@Test单元测试方法中无法从控制台输入的问题

Step1 ：Help — > Edit Custom VM Options

Step2：打开后在其中添加

-Deditable.java.test.console=true

Step3：重启IDEA即可

打印流

打印流：PrintStream和PrintWriter 提供了一系列重载的print() 和 println()

作用：实现将基本数据类型的数据格式转化为字符串输出

说明：

• 提供了一系列重载的print()和println()方法，用于多种数据类型的输出
• PrintStream和PrintWriter的输出不会抛出IOException异常
• PrintStream和PrintWriter有自动flush功能
• PrintStream 打印的所有字符都使用平台的默认字符编码转换为字节。在需要写入字符而不是写入字节的情况下，应该使用 PrintWriter 类。
• System.out返回的是PrintStream的实例

    @Test
    public void test14() {
        PrintStream ps = null;
        try {
            FileOutputStream fos = new FileOutputStream(new File("D:\\IO\\text.txt"));
            // 创建打印输出流,设置为自动刷新模式(写入换行符或字节 '\n' 时都会刷新输出缓冲区)
            ps = new PrintStream(fos, true);
            if (ps != null) {// 把标准输出流(控制台输出)改成文件
                System.setOut(ps);
                //修改输出方式
            }
            for (int i = 0; i <= 255; i++) { // 输出ASCII字符
                System.out.print((char) i);
                if (i % 50 == 0) { // 每50个数据一行
                    System.out.println(); // 换行
                }
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } finally {
            if (ps != null) {
                ps.close();
            }
        }
    }

System.out.println()其中System.out返回的是PrintStream，默认是从控制台输出，而println()是将内容转化为字符串进行输出。

调用System类的setOut(PrintStream out)方法改变输出设备。

应用：当想把输出的数据保存下来就可以调用setOut()指定新的输出位置，输出到文件中保存下来。

数据流

1.DataInputStream 和 DataOutputStream

2.作用：用于读取或写出基本数据类型的变量或字符串。 比如说将内存中的变量或字符串写到文件中，或者将文件中存储的基本数据类型变量和字符串读取到内存中，保存在变量中。(所以这个数据流是在内存层面与物理存储层面的交流)

3.应用：将内存中的数据持久化保存在硬盘中。

练习：将内存中的字符串、基本数据类型的变量写出到文件中。

    //将内存中的字符串、基本数据类型的变量写出到文件中。
    @Test
    public void test15(){

        DataOutputStream dos = null;
        try {
            dos = new DataOutputStream(new FileOutputStream("data.txt"));

            dos.writeUTF("刘德华");
            dos.flush();//刷新操作，将内存中的数据写入文件
            dos.write(23);
            dos.flush();
            dos.writeBoolean(true);
            dos.flush();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //关闭资源
            try {
                if (dos != null)
                    dos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }

注意：利用DataOutputStream生成的文件不可以直接双击打开读取(否则乱码)，还应该调用DataInputStream将文件读取到内存中显示
**注意点：**读取不同类型的数据的顺序要与当初写入文件时，保存的数据的顺序一致。否则报错。

将文件中存储的基本数据类型变量和字符窜读取到内存中，保存在变量中:

    /*
    将文件中存储的基本数据类型变量和字符窜读取到内存中，保存在变量中。
    注意：利用DataOutputStream生成的文件不可以直接双击打开读取(否则乱码)，还应该调用DataInputStream
    将文件读取到内存中显示
    注意点：读取不同类型的数据的顺序要与当初写入文件时，保存的数据的顺序一致。否则报错。
     */

    @Test
    public void test16(){
        DataInputStream dis = null;
        try {
            dis = new DataInputStream(new FileInputStream("data.txt"));

            String name = dis.readUTF();
            int age = dis.readInt();
            boolean isMale = dis.readBoolean();
            System.out.println("name = " + name);
            System.out.println("age = " + age);
            System.out.println("isMale = " + isMale);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //关闭资源
            try {
                if (dis != null)
                    dis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }

对象流

1.ObjectInputStream和OjbectOutputSteam

2.作用：用于存储和读取基本数据类型数据或对象的处理流。它的强大之处就是可以把Java中的对象写入到数据源中，也能把对象从数据源中还原回来。

• 序列化：用ObjectOutputStream类保存基本类型数据或对象的机制（从内存写入硬盘文件）
• 反序列化：用ObjectInputStream类读取基本类型数据或对象的机制（从硬盘文件读入内存）

ObjectOutputStream和ObjectInputStream不能序列化static和transient修饰的成员变量

对象的序列化：

对象序列化机制允许把内存中的Java对象转换成平台无关的二进制流，从而允许把这种二进制流持久地保存在磁盘上，或通过网络将这种二进制流传输到另一个网络节点。//当其它程序获取了这种二进制流，就可以恢复成原来的Java对象。

序列化的过程：将内存中的java对象保存到磁盘中或通过网络传输出去，使用ObjectOutputStream实现

**中间需要注意的是：**数据流、对象流等从内存写入硬盘的都需要显式调用flush()

//序列化的过程：将内存中的java对象保存到磁盘中或通过网络传输出去，使用ObjectOutputStream实现
@Test
public void test1(){
    ObjectOutputStream oos = null;
    try {
        oos = new ObjectOutputStream(new FileOutputStream("object.txt"));
        oos.writeObject(new String("刮风这天"));
        //刷新操作
        oos.flush();//数据流、对象流等从内存写入硬盘的都需要显式调用flush()
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        try {
            if (oos != null)
                oos.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

反序列化：将磁盘文件中的对象还原为内存中的一个java对象，使用ObjectInputStream实现

需要知道的是：数据流，对象流等从内存写入硬盘生成的文件是不能双击打开查看的，应该使用对应的读取操作再读取到内存中

//数据流，对象流等从内存写入硬盘生成的文件是不能双击打开查看的，应该使用对应的读取操作再读取到内存中
//反序列化：将磁盘文件中的对象还原为内存中的一个java对象，使用ObjectInputStream实现
@Test
public void test2(){
    ObjectInputStream ois = null;
    try {
        ois = new ObjectInputStream(new FileInputStream("object.txt"));
        Object object = ois.readObject();
        String str = (String) object;//在我们已经知道对象的类型情况下可以强转
        System.out.println(str);
    } catch (IOException e) {
        e.printStackTrace();
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    } finally {
        try {
            if (ois != null)
                ois.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

要想一个java对象是可序列化的，需要满足相应的要求。自定义类需要满足如下的要求，方可序列化：（缺一不可）

1.需要实现接口：Serializable （实现这个Externalizable接口也可以，但这个用的很少。）

2.当前类提供一个全局常量：serialVersionUID(序列版本号) 。(这个必须有)

public static final long serialVersionUID = -6849794470754667710L;
//这个long型的serialVersionUID随便写，可正可负。

serialVersionUID用来表明类的不同版本间的兼容性。简言之，其目的是以序列化对象进行版本控制，有关各版本反序列化时是否兼容。
如果类没有显示定义这个静态常量，它的值是Java运行时环境根据类的内部细节自动生成的。若类的实例变量做了修改，serialVersionUID 可能发生变化。故建议，显式声明。

3.除了当前自定义类需要实现Serializable接口之外，还必须保证其内部所有属性也必须是可序列化的。(默认情况下，基本数据类型、String可序列化)。【比如说当前自定义类中有个属性的类型是其他的自定义类，那么作为属性的其他自定义类都必须是可序列化的，这个自定义类才可以序列化。】

补充：ObjectOutputStream和ObjectInputStream不能序列化static和transient修饰的成员变量。

用static和transient修饰的成员变量经过序列化和反序列化得到的结果是属性的默认值如String = null ；因为这两个修饰的不可以进行序列化，内存中的数据无法保存在硬盘中，自然读取的也是默认值。

打个比喻：好比一个人（就是一个对象）要通过时空门进行时空穿越(这个过程可以理解为序列化)，要想序列化必须身体的每个部位（每个属性）都要可序列化。

static修饰的属性归类所有，不归对象所有，所以不可以序列化；而transient的意思就是禁止修饰的属性序列化

---

总结要求：

1.需要实现接口：Serializable

2.当前类提供一个全局常量：serialVersionUID

3.除了当前自定义类需要实现Serializable接口之外，还必须保证其内部所有属性也必须是可序列化的。(默认情况下，基本数据类型、String可序列化)。

---

序列化是 RMI（Remote Method Invoke – 远程方法调用）过程的参数和返回值都必须实现的机制，而 RMI 是 JavaEE 的基础。因此序列化机制是JavaEE 平台的基础。

这一部分的重点是理解序列化机制，跟后面的JavaEE紧密相关，都必须实现序列化机制，实际传输的是json . (json是字符串)

谈谈你对java.io.Serializable接口的理解，我们知道它用于序列化，是空方法接口，还有其它认识吗？

实现了Serializable接口的对象，可将它们转换成一系列字节，并可在以后完全恢复回原来的样子。**这一过程亦可通过网络进行。这意味着序列化机制能自动补偿操作系统间的差异。**换句话说，可以先在Windows机器上创建一个对象，对其序列化，然后通过网络发给一台Unix机器，然后在那里准确无误地重新“装配”。不必关心数据在不同机器上如何表示，也不必关心字节的顺序或者其他任何细节。
由于大部分作为参数的类如String、Integer等都实现了java.io.Serializable的接口，也可以利用多态的性质，作为参数使接口更灵活。

RandomAccessFile

RandomAccessFile 类支持 “随机访问” 的方式，程序可以直接跳到文件的任意地方来读、写文件

• 支持只访问文件的部分内容
• 可以向已存在的文件后追加内容

RandomAccessFile的使用

1.RandomAccessFile直接继承于java.lang.Object类，实现了DataInput和DataOutput接口

2.RandomAccessFile既可以作为一个输入流，又可以作为一个输出流(但是需要创建两个对象，一个对象作为输入流，一个对象作为输出流)

3.如果RandomAccessFile作为输出流时，写出到的文件如果不存在，则在执行过程中自动创建；如果写出到的文件存在，则会对原有文件内容进行覆盖。（默认情况下，从头覆盖。能覆盖多少覆盖多少，没有覆盖的保留下来）

补充：①对文件覆盖：文件内容全部换成新的文件内容②对文件追加：在原有文件后面追加内容③对文件内容进行覆盖：原有文件内容保留，对内容进行覆盖，能覆盖多少覆盖多少，没有覆盖的保留下来。

构造器（参数是文件，或路径，而不是之前的字节流/字符流）
public RandomAccessFile(File file, String mode)
public RandomAccessFile(String name, String mode)

创建 RandomAccessFile 类实例需要指定一个 mode 参数，该参数指定 RandomAccessFile 的访问模式：

• r: 以只读方式打开（只能读文件）

• rw：打开以便读取和写入（可以读也可以写）

• rwd:打开以便读取和写入；同步文件内容的更新

• rws:打开以便读取和写入；同步文件内容和元数据的更新

  注意：没有单独的 ”w” 。

如果模式为只读r。则不会创建文件，而是会去读取一个已经存在的文件，如果读取的文件不存在则会出现异常。 如果模式为rw读写。如果文件不存在则会去创建文件，如果存在则不会创建。

jdk1.6上面写的每次write数据时，”rw“模式，数据不会立即写到硬盘中；而”rwd“，数据会被立即写入硬盘。如果写数据过程发生异常，”rwd“模式中已被write的数据被保存到硬盘，而”rw“则全部丢失。

RandomAccessFile读取数据还是用byte[]数组

@Test
public void test1(){
    RandomAccessFile raf1 = null;
    RandomAccessFile raf2 = null;
    try {
        raf1 = new RandomAccessFile("图片1.jpg","r");//只能读
        raf2 = new RandomAccessFile("图片3.jpg","rw");//可读可写

        //还是用byte[]数组
        byte[]  buffer = new byte[1024];
        int len;
        while ((len = raf1.read(buffer)) != -1){
            raf2.write(buffer,0,len);
        }
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        try {
            if (raf2 != null)
                raf2.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        try {
            if (raf1 != null)
                raf1.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}

默从头开始覆盖:

    @Test
    public void test2(){
        RandomAccessFile raf1 = null;
        try {
            raf1 = new RandomAccessFile("hello.txt","rw");
            raf1.write("xyz".getBytes());
            /*
            原来文本内容HelloWorld123，修改过内容为xyzloWorld123。
            默从头开始覆盖
             */
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (raf1 != null)
                    raf1.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

RandomAccessFile 对象包含一个记录指针，用以标示当前读写处的位置。 RandomAccessFile 类对象可以自由移动记录指针：

• long getFilePointer()：获取文件记录指针的当前位置
• void seek(long pos)：将文件记录指针定位到 pos 位置

利用seek(long pos)实现从指定位置覆盖；调用获取文件长度的方法实现在文件末尾追加内容

    @Test
    public void test2(){
        RandomAccessFile raf1 = null;
        try {
            raf1 = new RandomAccessFile("hello.txt","rw");
            raf1.seek(3);//将指针调到角标为3的位置。从指针处开始插入
            /*//实现在文件末尾追加填入内容，只需将指针定位到文件末尾即可
            raf1.seek(new File("hello.txt").length());//调用文件长度方法*/
            raf1.write("xyz".getBytes());
            /*
            原来文本内容是HelloWorld123，修改过之后为Helxyzorld123。
            从指针处开始覆盖
             */
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (raf1 != null)
                    raf1.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

4.可以通过相关的操作，实现RandomAccessFile“插入”数据的效果。

使用RandomAccessFile实现数据的插入效果

:实现方法，先将要插入位置及后面的所有数据都临时保存起来，这时候指针已经指到文件末尾了，还需要再将指针调回来。覆盖完之后再将临时保存起来的数据调用write方法写入（此时的指针已经到了插入内容的末尾，直接将保存的文件调用方法覆盖即可）

这个方法里面有很多值得借鉴的地方，保存完后面的数据之后指针要回调。将数据保存在StringBuilder中(这时候是在内存层面的)。

    /*
    使用RandomAccessFile实现数据的插入效果
    实现方法，先将要插入位置及后面的所有数据都临时保存起来，这时候指针已经指到文件末尾了，还需要再将指针调回来。
    覆盖完之后再将临时保存起来的数据调用write方法写入（此时的指针已经到了插入内容的末尾，
    直接将保存的文件调用方法覆盖即可）
     */
    @Test
    public void test3(){
        RandomAccessFile raf = null;
        try {
            raf = new RandomAccessFile("hello.txt","rw");
            raf.seek(3);//将指针调到角标为3的位置
            //保存指针3后面的所有数据到StringBuilder中
            StringBuilder builder = new StringBuilder((int) new File("hello.txt").length());
            //不用String的原因是效率低，需要频繁的重新更换内存区域。由于StringBuilder有默认值，怕文件太长，
            //先直接指定好StringBuilder的长度省的再进行扩容
            byte[] buffer = new byte[20];
            int len;
            while ((len = raf.read(buffer)) != -1){
                builder.append(new String(buffer,0,len));//构造器中没有byte[]参数，所以先转换成字符串
            }
            //调回指针，写入“xyz”
            raf.seek(3);
            raf.write("xyz".getBytes());
            //将StringBuilder中的数据写入到文件中。（此时的指针已经指在正确的位置了，不用调整）
            //write的参数只能是byte[]数组，StringBuilder要先转换为String再转换为byte[]数组
            raf.write(builder.toString().getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (raf != null)
                    raf.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        /*
        结果：
        原来内容：HelloWo        修改过内容：HelxyzloWo
                rld123                      rld123
         */
    }

实现插入操作要保存太多的临时数据在内存层面是比较耗内存的。

还可以使用ByteArrayOutputStream流实现临时数据的存储，例

		ByteArrayOutputStream baos = new ByteArrayOutputStream();
		byte[] buffer = new byte[10];
		int len;
		while ((len = fis.read(buffer)) != -1) {
			baos.write(buffer, 0, len);
		}
		
		return baos.toString();

ByteArrayOutputStream的底层也是用一个char[]型数组存储，调用write()方法就是将数据写入char[]数组。

利用RandomAccessFile类可以实现插入效果这一功能可以实现断点续传功能。具体实现思路：

可以用RandomAccessFile这个类，来实现一个多线程断点下载的功能，用过下载工具的都知道，下载前都会建立两个临时文件，一个是与被下载文件大小相同的空文件，另一个是记录文件指针的位置文件，每次暂停的时候，都会保存上一次的指针，然后断点下载的时候，会继续从上一次的地方下载，从而实现断点下载或上传的功能。

NIO概述

Java NIO (New IO，Non-Blocking IO)，两种理解都可以，新IO；非阻塞式IO

目前对于NIO仅为了解。后续涉及框架的时候再细讲。

NIO支持面向缓冲区的(IO是面向流的)、基于通道的IO操作。NIO将以更加高效的方式进行文件的读写操作。

Java API中提供了两套NIO，一套是针对标准输入输出NIO，另一套就是网络编程NIO。

|-----java.nio.channels.Channel
|-----FileChannel:处理本地文件
|-----SocketChannel：TCP网络编程的客户端的Channel
|-----ServerSocketChannel:TCP网络编程的服务器端的Channel
|-----DatagramChannel：UDP网络编程中发送端和接收端的Channel

随着 JDK 7 的发布，Java对NIO进行了极大的扩展，增强了对文件处理和文件系统特性的支持，以至于我们称他们为 NIO.2。因为 NIO 提供的一些功能，NIO已经成为文件处理中越来越重要的部分。

Path、Paths和Files核心API

Paths、Files等后面带s的跟Arrays、Maths等都是工具类，提供静态方法。

早期的Java只提供了一个File类来访问文件系统，但File类的功能比较有限，所提供的方法性能也不高。而且，大多数方法在出错时仅返回失败，并不会提供异常信息。
NIO. 2为了弥补这种不足，引入了Path接口，代表一个平台无关的平台路径，描述了目录结构中文件的位置。Path可以看成是File类的升级版本，实际引用的资源也可以不存在。
在以前IO操作都是这样写的:

import java.io.File;
File file = new File(“index.html”);

但在Java7 中，我们可以这样写：

import java.nio.file.Path;
import java.nio.file.Paths;
Path path = Paths.get(“index.html”);

同时，NIO.2在java.nio.file包下还提供了Files、Paths工具类，Files包含了大量静态的工具方法来操作文件；Paths则包含了两个返回Path的静态工厂方法。工厂设计模式：专门用来造对象的。

Paths 类提供的静态 get() 方法用来获取 Path 对象：

• static Path get(String first, String … more) : 用于将多个字符串串连成路径
• static Path get(URI uri): 返回指定uri对应的Path路径

Path接口

Path 常用方法：

• String toString() ： 返回调用 Path 对象的字符串表示形式
• boolean startsWith(String path) : 判断是否以 path 路径开始
• boolean endsWith(String path) : 判断是否以 path 路径结束
• boolean isAbsolute() : 判断是否是绝对路径
• Path getParent() ：返回Path对象包含整个路径，不包含 Path 对象指定的文件路径
• Path getRoot() ：返回调用 Path 对象的根路径
• Path getFileName() : 返回与调用 Path 对象关联的文件名
• int getNameCount() : 返回Path 根目录后面元素的数量
• Path getName(int idx) : 返回指定索引位置 idx 的路径名称
• Path toAbsolutePath() : 作为绝对路径返回调用 Path 对象
• Path resolve(Path p) :合并两个路径，返回合并后的路径对应的Path对象
• File toFile(): 将Path转化为File类的对象

Files 类

java.nio.file.Files 用于操作文件或目录的工具类。
Files常用方法：

• Path copy(Path src, Path dest, CopyOption … how) : 文件的复制
• Path createDirectory(Path path, FileAttribute<?> … attr) : 创建一个目录
• Path createFile(Path path, FileAttribute<?> … arr) : 创建一个文件
• void delete(Path path) : 删除一个文件/目录，如果不存在，执行报错
• void deleteIfExists(Path path) : Path对应的文件/目录如果存在，执行删除
• Path move(Path src, Path dest, CopyOption…how) : 将 src 移动到 dest 位置
• long size(Path path) : 返回 path 指定文件的大小

Files常用方法：用于判断

• boolean exists(Path path, LinkOption … opts) : 判断文件是否存在
• boolean isDirectory(Path path, LinkOption … opts) : 判断是否是目录
• boolean isRegularFile(Path path, LinkOption … opts) : 判断是否是文件
• boolean isHidden(Path path) : 判断是否是隐藏文件
• boolean isReadable(Path path) : 判断文件是否可读
• boolean isWritable(Path path) : 判断文件是否可写
• boolean notExists(Path path, LinkOption … opts) : 判断文件是否不存在

Files常用方法：用于操作内容

• SeekableByteChannel newByteChannel(Path path, OpenOption…how) : 获取与指定文件的连接，how 指定打开方式。
• DirectoryStream newDirectoryStream(Path path) : 打开 path 指定的目录
• InputStream newInputStream(Path path, OpenOption…how):获取InputStream 对象
• OutputStream newOutputStream(Path path, OpenOption…how) : 获取 OutputStream 对象

IDEA导入第三方jar包

注意jar包下存的都是 “.class” 字节码文件，做开发的都是".java" 文件

利用第三方jar包实现数据的读写操作。

jar包就相当于提供了额外的API，这个API 不是JDK里面的API 了。

在IDEA中导入jar包：

如果是在当前Module下导入：现在当前Module—>new —>Directory

第三方jar包放于lib文件夹下(或libs)，lib全称library

将jar包复制到该包下

此时还不能使用，应该做如下设置：选择该jar包右键–>Add as Library

选择OK

此时便可以作为API去使用了。

进行测试，此时就可以使用jar包下的API了

利用jar包实现文件复制操作:

    //利用jar包实现文件复制操作。
    @Test
    public void test4(){
        File srcFile = new File("图片1.jpg");
        File destFile = new File("图片3.jpg");
        try {
            //jar包里面其实就是封装了我们学的基本方法，底层知识还是用流处理文件
            FileUtils.copyFile(srcFile,destFile);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }