File类和IO流

File类

概述

java.io.File 类是文件和目录路径名的抽象表示，主要用于文件和目录的创建、查找和删除等操作
Java把电脑中的文件和文件夹(目录)封装为了一个File类,我们可以使用File类对文件和文件夹进行操作

File类的方法
    创建一个文件/文件夹
    删除文件/文件夹
    获取文件/文件夹
    判断文件/文件夹是否存在
    对文件夹进行遍历
    获取文件的大小
File类是一个与系统无关的类,任何的操作系统都可以使用这个类中的方法

重点:记住这三个单词

• file:文件
• directory:文件夹/目录
• path:路径

File类的静态成员变量

静态成员变量 类名.变量名（File.pathSeparator）就可

public class Demo01File{
    public static void main(String[] args) {
        /*
            static String pathSeparator 与系统有关的路径分隔符，为了方便，它被表示为一个字符串。
            static char pathSeparatorChar 与系统有关的路径分隔符。

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

            操作路径:路径不能写死了
            C:\develop\a\a.txt  windows
            C:/develop/a/a.txt  linux
            "C:"+File.separator+"develop"+File.separator+"a"+File.separator+"a.txt"
         */
        String pathSeparator = File.pathSeparator;
        System.out.println(pathSeparator);//路径分隔符 windows:分号;  linux:冒号:

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

路径

绝对路径:是一个完整的路径

以盘符(c:,D:)开始的路径
    c:\\a.txt
    C:\\Users\A\\AA\\AAA\\123.txt
    D:\\demo\\b.txt

相对路径:是一个简化的路径

相对指的是相对于当前项目的根目录(C:\\Users\A\\AA\\AAA)
如果使用当前项目的根目录,路径可以简化书写
C:\\Users\A\\AA\\AAA\\123.txt-->简化为: 123.txt(可以省略项目的根目录)

注意:

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

File类的构造方法

• public File(String pathname) ：通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例。

File(String pathname) 通过将给定路径名字符串转换为抽象路径名来创建一个新 File 实例。
   参数:
     String pathname:字符串的路径名称
     路径可以是以文件结尾,也可以是以文件夹结尾
     路径可以是相对路径,也可以是绝对路径
     路径可以是存在,也可以是不存在
    创建File对象,只是把字符串路径封装为File对象,不考虑路径的真假情况
     
==================================================================
	// 文件路径名
	String pathname = "D:\\aaa.txt";
	//因为这里是把字符串路径封装为File对象，所以不考虑路径是否存在
	File file1 = new File(pathname); //重写了Object类的toString方法

• public File(String parent, String child) ：从父路径名字符串和子路径名字符串创建新的 File实例。

File(String parent, String child) 根据 parent 路径名字符串和 child 路径名字符串创建一个新 File 实例。
   参数:把路径分成了两部分
         String parent:父路径
         String child:子路径
   好处:
        父路径和子路径,可以单独书写,使用起来非常灵活;父路径和子路径都可以变化
==================================================================
        
     // 通过父路径和子路径字符串
	 String parent = "d:\\aaa";
	 String child = "bbb.txt";
	 File file2 = new File(parent, child);

• public File(File parent, String child) ：从父抽象路径名和子路径名字符串创建新的 File实例。

File(File parent, String child) 根据 parent 抽象路径名和 child 路径名字符串创建一个新 File 实例。
参数:把路径分成了两部分
  File parent:父路径
  String child:子路径
好处:
   父路径和子路径,可以单独书写,使用起来非常灵活;父路径和子路径都可以变化
   父路径是File类型,可以使用File的方法对路径进行一些操作,再使用路径创建对象
==================================================================
	// 通过父级File对象和子路径字符串
	File parentDir = new File("d:\\aaa");
	String child = "bbb.txt";
	File file3 = new File(parentDir, child);

小贴士：

1. 一个File对象代表硬盘中实际存在的一个文件或者目录。
2. 无论该路径下是否存在文件或者目录，都不影响File对象的创建。

常用方法

获取功能的方法

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

	public String getAbsolutePath() ：返回此File的绝对路径名字符串。
	获取的构造方法中传递的路径
	无论路径是绝对的还是相对的,getAbsolutePath方法返回的都是绝对路径
	
==================================================================
	
	File f1 = new File("c:\\A\\AA\\a.txt");//不存在也没关系
    String absolutePath = f1.getAbsolutePath();
    System.out.println(absolutePath);//c:\A\AA\a.txt

	File f2 = new File("aa.txt");//这里是相对路径 下面输出绝对路径的话就是该代码的工作空间
    System.out.println( f2.getAbsolutePath() );//C:\Users\ASUS\Workspaces\MyEclipse 8.5\Demo\aa.txt

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

	public String getPath() ：将此File转换为路径名字符串。
    获取的构造方法中传递的路径
    toString方法调用的就是getPath方法
    源码:
        public String toString() {
            return getPath();
        }
==================================================================

		File f1 = new File("c:\\A\\AA\\a.txt");
        File f2 = new File("aa.txt");

        String path1 = f1.getPath();
        System.out.println(path1);//c:\A\AA\a.txt

        String path2 = f2.getPath();
        System.out.println(path2);//aa.txt

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

    public String getName()  ：返回由此File表示的文件或目录的名称。
    获取的就是构造方法传递路径的结尾部分(文件/文件夹)
==================================================================
        File f1 = new File("c:\\A\\AA\\a.txt");
        File f2 = new File("aa.txt");
        File f3 = new File("c:\\A\\AA\\新建文件夹");

        String f1Name = f1.getName();
        System.out.println(f1Name);//a.txt

        String f2Name = f2.getName();
        System.out.println(f2Name);//aa.txt

        String f3Name = f3.getName();
        System.out.println(f3Name);//新建文件夹

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

     public long length()  ：返回由此File表示的文件的长度。
     获取的是构造方法指定的文件的大小,以字节为单位
     注意:
       文件夹是没有大小概念的,不能获取文件夹的大小
       如果构造方法中给出的路径不存在,那么length方法返回0
==================================================================
        File f1 = new File("C:\\Users\\ASUS\\Pictures\\Camera Roll\\banner.jpg");//存在
        long length1 = f1.length();
        System.out.println(length1);//291002（单位是字节）

        File f2 = new File("C:\\Users\\ASUS\\Pictures");//存在的文件夹
        long length2 = f2.length();
        System.out.println(length2);//0

        File f3 = new File("C:\\A.jpg");//不存在
        long length3 = f3.length();
        System.out.println(length3);//0

判断功能的方法

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

        File f1 = new File("C:\\A\\AA");
        System.out.println(f1.exists());//false 不存在

        File f2 = new File("C:\\Users\\ASUS\\Workspaces\\MyEclipse 8.5\\Demo\\src\\JavaSEDemo\\file");
        System.out.println(f2.exists());//true

        File f3 = new File("工作空间.txt");
        // C:\Users\ASUS\Workspaces\MyEclipse 8.5\Demo\工作空间.txt 而不是上面那个代码的位置
        System.out.println(f3.exists());//true

• public boolean isDirectory() ：此File表示的是否为目录。
• public boolean isFile() ：此File表示的是否为文件。

	电脑的硬盘中只有文件/文件夹,两个方法是互斥
	这两个方法使用前提,路径必须是存在的,否则都返回false
===============================================================
    public static void main(String[] args) {
        File f1 = new File("C:\\A\\AA");
        isWhat(f1);//不存在

        File f2 = new File("C:\\Users\\ASUS\\Workspaces\\MyEclipse 8.5\\Demo\\src\\JavaSEDemo\\file");
        isWhat(f2);//文件夹

        File f3 = new File("工作空间.txt");
        isWhat(f3);//文件
    }

    private static void isWhat(File file) {
        if (file.exists()) {
            if (file.isDirectory())
                System.out.println("文件夹");
            if (file.isFile())
                System.out.println("文件");
        }else
            System.out.println("路径不存在");
    }

创建删除功能的方法

• public boolean createNewFile() ：当且仅当具有该名称的文件尚不存在时，创建一个新的空文件。

	public boolean createNewFile() ：当且仅当具有该名称的文件尚不存在时，创建一个新的空文件。
    创建文件的路径和名称在构造方法中给出(构造方法的参数)
    返回值:布尔值
        true:文件不存在,创建文件,返回true
        false:文件存在,不会创建,返回false
    注意:
        1.此方法只能创建文件,不能创建文件夹
        2.创建文件的路径必须存在,否则会抛出异常

    public boolean createNewFile() throws IOException
    createNewFile声明抛出了IOException,我们调用这个方法,就必须的处理这个异常,要么throws,要么try catch
================================================================================================
//        File f1 = new File("C:\\A\\AA\\1.txt");
//        boolean b1 = f1.createNewFile();
//        System.out.println("b1:" + b1);//抛出异常

        File f2 = new File("C:\\Users\\ASUS\\Workspaces\\MyEclipse 8.5\\Demo\\src\\JavaSEDemo\\file\\1.txt");
        boolean b2 = f2.createNewFile();
        System.out.println("b2:" + b2);//b2:true

        File f3 = new File("2.txt");
        boolean b3 = f3.createNewFile();
        System.out.println("b3:" + b3);//b2:true

        File f4 = new File("已有文件夹");//不要被名字骗了 这里还是文件
        boolean b4 = f4.createNewFile();
        System.out.println("b4:" + b4);//b4:false

• public boolean mkdir() ：创建由此File表示的目录（单级文件夹）。
• public boolean mkdirs() ：创建由此File表示的目录，包括任何必需但不存在的父目录。

	public boolean mkdir() ：创建单级空文件夹
	public boolean mkdirs() ：既可以创建单级空文件夹,也可以创建多级文件夹
    创建文件夹的路径和名称在构造方法中给出(构造方法的参数)
    返回值:布尔值
        true:文件夹不存在,创建文件夹,返回true
        false:文件夹存在,不会创建,返回false;构造方法中给出的路径不存在返回false
    注意:
    	此方法只能创建文件夹,不能创建文件
=======================================================================
        File f1 = new File("src\\JavaSEDemo\\aaa");
        boolean b1 = f1.mkdir();
        System.out.println("b1:"+b1);

        File f2 = new File("src\\JavaSEDemo\\111\\222\\333\\444");
        boolean b2 = f2.mkdirs();
        System.out.println("b2:"+b2);

        File f3 = new File("src\\JavaSEDemo\\abc.txt");
        boolean b3 = f3.mkdirs();//看类型,是一个文件夹 只要不是创建父子级都不存在的，就可以用mkdir()方法
        System.out.println("b3:"+b3);

        File f4 = new File("A:sec\\ccc");
        //注意 用mkdirs()方法 只有根目录不存在才会失败
        //而     mkdir()方法 路径不对就会失败
        boolean b4 = f4.mkdirs();//不会抛出异常,路径不存在,不会创建
        System.out.println("b4:"+b4);

• public boolean delete() ：删除由此File表示的文件或目录（文件夹）。

    public boolean delete() ：删除由此File表示的文件或目录。
    此方法,可以删除构造方法路径中给出的文件/文件夹
    返回值:布尔值
        true:文件/文件夹删除成功,返回true
        false:文件夹中有内容,不会删除返回false;构造方法中路径不存在false
    注意:
        delete方法是直接在硬盘删除文件/文件夹,不走回收站,删除要谨慎
========================================================================
        File f1 = new File("src\\JavaSEDemo\\file\\A.txt");
        boolean b1 = f1.delete();
        System.out.println("b1:"+b1);//b1:true

        File f2 = new File("C:\\Users\\ASUS\\Workspaces\\MyEclipse 8.5\\Demo\\src\\JavaSEDemo\\file\\1.txt");
        System.out.println(f2.delete());//true

        File f3 = new File("2.txt");
        System.out.println(f3.delete());//true
        
        //删除有子级文件夹的文件夹
        File f4 = new File("a");//在项目目录中有一个a\A 这样的文件夹
        //可以逐级删除  先a\\A  再a
        System.out.println(f4.delete());//false

自己删除自己 System.out.println(file.delete());//true
控制台打印true后 代码那个文件会被删除

目录的遍历

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

	public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
	遍历构造方法中给出的目录,会获取目录中所有文件/文件夹的名称,把获取到的多个名称存储到一个String类型的数组中
	隐藏的也能遍历到
===================================================================================================
        //File file = new File("C:\\Users\\itcast\\IdeaProjects\\shungyuan\\08_FileAndRecursion\\1.txt");//不能变量文件NullPointerException
        //File file = new File("C:\\Users\\itcast\\IdeaProjects\\shungyuan\\08_Fi");//NullPointerException
        File file = new File("C:\\Users\\itcast\\IdeaProjects\\shungyuan\\08_FileAndRecursion");
        String[] arr = file.list();
        for (String fileName : arr) {
            System.out.println(fileName);
        }
        //相对路径都行
        File file = new File("src");
        for (String s : file.list()) {
            System.out.println(s);
        }

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

        public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。
        遍历构造方法中给出的目录,会获取目录中所有的文件/文件夹,把文件/文件夹封装为File对象,多个File对象存储到File数组中
===================================================================================================
        File file = new File("C:\\Users\\itcast\\IdeaProjects\\shungyuan\\08_FileAndRecursion");
        File[] files = file.listFiles();
        for (File f : files) {
            System.out.println(f);
        }

递归

概述

• 递归：指在当前方法内调用自己的这种现象。

• 递归的分类:

  • 递归分为两种，直接递归和间接递归。
  • 直接递归称为方法自身调用自己。
  • 间接递归可以A方法调用B方法，B方法调用C方法，C方法调用A方法。

• 注意事项：

  • 递归一定要有条件限定，保证递归能够停止下来，否则会发生栈内存溢出。
  • 在递归中虽然有限定条件，但是递归次数不能太多。否则也会发生栈内存溢出。
  • 构造方法,禁止递归

计算1-n的和

阶乘同理
3的阶乘就是 321

    public static void main(String[] args) {
        int s = sum(100);
        System.out.println(s);
    }

    private static int sum(int n) {
        if (n == 1){
            return 1;
        }

        return n + sum(n-1);
    }

原理

打印多级目录

    public static void main(String[] args) {
        File f = new File("D:\\A");
        findFile(f);
    }

    private static void findFile(File f) {
        if (f.exists()){
            File[] files = f.listFiles();
            for (File file : files) {
                System.out.println(file.getAbsolutePath());
                if (file.isDirectory()){
                //如果第一次遍历中出现了文件夹
                //则将该文件夹递归再次打印
                    findFile(file);
                }
            }
        }
    }

文件搜索

    public static void main(String[] args) {
        File file = new File("D:\\A");
        String s = "文件ba.txt";
        findFile(file,s);
    }

    private static void findFile(File file, String name) {
        if (file.exists()){
            File[] files = file.listFiles();
            for (File f : files) {
                if ( name.equals(f.getName()) ){//先判断是否存在
                    System.out.println(f.getAbsolutePath());
                }else {//如果不存在则递归进入下一级继续判断
                    if (f.isDirectory()){
                        findFile(f,name);
                    }else
                        System.out.println(name + "不存在");
                }
            }
        }
    }

文件过滤器

java.io.FileFilter是一个接口，是File的过滤器。 该接口的对象可以传递给File类的listFiles(FileFilter) 作为参数， 接口中只有一个方法。

boolean accept(File pathname) ：测试pathname是否应该包含在当前File目录中，符合则返回true。

分析：

1. 接口作为参数，需要传递子类对象，重写其中方法。我们选择匿名内部类方式，比较简单。
2. accept方法，参数为File，表示当前File下所有的子文件和子目录。保留住则返回true，过滤掉则返回false。保留规则：
   1. 要么是.java文件。
   2. 要么是目录，用于继续遍历。
3. 通过过滤器的作用，listFiles(FileFilter)返回的数组元素中，子文件对象都是符合条件的，可以直接打印。

    在File类中有两个和ListFiles重载的方法,方法的参数传递的就是过滤器
   1
    File[] listFiles(FileFilter filter)
    java.io.FileFilter接口:用于抽象路径名(File对象)的过滤器。
        作用:用来过滤文件(File对象)
        抽象方法:用来过滤文件的方法
            boolean accept(File pathname) 测试指定抽象路径名是否应该包含在某个路径名列表中。
            参数:
                File pathname:使用ListFiles方法遍历目录,得到的每一个文件对象
             
               
   2             
    File[] listFiles(FilenameFilter filter)
    java.io.FilenameFilter接口:实现此接口的类实例可用于过滤器文件名。
        作用:用于过滤文件名称
        抽象方法:用来过滤文件的方法
            boolean accept(File dir, String name) 测试指定文件是否应该包含在某一文件列表中。
            参数:
                File dir:构造方法中传递的被遍历的目录
                String name:使用ListFiles方法遍历目录,获取的每一个文件/文件夹的名称
    注意:
        两个过滤器接口是没有实现类的,需要我们自己写实现类,重写过滤的方法accept,在方法中自己定义过滤的规则

过滤器原理

一个参数的accept方法

    public static void main(String[] args) {
        File dir = new File("D:\\A");
        findFile(dir);
    }

    private static void findFile(File dir) {
        File[] files = dir.listFiles(f->{
            return f.getName().toLowerCase().endsWith(".txt") || f.isDirectory();
            //返回  先获取名字   再变小写        再比较后缀
            //如果是true才会进入数组，所以如果是文件夹也放入数组中
        });
=================================================================
        File[] files = dir.listFiles((f,name)->{
            return name.equals("文件ba.txt") || new File(f,name).isDirectory();
        });
=================================================================        
        for (File file : files) {
            if (file.isDirectory())
                findFile(file);
            if (file.isFile())
                System.out.println(file);
        }
    }

IO流

• OutputStream，输出流。对程序来说，我(程序)输出（比如输出到磁盘的某个txt文件里，写入txt文件），写。
• InputStream，输入流。对程序来说，向我(程序)输入的流，就是需要我(程序)来读取流的内容， 读。
  

字节流

一切皆为字节

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

字节输出流【OutputStream】

程序 输出到 硬盘 写入

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

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

小贴士：
close方法，当完成流的操作时，必须调用此方法，释放系统资源。

FileOutputStream类

OutputStream有很多子类，我们从最简单的一个子类开始。
java.io.FileOutputStream类是文件输出流，用于将数据写出到文件。

java.io.FileOutputStream extends OutputStream
FileOutputStream:文件字节输出流
作用:把内存中的数据写入到硬盘的文件中

构造方法

FileOutputStream(String name)创建一个向具有指定名称的文件中写入数据的输出文件流。
FileOutputStream(File file) 创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
**注意 在下面续写中会出现两个参数的构造方法**
    参数:写入数据的目的
        String name:目的地是一个文件的路径
        File file:目的地是一个文件
    构造方法的作用:
        1.创建一个FileOutputStream对象
        2.会根据构造方法中传递的文件/文件路径,创建一个空的文件
        3.会把FileOutputStream对象指向创建好的文件
        
字节输出流的使用步骤(重点):
    1.创建一个FileOutputStream对象,构造方法中传递写入数据的目的地
    2.调用FileOutputStream对象中的方法write,把数据写入到文件中
    3.释放资源(流使用会占用一定的内存,使用完毕要把内存清空,提供程序的效率)

构造举例

//注 现在创建的都是没有内容的
    public static void main(String[] args) {
   	 	// 使用File对象创建流对象
        File file = new File("a.txt");//假设a.txt存在
        FileOutputStream fos = new FileOutputStream(file);
        //则还会创建a.txt且覆盖原来的
      
        // 使用文件名称创建流对象
        FileOutputStream fos = new FileOutputStream("b.txt");
    }
    //这样就在项目目录中创建了两个文件 a.txt 和 b.txt 没有内容

写入（写入硬盘）字节数据

• 一次写一个字节
  public abstract void write(int b) ：将指定的字节输出流。

---

写入数据的原理(内存-->硬盘)
java程序-->JVM(java虚拟机)-->OS(操作系统)-->OS调用写数据的方法-->把数据写入到文件中

    public static void main(String[] args) throws IOException {
        //1.创建一个FileOutputStream对象,构造方法中传递写入数据的目的地
        FileOutputStream fos = new FileOutputStream("a.txt");
        //2.调用FileOutputStream对象中的方法write,把数据写入到文件中
           //public abstract void write(int b) ：将指定的字节输出流。
        fos.write(97);// 对应的就是 a
        //3.释放资源(流使用会占用一定的内存,使用完毕要把内存清空,提供程序的效率)
        fos.close();
    }

代码解析

• 一次写多个字节
  public void write(byte[] b)：将 b.length字节从指定的字节数组写入此输出流。
  public void write(byte[] b, int off, int len) ：从指定的字节数组写入 len字节，从偏移量 off开始输出到此输出流。

    public static void main(String[] args) throws Exception {
        //一次写多个字节:
        //    如果写的第一个字节是正数(0-127),那么显示的时候会查询ASCII表
        //    如果写的第一个字节是负数,那第一个字节会和第二个字节,两个字节组成一个中文显示,查询系统默认码表(GBK)
        FileOutputStream fos = new FileOutputStream("a.txt");
        byte[] bytes = {65, 66, 67, 68, 69};//ABCDE
        //byte[] bytes = {-65, -66, -67, 68, 69};//GBK码 烤紻E
        //fos.write(bytes);

        //write(byte[] b, int off, int len)
        fos.write(bytes, 1, 2);//BC
        //int off:数组的开始索引
        //int len:写几个字节

        /*
          写入字符的方法:可以使用String类中的方法把字符串,转换为字节数组
              byte[] getBytes()  把字符串转换为字节数组
         */
        byte[] bytes1 = "中文".getBytes();
        System.out.println(Arrays.toString(bytes1));
        //[-28, -72, -83, -26, -106, -121]
        fos.write(bytes1);

        fos.close();
    }

数据追加续写与换行

追加续写
每次程序运行，创建输出流对象，都会清空目标文件中的数据。

• public FileOutputStream(File file, boolean append)： 创建文件输出流以写入由指定的 File对象表示的文件。
• public FileOutputStream(String name, boolean append)： 创建文件输出流以指定的名称写入文件。

这两个构造方法，参数中都需要传入一个boolean类型的值，true 表示追加数据，false 表示清空原有数据。这样创建的输出流对象，就可以指定是否追加续写了

换行

windows:\r\n
linux:/n
mac:/r

    public static void main(String[] args) throws Exception {
        FileOutputStream fos = new FileOutputStream("a.txt",true);
        byte[] bytes1 = "\r\n".getBytes();
        fos.write(bytes1);
        byte[] bytes2 = "换行后的追加内容".getBytes();
        fos.write(bytes2);
        fos.close();
    }

字节输入流【InputStream】

硬盘 输入到 程序中 对程序来说 读

java.io.InputStream抽象类是表示字节输入流的所有类的超类，可以读取字节信息到内存中。它定义了字节输入流的基本共性功能方法。

• public void close() ：关闭此输入流并释放与此流相关联的任何系统资源。
• public abstract int read()： 从输入流读取数据的下一个字节。
• public int read(byte[] b)： 从输入流中读取一些字节数，并将它们存储到字节数组 b中 。

FileInputStream类

java.io.FileInputStream类是文件输入流，从文件中读取字节。

构造方法

• FileInputStream(File file)： 通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的 File对象 file命名。
• FileInputStream(String name)： 通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的路径名 name命名。

当你创建一个流对象时，必须传入一个文件路径。该路径下，如果没有该文件,会抛出FileNotFoundException 。

读取字节数据

1. 读取字节：read方法，每次可以读取一个字节的数据，提升为int类型，读取到文件末尾，返回-1，代码使用演示：

    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("a.txt");
        int len = 0;
        while ((len = fis.read()) != -1){
            System.out.println(len);
        }
//        while ( fis.read() != -1){
//            len = fis.read();
//            System.out.println(len);//66 67 68 BCD
//        }//这个是错误的 因为第一次循环判断的时候就已经调用一个read了 输出会导致第一个识别不到
        fis.close();
    }

小贴士：

1. 虽然读取了一个字节，但是会自动提升为int类型。
2. 流操作完毕后，必须释放系统资源，调用close方法，千万记得。

2. 使用字节数组读取（一次读多个）：read(byte[] b)，每次读取b的长度个字节到数组中，返回读取到的有效字节个数，读取到末尾时，返回-1 ，代码使用演示：

    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("a.txt");
        byte[] b = new byte[2];
//a.txt内容为 BCD
        int len = fis.read(b);
        System.out.println(len);//2
        System.out.println(Arrays.toString(b));//[66, 67]
        System.out.println(new String(b));//BC

        len = fis.read(b);
        System.out.println(len);//1
        System.out.println(new String(b));//DC
        //数组中，上次读取的数据没有被完全替换
        
        len = fis.read(b);
        System.out.println(len);//-1
        System.out.println(new String(b));//DC

		fis.close();
	}

小结 
len = read(byte[] b)中  len是读了多少个字节，并将读到的内容写入数组b中
当第二次只读了一个D然后覆盖数组中的第一个B，第二个还是上次的C，所以输出数组就是DC
第三次读取失败没有内容了，所以数组没有变还是上次的DC

代码优化

    public static void main(String[] args) throws IOException {
        //a.txt内容为 BCD
        FileInputStream fis = new FileInputStream("a.txt");
==========================方法1===========================================================
        byte[] b = new byte[1024];//1.一次多读取些 1024的整数倍 如果能一次读完就不用循环
        fis.read(b);
        System.out.println(new String(b));
==========================方法2===========================================================
        byte[] b = new byte[2];
        int len = 0;
        while (( len= fis.read(b))!=-1) {
        // 每次读取后,把数组的有效字节部分，变成字符串打印
            System.out.println(new String(b,0,len));//  len 每次读取的有效字节个数
        // String(byte[] bytes, int offset, int length)
        // 把字节数组的一部分转换为字符串 offset:数组的开始索引 length:转换的字节个数
        }
==========================最终版本===========================================================
		byte[] b = new byte[1024];//有点浪费内存但是稍微快一点
        int len = 0;
        while (( len= fis.read(b))!=-1) {
            System.out.println(new String(b,0,len));
        }
        fis.close();
    }

小贴士：

使用数组读取，每次读取多个字节，减少了系统间的IO操作次数，从而提高了读写的效率，建议开发中使用。

练习文件复制

字节流读取中文的问题

1个中文
    GBK:占用两个字节
    UTF-8:占用3个字节

所以我们使用字符流可以读取中文

字符流

字符输入流【Reader】

java.io.Reader抽象类是表示用于读取字符流的所有类的超类，可以读取字符信息到内存中。它定义了字符输入流的基本共性功能方法。

• public void close() ：关闭此流并释放与此流相关联的任何系统资源。
• public int read()： 从输入流读取一个字符。返回int类型
• public int read(char[] cbuf)： 从输入流中读取一些字符，并将它们存储到字符数组 cbuf中 。返回int类型

FileReader类

java.io.FileReader类是读取字符文件的便利类。构造时使用系统默认的字符编码和默认字节缓冲区。

小贴士：

1. 字符编码：字节与字符的对应规则。Windows系统的中文编码默认是GBK编码表。

   idea中UTF-8

2. 字节缓冲区：一个字节数组，用来临时存储字节数据。

构造方法

• FileReader(File file)： 创建一个新的 FileReader ，给定要读取的File对象。
• FileReader(String fileName)： 创建一个新的 FileReader ，给定要读取的文件的名称。

当你创建一个流对象时，必须传入一个文件路径。类似于FileInputStream 。

字符输出流【Writer】

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

• void write(int c) 写入单个字符。
• void write(char[] cbuf)写入字符数组。
• abstract void write(char[] cbuf, int off, int len)写入字符数组的某一部分,off数组的开始索引,len写的字符个数。
• void write(String str)写入字符串。
• void write(String str, int off, int len) 写入字符串的某一部分,off字符串的开始索引,len写的字符个数。
• void flush()刷新该流的缓冲。
• void close() 关闭此流，但要先刷新它。

FileWriter类

java.io.FileWriter类是写出字符到文件的便利类。构造时使用系统默认的字符编码和默认字节缓冲区。

字符输出流的使用步骤(重点):
    1.创建FileWriter对象,构造方法中绑定要写入数据的目的地
    2.使用FileWriter中的方法write,把数据写入到内存缓冲区中(字符转换为字节的过程)
    3.使用FileWriter中的方法flush,把内存缓冲区中的数据,刷新到文件中
    4.释放资源(会先把内存缓冲区中的数据刷新到文件中)

构造方法

• FileWriter(File file)： 创建一个新的 FileWriter，给定要读取的File对象。
• FileWriter(String fileName)： 创建一个新的 FileWriter，给定要读取的文件的名称。

当你创建一个流对象时，必须传入一个文件路径，类似于FileOutputStream。

字符输入输出流代码

    public static void main(String[] args) throws IOException {
//        FileWriter fw = new FileWriter("b.txt");
//        fw.write("额1234r.e");
//		  fw.write(30000);
//假设没有flush或者close方法则并没有写入文件
//		  fw.flush();
//        fw.close();

        FileReader fr = new FileReader("b.txt");
        int len;
//        while ((len =fr.read()) != -1){
//            System.out.println(len);
//        }
        char[] c = new char[1024];
        while ((len=fr.read(c)) != -1){
            System.out.println(new String(c,0,len));
        }
    }

字符输出流写数据的其他方法

        char[] cs = {'a','b','c','d','e'};
        //void write(char[] cbuf)写入字符数组。
        fw.write(cs);//abcde

        //void write(char[] cbuf, int off, int len)写入字符数组的某一部分,off数组的开始索引,len写的字符个数。
        fw.write(cs,1,3);//bcd

        //void write(String str)写入字符串。
        fw.write("直接字符串");//直接字符串

        //void write(String str, int off, int len) 写入字符串的某一部分,off字符串的开始索引,len写的字符个数。
        fw.write("字符串指定",2,3);//串指定

    public static void main(String[] args) throws IOException {
        FileWriter fw = new FileWriter("bb.txt",true);//续写
        for (int i = 0; i <10 ; i++) {
            fw.write("HelloWorld"+i+"\r\n");//换行
        }
        char[] chars = "好像还有这个".toCharArray();
        fw.write(chars);
        fw.close();
    }

IO流的异常的处理

JDK7（1.7）之前的处理

在jdk1.7之前使用try catch finally 处理流中的异常
格式:
    try{
        可能会产出异常的代码
    }catch(异常类变量 变量名){
        异常的处理逻辑
    }finally{
        一定会指定的代码
        资源释放
    }

    public static void main(String[] args) {
        //提高变量fw的作用域,让finally可以使用
        //变量在定义的时候,可以没有值,但是使用的时候必须有值
        //fw = new FileWriter("w:\\A\\g.txt",true); 执行失败,fw没有值,fw.close会报错
        FileWriter fw = null;
        try{
            //可能会产出异常的代码
            fw = new FileWriter("w:\\A\\g.txt",true);
            for (int i = 0; i <10 ; i++) {
                fw.write("HelloWorld"+i+"\r\n");
            }
        }catch(IOException e){
            //异常的处理逻辑
            System.out.println(e);
        }finally {
            //一定会指定的代码
            //创建对象失败了,fw的默认值就是null,null是不能调用方法的,会抛出NullPointerException,需要增加一个判断,不是null在把资源释放
            if(fw!=null){
                try {
                    //fw.close方法声明抛出了IOException异常对象,所以我们就的处理这个异常对象,要么throws,要么try catch
                    fw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

JDK7（1.7）及其以后的处理

JDK7的新特性
在try的后边可以增加一个(),在括号中可以定义流对象
那么这个流对象的作用域就在try中有效
try中的代码执行完毕,会自动把流对象释放,不用写finally
格式:
    try(定义流对象;定义流对象....){
        可能会产出异常的代码
    }catch(异常类变量 变量名){
        异常的处理逻辑
    }

    public static void main(String[] args) {
        try(//1.创建一个字节输入流对象,构造方法中绑定要读取的数据源
            FileInputStream fis = new FileInputStream("c:\\1.jpg");
            //2.创建一个字节输出流对象,构造方法中绑定要写入的目的地
            FileOutputStream fos = new FileOutputStream("d:\\1.jpg");){

            //可能会产出异常的代码
            //一次读取一个字节写入一个字节的方式
            //3.使用字节输入流对象中的方法read读取文件
            int len = 0;
            while((len = fis.read())!=-1){
                //4.使用字节输出流中的方法write,把读取到的字节写入到目的地的文件中
                fos.write(len);
            }

        }catch (IOException e){
            //异常的处理逻辑
            System.out.println(e);
        }
    }

JDK9

JDK9新特性
try的前边可以定义流对象
在try后边的()中可以直接引入流对象的名称(变量名)
在try代码执行完毕之后,流对象也可以释放掉,不用写finally
格式:
    A a = new A();
    B b = new B();
    try(a,b){
        可能会产出异常的代码
    }catch(异常类变量 变量名){
        异常的处理逻辑
    }

    public static void main(String[] args) throws FileNotFoundException{
        //1.创建一个字节输入流对象,构造方法中绑定要读取的数据源
        FileInputStream fis = new FileInputStream("c:\\1.jpg");
        //2.创建一个字节输出流对象,构造方法中绑定要写入的目的地
        FileOutputStream fos = new FileOutputStream("d:\\1.jpg");

        try(fis;fos){
            //一次读取一个字节写入一个字节的方式
            //3.使用字节输入流对象中的方法read读取文件
            int len = 0;
            while((len = fis.read())!=-1){
                //4.使用字节输出流中的方法write,把读取到的字节写入到目的地的文件中
                fos.write(len);
            }
        }catch (IOException e){
            System.out.println(e);
        }
        //fos.write(1);//Stream Closed
    }

属性集

概述

java.util.Properties集合 extends Hashtable<k,v> implements Map<k,v>
Properties 类表示了一个持久的属性集。Properties 可保存在流中或从流中加载。

Properties集合是一个唯一和IO流相结合的集合
     可以使用Properties集合中的方法store,把集合中的临时数据,持久化写入到硬盘中存储
    !可以使用Properties集合中的方法load,把硬盘中保存的文件(键值对),读取到集合中使用（重点）

属性列表中每个键及其对应值都是一个字符串。
Properties集合是一个双列集合,key和value默认都是字符串

java.util.Properties 继承于Hashtable ，来表示一个持久的属性集。它使用键值结构存储数据，每个键及其对应值都是一个字符串。该类也被许多Java类使用，比如获取系统属性时，System.getProperties 方法就是返回一个Properties对象。

基本的存储方法

使用Properties集合存储数据,遍历取出Properties集合中的数据
Properties集合是一个双列集合,key和value默认都是字符串
Properties集合有一些操作字符串的特有方法
    Object setProperty(String key, String value) 调用 Hashtable 的方法 put。
    String getProperty(String key) 通过key找到value值,此方法相当于Map集合中的get(key)方法
    Set<String> stringPropertyNames() 返回此属性列表中的键集，其中该键及其对应值是字符串,此方法相当于Map集合中的keySet方法

    public static void main(String[] args) {
        //创建Properties集合对象
        Properties prop = new Properties();
        //使用setProperty往集合中添加数据
        prop.setProperty("两边都得是字符串","10");
        prop.setProperty("AA","上面的数字其实也是字符串");
        prop.setProperty("true","10.0");
        //prop.put(1,true);//这里可以是任意类型

        //使用stringPropertyNames把Properties集合中的键取出,存储到一个Set集合中
        Set<String> set = prop.stringPropertyNames();

        //遍历Set集合,取出Properties集合的每一个键
        for (String key : set) {
            //使用getProperty方法通过key获取value
            String value = prop.getProperty(key);
            System.out.println(key+"="+value);
        }
    }

与流相关的方法

store程序集合中的数据写入硬盘文件

    可以使用Properties集合中的方法store,把集合中的临时数据,持久化写入到硬盘中存储
    void store(OutputStream out, String comments)
    void store(Writer writer, String comments)
    参数:
        OutputStream out:字节输出流,不能写入中文
        Writer writer:字符输出流,可以写中文
        String comments:注释,用来解释说明保存的文件是做什么用的
                不能使用中文,会产生乱码,默认是Unicode编码
                一般使用""空字符串

    使用步骤:
        1.创建Properties集合对象,添加数据
        2.创建字节输出流/字符输出流对象,构造方法中绑定要输出的目的地
        3.使用Properties集合中的方法store,把集合中的临时数据,持久化写入到硬盘中存储
        4.释放资源

    public static void main(String[] args) throws IOException {
        //1.创建Properties集合对象,添加数据
        Properties prop = new Properties();
        prop.setProperty("A","1");
        prop.setProperty("B","2");
        prop.setProperty("C","3");
        prop.setProperty("中","4");

        //2.创建字符输出流对象,构造方法中绑定要输出的目的地
        FileWriter fw = new FileWriter("prop.txt");

        //3.使用Properties集合中的方法store,把集合中的临时数据,持久化写入到硬盘中存储
        prop.store(fw,"save data");//后面这个是注释

        //4.释放资源
        fw.close();

        //prop.store(new FileOutputStream("prop2.txt"),"");//字节输出流不能写中文
    }

load 文件读出到程序的集合中

    可以使用Properties集合中的方法load,把硬盘中保存的文件(键值对),读取到集合中使用
    void load(InputStream inStream)
    void load(Reader reader)
    参数:
        InputStream inStream:字节输入流,不能读取含有中文的键值对
        Reader reader:字符输入流,能读取含有中文的键值对
    使用步骤:
        1.创建Properties集合对象
        2.使用Properties集合对象中的方法load读取保存键值对的文件
        3.遍历Properties集合
    注意:
        1.存储键值对的文件中,键与值默认的连接符号可以使用=,空格(其他符号)
        2.存储键值对的文件中,可以使用#进行注释,被注释的键值对不会再被读取
        3.存储键值对的文件中,键与值默认都是字符串,不用再加引号

    public static void main(String[] args) throws IOException {
        //1.创建Properties集合对象
        Properties prop = new Properties();
        //2.使用Properties集合对象中的方法load读取保存键值对的文件
        prop.load( new FileReader("prop.txt"));
        Set<String> set = prop.stringPropertyNames();
        //3.遍历Properties集合
        for (String key : set) {
            String value = prop.getProperty(key);
            System.out.println(key + "=" + value);
        }
    }

缓冲流

概述

缓冲流,也叫高效流，是对4个基本的FileXxx 流的增强，所以也是4个流，按照数据类型分类：

• 字节缓冲流：BufferedInputStream，BufferedOutputStream
• 字符缓冲流：BufferedReader，BufferedWriter

缓冲流的基本原理，是在创建流对象时，会创建一个内置的默认大小的缓冲区数组，通过缓冲区读写，减少系统IO次数，从而提高读写的效率。

字节缓冲流

字节缓冲输出流【BufferedOutputStream】

程序输出到内部缓冲区再刷新到文件（硬盘） 代码去写入内容进硬盘
继承自父类的共性成员方法

• 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) ：将指定的字节输出流。

构造方法

• public BufferedOutputStream(OutputStream out)： 创建一个新的缓冲输出流。
• public BufferedOutputStream(OutputStream out, int size)：创建一个新的缓冲输出流，以将具有指定缓冲区大小的数据写入指定的底层输出流。

参数:

• OutputStream out:字节输出流
  我们可以传递FileOutputStream,缓冲流会给FileOutputStream增加一个缓冲区,提高FileOutputStream的写入效率
• int size:指定缓冲流内部缓冲区的大小,不指定默认

缓冲输出流代码使用

使用步骤(重点)
   1.创建FileOutputStream对象,构造方法中绑定要输出的目的地
   2.创建BufferedOutputStream对象,构造方法中传递FileOutputStream对象对象,提高FileOutputStream对象效率
   3.使用BufferedOutputStream对象中的方法write,把数据写入到内部缓冲区中
   4.使用BufferedOutputStream对象中的方法flush,把内部缓冲区中的数据,刷新到文件中
   5.释放资源(会先调用flush方法刷新数据,第4部可以省略)

    public static void main(String[] args) throws IOException {
        //1.创建FileOutputStream对象,构造方法中绑定要输出的目的地
        FileOutputStream fos = new FileOutputStream("缓冲流的a.txt");
        //2.创建BufferedOutputStream对象,构造方法中传递FileOutputStream对象对象,提高FileOutputStream对象效率
        BufferedOutputStream bos = new BufferedOutputStream(fos);
        //3.使用BufferedOutputStream对象中的方法write,把数据写入到内部缓冲区中
        bos.write("我把数据写入到内部缓冲区中".getBytes());
        //4.使用BufferedOutputStream对象中的方法flush,把内部缓冲区中的数据,刷新到文件中
        bos.flush();
        //5.释放资源(会先调用flush方法刷新数据,第4部可以省略)
        bos.close();
        fos.close();
    }

字节缓冲输入流【BufferedInputStream】

文件（硬盘）输入进缓冲区再刷新到程序中 代码去读硬盘的内容

继承自父类的共性成员方法

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

构造方法

• public BufferedInputStream(InputStream in)： 创建一个 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。
• public BufferedInputStream(InputStream in, int size)：创建具有指定缓冲区大小的 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。

参数:

• InputStream in:字节输入流
  我们可以传递FileInputStream,缓冲流会给FileInputStream增加一个缓冲区,提高FileInputStream的读取效率
• int size:指定缓冲流内部缓冲区的大小,不指定默认

缓冲输入流代码使用

使用步骤(重点):
    1.创建FileInputStream对象,构造方法中绑定要读取的数据源
    2.创建BufferedInputStream对象,构造方法中传递FileInputStream对象,提高FileInputStream对象的读取效率
    3.使用BufferedInputStream对象中的方法read,读取文件
    4.释放资源    

    public static void main(String[] args) throws IOException {
        //1.创建FileInputStream对象,构造方法中绑定要读取的数据源
        FileInputStream fis = new FileInputStream("缓冲流的a.txt");
        //2.创建BufferedInputStream对象,构造方法中传递FileInputStream对象,提高FileInputStream对象的读取效率
        BufferedInputStream bis = new BufferedInputStream(fis);
        //3.使用BufferedInputStream对象中的方法read,读取文件
        //int read()从输入流中读取数据的下一个字节。
        /*int len = 0;//记录每次读取到的字节
        while((len = bis.read())!=-1){
            System.out.println(len);
        }*/

        //int read(byte[] b) 从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中。
        byte[] bytes =new byte[1024];//存储每次读取的数据
        int len = 0; //记录每次读取的有效字节个数
        while((len = bis.read(bytes))!=-1){
            System.out.println(new String(bytes,0,len));
        }

        //4.释放资源
        bis.close();
        fis.close();
    }

字节缓冲流综合复制案例

    public static void main(String[] args) {
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;
        try {
            bis = new BufferedInputStream(new FileInputStream("1.bmp"));
            bos = new BufferedOutputStream(new FileOutputStream("1copy.bmp"));
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }

        int len;
        byte[] b = new byte[1024*4];
        try {
            while ((len=bis.read(b))!=-1){
                bos.write(b,0,len);
            }
            bos.close();
            bis.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

字符缓冲流

字符缓冲输出流【BufferedWriter】

继承自父类的共性成员方法:

• void write(int c) 写入单个字符。
• void write(char[] cbuf)写入字符数组。
• abstract void write(char[] cbuf, int off, int len)写入字符数组的某一部分,off数组的开始索引,len写的字符个数。
• void write(String str)写入字符串。
• void write(String str, int off, int len) 写入字符串的某一部分,off字符串的开始索引,len写的字符个数。
• void flush()刷新该流的缓冲。
• void close() 关闭此流，但要先刷新它。

构造方法:

• BufferedWriter(Writer out) 创建一个使用默认大小输出缓冲区的缓冲字符输出流。
• BufferedWriter(Writer out, int sz) 创建一个使用给定大小输出缓冲区的新缓冲字符输出流。

参数:

• Writer out:字符输出流
  我们可以传递FileWriter,缓冲流会给FileWriter增加一个缓冲区,提高FileWriter的写入效率
• int sz:指定缓冲区的大小,不写默认大小

特有的成员方法:
void newLine()写入一个行分隔符。会根据不同的操作系统,获取不同的行分隔符

换行:换行符号
windows:\r\n
linux:/n
mac:/r

使用

 使用步骤:
    1.创建字符缓冲输出流对象,构造方法中传递字符输出流
    2.调用字符缓冲输出流中的方法write,把数据写入到内存缓冲区中
    3.调用字符缓冲输出流中的方法flush,把内存缓冲区中的数据,刷新到文件中
    4.释放资源

    public static void main(String[] args) throws IOException {
        //1.创建字符缓冲输出流对象,构造方法中传递字符输出流
        BufferedWriter bw = new BufferedWriter(new FileWriter("bw写的.txt"));
        //2.调用字符缓冲输出流中的方法write,把数据写入到内存缓冲区中
        for (int i = 0; i <10 ; i++) {
            bw.write("BufferedWriter");
            //bw.write("\r\n");
            bw.newLine();
        }
        //3.调用字符缓冲输出流中的方法flush,把内存缓冲区中的数据,刷新到文件中
        bw.flush();
        //4.释放资源
        bw.close();
    }

字符缓冲输入流【BufferedReader】

继承自父类的共性成员方法:

• int read()读取单个字符并返回。
• int read(char[] cbuf)一次读取多个字符,将字符读入数组。
• void close() 关闭该流并释放与之关联的所有资源。

构造方法:
-BufferedReader(Reader in) 创建一个使用默认大小输入缓冲区的缓冲字符输入流。
-BufferedReader(Reader in, int sz) 创建一个使用指定大小输入缓冲区的缓冲字符输入流。

• Reader in:字符输入流
  我们可以传递FileReader,缓冲流会给FileReader增加一个缓冲区,提高FileReader的读取效率

特有的成员方法:

• String readLine()读取一个文本行。读取一行数据
  行的终止符号:通过下列字符之一即可认为某行已终止：换行 (’\n’)、回车 (’\r’) 或回车后直接跟着换行(\r\n)。
• 返回值:
  包含该行内容的字符串，不包含任何行终止符，如果已到达流末尾，则返回 null

使用

 使用步骤:
    1.创建字符缓冲输入流对象,构造方法中传递字符输入流
    2.使用字符缓冲输入流对象中的方法read/readLine读取文本
    3.释放资源

    public static void main(String[] args) throws IOException {
        //1.创建字符缓冲输入流对象,构造方法中传递字符输入流
        BufferedReader br = new BufferedReader(new FileReader("bw写的.txt"));
        //去读刚刚bw写的

        //2.使用字符缓冲输入流对象中的方法read/readLine读取文本
//        String line = br.readLine();
//        System.out.println(line);//如果只有两行则 第一行
//
//        line = br.readLine();
//        System.out.println(line);//第二行
//
//        line = br.readLine();
//        System.out.println(line);//null
//
//        line = br.readLine();
//        System.out.println(line);//null

        /*
            发下以上读取是一个重复的过程,所以可以使用循环优化
            不知道文件中有多少行数据,所以使用while循环
            while的结束条件,读取到null结束
         */
        String line;
        while((line = br.readLine())!=null){
            System.out.println(line);
        }

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

对文本排序

    public static void main(String[] args) throws IOException {
        //1.创建一个HashMap集合对象,可以:存储每行文本的序号(1,2,3,..);value:存储每行的文本
        HashMap<String,String> map = new HashMap<>();
        //2.创建字符缓冲输入流对象,构造方法中绑定字符输入流
        BufferedReader br = new BufferedReader(new FileReader("10_IO\\in.txt"));
        //3.创建字符缓冲输出流对象,构造方法中绑定字符输出流
        BufferedWriter bw = new BufferedWriter(new FileWriter("10_IO\\out.txt"));
        //4.使用字符缓冲输入流中的方法readline,逐行读取文本
        String line;
        while((line = br.readLine())!=null){
            //5.对读取到的文本进行切割,获取行中的序号和文本内容
            String[] arr = line.split("\\.");
            //6.把切割好的序号和文本的内容存储到HashMap集合中(key序号是有序的,会自动排序1,2,3,4..)
            map.put(arr[0],arr[1]);
        }

        //7.遍历HashMap集合,获取每一个键值对
        for(String key : map.keySet()){
            String value = map.get(key);
            //8.把每一个键值对,拼接为一个文本行
            line = key + "." + value;
            //9.把拼接好的文本,使用字符缓冲输出流中的方法write,写入到文件中
            bw.write(line);
            bw.newLine();//写换行
        }
        //10.释放资源
        bw.close();
        br.close();
    }

转换流

字符编码和字符集

字符编码

按照某种规则，将字符存储到计算机中，称为编码 。反之，将存储在计算机中的二进制数按照某种规则解析显示出来，称为解码 。比如说，按照A规则存储，同样按照A规则解析，那么就能显示正确的文本符号。反之，按照A规则存储，再按照B规则解析，就会导致乱码现象。

编码:字符(能看懂的)–字节(看不懂的)

解码:字节(看不懂的)–>字符(能看懂的)

• 字符编码Character Encoding : 就是一套自然语言的字符与二进制数之间的对应规则。

  编码表:生活中文字和计算机中二进制的对应规则

字符集

• 字符集 Charset：也叫编码表。是一个系统支持的所有字符的集合，包括各国家文字、标点符号、图形符号、数字等。

计算机要准确的存储和识别各种字符集符号，需要进行字符编码，一套字符集必然至少有一套字符编码。常见字符集有ASCII字符集、GBK字符集、Unicode字符集等。[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-r67QQIpy-1596503499804)(img/1_charset.jpg)]

可见，当指定了编码，它所对应的字符集自然就指定了，所以编码才是我们最终要关心的。

• ASCII字符集 ：
  • ASCII用于显示现代英语，主要包括控制字符（回车键、退格、换行键等）和可显示字符（英文大小写字符、阿拉伯数字和西文符号）。
  • 基本的ASCII字符集，使用7位（bits）表示一个字符，共128字符。ASCII的扩展字符集使用8位（bits）表示一个字符，共256字符，方便支持欧洲常用字符。
• ISO-8859-1字符集：
  • 拉丁码表，别名Latin-1，用于显示欧洲使用的语言，包括荷兰、丹麦、德语、意大利语、西班牙语等。
  • ISO-8859-1使用单字节编码，兼容ASCII编码。
• GBxxx字符集：
  • GB就是国标的意思，是为了显示中文而设计的一套字符集。
  • GB2312：简体中文码表。一个小于127的字符的意义与原来相同。但两个大于127的字符连在一起时，就表示一个汉字，这样大约可以组合了包含7000多个简体汉字，此外数学符号、罗马希腊的字母、日文的假名们都编进去了，连在ASCII里本来就有的数字、标点、字母都统统重新编了两个字节长的编码，这就是常说的"全角"字符，而原来在127号以下的那些就叫"半角"字符了。
  • GBK：最常用的中文码表。是在GB2312标准基础上的扩展规范，使用了双字节编码方案，共收录了21003个汉字，完全兼容GB2312标准，同时支持繁体汉字以及日韩汉字等。
  • GB18030：最新的中文码表。收录汉字70244个，采用多字节编码，每个字可以由1个、2个或4个字节组成。支持中国国内少数民族的文字，同时支持繁体汉字以及日韩汉字等。
• Unicode字符集 ：
  • Unicode编码系统为表达任意语言的任意字符而设计，是业界的一种标准，也称为统一码、标准万国码。
  • 它最多使用4个字节的数字来表达每个字母、符号，或者文字。有三种编码方案，UTF-8、UTF-16和UTF-32。最为常用的UTF-8编码。
  • UTF-8编码，可以用来表示Unicode标准中任何字符，它是电子邮件、网页及其他存储或传送文字的应用中，优先采用的编码。互联网工程工作小组（IETF）要求所有互联网协议都必须支持UTF-8编码。所以，我们开发Web应用，也要使用UTF-8编码。它使用一至四个字节为每个字符编码，编码规则：
    1. 128个US-ASCII字符，只需一个字节编码。
    2. 拉丁文等字符，需要二个字节编码。
    3. 大部分常用字（含中文），使用三个字节编码。
    4. 其他极少使用的Unicode辅助字符，使用四字节编码。

编码引出的问题

在IDEA中，使用FileReader 读取项目中的文本文件。由于IDEA的设置，都是默认的UTF-8编码，所以没有任何问题。但是，当读取Windows系统中创建的文本文件时，由于Windows系统的默认是GBK编码，就会出现乱码。

    public static void main(String[] args) throws IOException {
        FileReader fileReader = new FileReader("File_GBK.txt");
        int read;
        while ((read = fileReader.read()) != -1) {
            System.out.print((char)read);
        }
        fileReader.close();
    }
输出结果：
���

OutputStreamWriter类

转换流java.io.OutputStreamWriter ，是Writer的子类，是从字符流到字节流的桥梁。使用指定的字符集将字符编码为字节。它的字符集可以由名称指定，也可以接受平台的默认字符集。
(编码:把能看懂的变成看不懂)

构造方法

• OutputStreamWriter(OutputStream in): 创建一个使用默认字符集的字符流。
• OutputStreamWriter(OutputStream in, String charsetName): 创建一个指定字符集的字符流。
  参数:
  • OutputStream out:字节输出流,可以用来写转换之后的字节到文件中
  • String charsetName:指定的编码表名称,不区分大小写,可以是utf-8/UTF-8,gbk/GBK,…不指定默认使用UTF-8

使用

使用步骤:
    1.创建OutputStreamWriter对象,构造方法中传递字节输出流和指定的编码表名称
    2.使用OutputStreamWriter对象中的方法write,把字符转换为字节存储缓冲区中(编码)
    3.使用OutputStreamWriter对象中的方法flush,把内存缓冲区中的字节刷新到文件中(使用字节流写字节的过程)
    4.释放资源

    public static void main(String[] args) throws IOException {
        //write_utf_8();
        write_gbk();
    }

    private static void write_gbk() throws IOException {
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("OutputStreamWriter_gbk.txt"),"gbk");
        osw.write("gbk编码");
        osw.flush();
        osw.close();
    }

    private static void write_utf_8() throws IOException {
        //1.创建OutputStreamWriter对象,构造方法中传递字节输出流和指定的编码表名称
        //OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("10_IO\\utf_8.txt"),"utf-8");
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("OutputStreamWriter_utf-8.txt"));//不指定,则默认使用UTF-8
        //2.使用OutputStreamWriter对象中的方法write,把字符转换为字节存储缓冲区中(编码)
        osw.write("UTF-8编码");
        //3.使用OutputStreamWriter对象中的方法flush,把内存缓冲区中的字节刷新到文件中(使用字节流写字节的过程)
        osw.flush();
        //4.释放资源
        osw.close();
    }

InputStreamReader类

转换流java.io.InputStreamReader，是Reader的子类，是从字节流到字符流的桥梁。它读取字节，并使用指定的字符集将其解码为字符。它的字符集可以由名称指定，也可以接受平台的默认字符集。
(解码:把看不懂的变成能看懂的)

构造方法

• InputStreamReader(InputStream in): 创建一个使用默认字符集的字符流。
• InputStreamReader(InputStream in, String charsetName): 创建一个指定字符集的字符流。
  参数:
  • InputStream in:字节输入流,用来读取文件中保存的字节
  • String charsetName:指定的编码表名称,不区分大小写,可以是utf-8/UTF-8,gbk/GBK,…不指定默认使用UTF-8

使用

 使用步骤:
    1.创建InputStreamReader对象,构造方法中传递字节输入流和指定的编码表名称
    2.使用InputStreamReader对象中的方法read读取文件
    3.释放资源
 注意事项:
    构造方法中指定的编码表名称要和文件的编码相同,否则会发生乱码

    public static void main(String[] args) throws IOException {
        read_utf_8();
        //read_gbk();
    }
    private static void read_gbk() throws IOException {
        //1.创建InputStreamReader对象,构造方法中传递字节输入流和指定的编码表名称
        //InputStreamReader isr = new InputStreamReader(new FileInputStream("OutputStreamWriter_gbk.txt"));//输出乱码
        InputStreamReader isr = new InputStreamReader(new FileInputStream("OutputStreamWriter_gbk.txt"),"gbk");
        int len;
        char[] c = new char[1024];
        //2.使用InputStreamReader对象中的方法read读取文件
        while ((len=isr.read(c))!=-1){
            System.out.println(new String(c,0,len));
        }
        //3.释放资源
        isr.close();
    }

    private static void read_utf_8() throws IOException {
        //1.创建InputStreamReader对象,构造方法中传递字节输入流和指定的编码表名称
        //InputStreamReader isr = new InputStreamReader(new FileInputStream("OutputStreamWriter_utf-8.txt"),"UTF-8");
        InputStreamReader isr = new InputStreamReader(new FileInputStream("OutputStreamWriter_utf-8.txt"));//不指定默认使用UTF-8
        //2.使用InputStreamReader对象中的方法read读取文件
        int len = 0;
        while((len = isr.read())!=-1){
            System.out.println((char)len);
        }
        //3.释放资源
        isr.close();
    }

练习：转换文件编码

将GBK编码的文本文件，转换为UTF-8编码的文本文件。

    public static void main(String[] args) throws IOException {
        InputStreamReader isr = new InputStreamReader(new FileInputStream("OutputStreamWriter_gbk.txt"),"gbk");
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("gbk转换为utf-8.txt"));//不写默认u8
        int len;
        char[] c = new char[1024];
        osw.write("之前是");
        while ((len= isr.read(c))!=-1){
            osw.write(c,0,len);
        }
        osw.write("\n现在变成了UTF-8编码");
        osw.flush();
        osw.close();
        isr.close();
    }

序列化

概述

Java 提供了一种对象序列化的机制。用一个字节序列可以表示一个对象，该字节序列包含该对象的数据、对象的类型和对象中存储的属性等信息。字节序列写出到文件之后，相当于文件中持久保存了一个对象的信息。

反之，该字节序列还可以从文件中读取回来，重构对象，对它进行反序列化。对象的数据、对象的类型和对象中存储的数据信息，都可以用来在内存中创建对象。看图理解序列化： [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-orHr1dvL-1596508952930)(img/3_xuliehua.jpg)]

ObjectOutputStream类

java.io.ObjectOutputStream 类，将Java对象的原始数据类型写出到文件,实现对象的持久存储。

方法

构造方法

• public ObjectOutputStream(OutputStream out)： 创建一个指定OutputStream的ObjectOutputStream。

特有的成员方法:

• void writeObject(Object obj) 将指定的对象写入 ObjectOutputStream。

序列化操作

使用步骤:
    1.创建ObjectOutputStream对象,构造方法中传递字节输出流
    2.使用ObjectOutputStream对象中的方法writeObject,把对象写入到文件中
    3.释放资源

1.先标记类
一个对象要想序列化，必须满足两个条件:

• 该类必须实现java.io.Serializable 接口，Serializable 是一个标记接口，不实现此接口的类将不会使任何状态序列化或反序列化，会抛出NotSerializableException 。
• 该类的所有属性必须是可序列化的。如果有一个属性不需要可序列化的，则该属性必须注明是瞬态的，使用transient 关键字修饰。

public class Person implements Serializable{
    private String name;
    private static int age;//这里也没有被序列化
    //    static关键字:静态关键字
    //    静态优先于非静态加载到内存中(静态优先于对象进入到内存中)
    //    被static修饰的成员变量不能被序列化的,序列化的都是对象
    private transient int sno;//不需要可序列化的
    
    .
    .省略其他方法
    .
}

2.写出对象方法

• public final void writeObject (Object obj) : 将指定的对象写出。

    public static void main(String[] args) throws IOException {
        //1.创建ObjectOutputStream对象,构造方法中传递字节输出流
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person.txt"));
        //2.使用ObjectOutputStream对象中的方法writeObject,把对象写入到文件中
        oos.writeObject(new Person(1,"张三",18));
        //3.释放资源
        oos.close();
    }

ObjectInputStream类

ObjectInputStream反序列化流，将之前使用ObjectOutputStream序列化的原始数据恢复为对象。

方法

构造方法

• public ObjectInputStream(InputStream in)： 创建一个指定InputStream的ObjectInputStream。

特有的成员方法:

• Object readObject() 从 ObjectInputStream 读取对象。

反序列化操作1

 readObject方法声明抛出了ClassNotFoundException(class文件找不到异常)
 当不存在对象的class文件时抛出此异常
 反序列化的前提:
    1.类必须实现Serializable
    2.必须存在类对应的class文件

    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //1.创建ObjectInputStream对象,构造方法中传递字节输入流
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("person.txt"));
        //2.使用ObjectInputStream对象中的方法readObject读取保存对象的文件
        Object o = ois.readObject();
        //3.释放资源
        ois.close();
        //4.使用读取出来的对象(打印)
        System.out.println(o);//Person{name='张三', sno=0, age=0}
        Person p = (Person)o;
        System.out.println(p.getSno()+p.getName()+p.getAge());//0张三0
        		sno被transient标记所以没有被序列化		age被static修饰也没被序列化
    }

反序列化操作2

当JVM反序列化对象时，能找到class文件，但是class文件在序列化对象之后发生了修改，那么反序列化操作也会失败，抛出一个InvalidClassException异常
发生这个异常的原因如下：

• 该类的序列版本号与从流中读取的类描述符的版本号不匹配
• 该类包含未知数据类型
• 该类没有可访问的无参数构造方法

Serializable 接口给需要序列化的类，提供了一个序列版本号。serialVersionUID 该版本号的目的在于验证序列化的对象和对应类是否版本匹配。

解决方案

public class Person implements Serializable{
	// 加入序列版本号
    private static final long serialVersionUID = 1L;
    private String name;
    private static int age;//这里也没有被序列化
    //    static关键字:静态关键字
    //    静态优先于非静态加载到内存中(静态优先于对象进入到内存中)
    //    被static修饰的成员变量不能被序列化的,序列化的都是对象
    private transient int sno;//不需要可序列化的
    
    .
    .省略其他方法
    .
}

练习：序列化集合

练习：序列化集合
    当我们想在文件中保存多个对象的时候
    可以把多个对象存储到一个集合中
    对集合进序列化和反序列化
分析:
    1.定义一个存储Person对象的ArrayList集合
    2.往ArrayList集合中存储Person对象
    3.创建一个序列化流ObjectOutputStream对象
    4.使用ObjectOutputStream对象中的方法writeObject,对集合进行序列化
    5.创建一个反序列化ObjectInputStream对象
    6.使用ObjectInputStream对象中的方法readObject读取文件中保存的集合
    7.把Object类型的集合转换为ArrayList类型
    8.遍历ArrayList集合
    9.释放资源

    public static void main(String[] args) throws IOException, ClassNotFoundException {
        ArrayList<Person> list = new ArrayList<>();
        list.add(new Person("张三",11));
        list.add(new Person("李四",12));
        list.add(new Person("王五",13));

        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("list.txt"));
        oos.writeObject(list);
        oos.flush();

        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("list.txt"));
        //6.使用ObjectInputStream对象中的方法readObject读取文件中保存的集合
        Object o = ois.readObject();
        //7.把Object类型的集合转换为ArrayList类型
        ArrayList<Person> getList = (ArrayList<Person>)o;


        System.out.println(getList);
        ois.close();
        oos.close();
    }

打印流

概述

平时我们在控制台打印输出，是调用print方法和println方法完成的，这两个方法都来自于java.io.PrintStream类，该类能够方便地打印各种数据类型的值，是一种便捷的输出方式。

PrintStream类

PrintStream特点:
    1.只负责数据的输出,不负责数据的读取
    2.与其他输出流不同，PrintStream 永远不会抛出 IOException

方法

    PrintStream(File file):输出的目的地是一个文件
    PrintStream(OutputStream out):输出的目的地是一个字节输出流
    PrintStream(String fileName) :输出的目的地是一个文件路径
PrintStream extends OutputStream

构造方法

• public PrintStream(File file):输出的目的地是一个文件
• public PrintStream(OutputStream out):输出的目的地是一个字节输出流
• public PrintStream(String fileName)： 输出的目的地是一个文件路径 使用指定的文件名创建一个新的打印流。

继承自父类的成员方法:

• 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)：将指定的字节输出流。
• 注意:
  • 如果使用继承自父类的write方法写数据,那么查看数据的时候会查询编码表 97->a
  • 如果使用自己特有的方法print/println方法写数据,写的数据原样输出 97->97

普通使用

    public static void main(String[] args) throws FileNotFoundException {
        //创建打印流PrintStream对象,构造方法中绑定要输出的目的地
        PrintStream ps = new PrintStream("print.txt");
        //如果使用继承自父类的write方法写数据,那么查看数据的时候会查询编码表 97->a
        ps.write(97);
        //如果使用自己特有的方法print/println方法写数据,写的数据原样输出 97->97
        ps.println(97);
        ps.println(8.8);
        ps.println('a');
        ps.println("HelloWorld");
        ps.println(true);

        //释放资源
        ps.close();
    }

改变打印流向

System.out就是PrintStream类型的，只不过它的流向是系统规定的，打印在控制台上。不过，既然是流对象，我们就可以玩一个"小把戏"，改变它的流向。

public class PrintDemo {
    public static void main(String[] args) throws IOException {
		// 调用系统的打印流,控制台直接输出97
        System.out.println(97);
      
		// 创建打印流,指定文件的名称
        PrintStream ps = new PrintStream("ps.txt");
      	
      	// 设置系统的打印流流向,输出到ps.txt
        System.setOut(ps);//从这之后的System输出都改到了ps文件中去了
      	// 调用系统的打印流,ps.txt中输出a
        System.out.println("a");
        try {
            int i = 1/0;
        }catch (ArithmeticException e){
            System.out.println(e);
            System.out.println("除0异常");
        }
    }
}
控制台中
	97
ps中
	a
	java.lang.ArithmeticException: / by zero
	除0异常