java IO (一)

接下篇

一、File类

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

File类的构造方法

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

import java.io.File;

/**
 * @Author：
 * @Date: 2020/9/20 9:06
 */
public class Test {
    public static void main(String[] args) {
        // 创建File对象表示H:\aaa\hb.jpg文件路径
        File f1 = new File("H:\\aaa\\hb.jpg");
        File f2 = new File("H:\\aaa","hb.jpg");
        File parent = new File("H:\\aaa");
        File f3 = new File(parent, "hb.jpg");
        System.out.println(f1);
        System.out.println(f2);
        System.out.println(f3);

        System.out.println("=========================================");
        // 创建File对象表示H:\aaa\2020文件夹路径
        File f4 = new File("H:\\aaa\\2020");
        File f5 = new File("H:\\aaa","2020");
        File f6 = new File(parent,"2020");
        System.out.println(f4);
        System.out.println(f5);
        System.out.println(f6);

        System.out.println("=========================================");
        // 路径不存在的
        File f7 = new File("H:\\aaa\\b.txt");// b.txt文件是不存在的
        File f8 = new File("H:\\aaa\\2018");// 2018文件夹是不存在的
        System.out.println(f7);
        System.out.println(f8);
    }
}

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

File类常用方法

绝对路径和相对路径

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

获取功能的方法

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

• public String getPath() ：将此File转换为路径名字符串。 获取构造路径（构造方法中传入的路径）

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

• public long length() ：返回由此File表示的文件的字节大小。 不能获取目录的字节大小，返回值未指定。

public class Test {
    public static void main(String[] args) {
        /*
            程序中:
               绝对路径:G:\szit104\day12\aaa\hb.jpg
               相对路径:day12\aaa\hb.jpg
         */
        // 绝对路径
        File f11 = new File("G:\\szit104\\day12\\aaa\\hb.jpg");

        // 相对路径
        File f22 = new File("day12\\aaa\\hb.jpg");

        System.out.println(f1);
        System.out.println(f2);
        
        // 创建File对象,表示day12\aaa\hb.jpg文件的路径
        File f1 = new File("day12\\aaa\\hb.jpg");
        System.out.println("f1的绝对路径:"+f1.getAbsolutePath());// G:\szit104\day12\aaa\hb.jpg  G:\szit104为项目工作目录
        System.out.println("f1的构造路径:"+f1.getPath());// day12\aaa\hb.jpg
        System.out.println("f1的文件名:"+f1.getName());// hb.jpg
        System.out.println("f1的字节大小:"+f1.length());// 24,666 字节

        // 创建File对象,表示day12\aaa\bbb文件夹的路径
        File f2 = new File("day12\\aaa\\bbb");
        System.out.println("f2的绝对路径:"+f2.getAbsolutePath());// G:\szit104\day12\aaa\bbb
        System.out.println("f2的构造路径:"+f2.getPath());// day12\aaa\bbb
        System.out.println("f2的文件名:"+f2.getName());// bbb
        System.out.println("f2的字节大小:"+f2.length());// 0
    }
}

判断功能的方法

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

创建删除功能的方法

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

File类遍历目录方法

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

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

import java.io.File;

/**
 * @Author：
 * @Date: 
 */
public class Test {
    public static void main(String[] args) {
        /*
            File类遍历目录方法:
                - public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或子目录的名称。
                - public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或子目录的路径。
         */
        // 创建File对象,表示day12\aaa文件夹
        File f = new File("day12\\aaa");
        // 获取f路径下的所有子文件和子文件夹的名称
        String[] arr1 = f.list();
        // 循环遍历
        for (String s : arr1) {
            System.out.println(s);
        }

        System.out.println("==============================");

        // 获取f路径下的所有子文件和子文件夹的路径
        File[] arr2 = f.listFiles();
        // 循环遍历
        for (File file : arr2) {
            System.out.println(file);
        }

        System.out.println("==============================");

        // 注意:如果文件夹没有访问权限,那么返回的就是null,遍历就会报空指针异常
        File f1 = new File("H:\\System Volume Information");
        String[] list = f1.list();
        File[] files = f1.listFiles();
        System.out.println(list+","+files);// null,null
        // 报异常,为了代码的健壮性,所以循环之前加一个非空判断
        if (list != null) {
            for (String s : list) {

            }
        }

    }
}

二、递归

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

递归的注意事项:

• 递归要有出口(结束方法),否则会报栈内存溢出错误StackOverflowError
• 递归的出口不能太晚了

什么时候用递归：同类事物相包含。

public class Test {
    static int count = 0;
    public static void main(String[] args) {
        /*
            程序中的递归: 指在当前方法内调用自己的这种现象
            注意事项:
                1.递归一定要有出口,否则会报栈内存溢出错误StackOverflowError
                2.递归出口太晚了（递归深度要适当）,还是会报栈内存溢出错误StackOverflowError
            解决办法:合理递归
         */
        method();
    }

    public static void method(){
        count++;
        if (count == 70000){
            return;
        }
        System.out.println("method 方法执行了...");
        method();
    }
}

三、IO

3.1 IO的概述

• I : Input 输入 从其他存储设备读数据到内存中就是输入
• O : Output 输出 从内存中写数据到其他存储设备

3.2 IO的分类

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

• 输入流 ：把数据从其他设备上读取到内存中的流。
  • 字节输入流:以字节为基本单位,读数据
  • 字符输入流:以字符为基本单位,读数据
• 输出流 ：把数据从内存 中写出到其他设备上的流。
  • 字节输出流:以字节为基本单位,写出数据
  • 字符输出流:以字符为基本单位,写出数据

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

• 字节流 ：以字节为单位，读写数据的流。
  • 字节输入流:以字节为基本单位,读数据
  • 字节输出流:以字节为基本单位,写出数据
• 字符流 ：以字符为单位，读写数据的流。
  • 字符输入流:以字符为基本单位,读数据
  • 字符输出流:以字符为基本单位,写出数据

IO的顶层父类

 字节输入流:顶层父类是InputStream抽象类,常见的子类FileInputStream
 字节输出流:顶层父类是OutputStream抽象类,常见的子类FileOutputStream
 字符输入流:顶层父类是Reader抽象类,常见的子类FileReader
 字符输出流:顶层父类是Writer抽象类,常见的子类FileWriter

注意事项

• utf8编码一个中文占3个字节,gbk编码一个中文占2个字节
• 如果存储和解析的编码不一致就会乱码
• idea默认编码是utf8
  

四、字节流

1、字节输出流【OutputStream】

OutputStream类的概述

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

OutputStream类的常用方法

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

小贴士：

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

FileOutputStream类

FileOutputStream类的概述

java.io.FileOutputStream类是OutputStream类的子类,用来表示是文件输出流，用于将数据写出到文件。

FileOutputStream类的构造方法

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

当你创建一个流对象时，必须传入一个文件路径。该路径下，如果没有这个文件，会创建该文件。如果有这个文件，会清空这个文件的数据。

写出字节：write(int b) 方法，每次可以写出一个字节数据，

小贴士：

1. 虽然参数为int类型四个字节，但是只会保留一个字节的信息写出。
2. 流操作完毕后，必须释放系统资源，调用close方法，千万记得。

写出字节数组：write(byte[] b)，每次可以写出数组中的数据，代码使用演示：

public class Test3 {
    public static void main(String[] args) throws Exception{
        /*
            FileOutputStream类的写出数据:
                - public void write(byte[] b)：将 b.length字节从指定的字节数组写入此输出流。
                - public void close() ：关闭此输出流并释放与此流相关联的任何系统资源。
         */
        // 创建字节输出流,关联目的地文件路径
        FileOutputStream fos = new FileOutputStream("day12\\bbb\\b.txt");
        // 创建字节数组,并存储字节数据
        byte[] bys = {97,98,99,100};
        // 写出该字节数组中的字节数据
        fos.write(bys);
        // 关闭流,释放资源
        fos.close();
    }
}

写出指定长度字节数组：write(byte[] b, int off, int len) ,每次写出从off索引开始，len个字节，

数据追加续写

每次程序运行，创建输出流对象，都会清空目标文件中的数据。如何保留目标文件中数据，还能继续添加新数据呢？

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

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

public class Test5 {
    public static void main(String[] args) throws Exception{
        /*
            数据追加续写:
                - public FileOutputStream(File file, boolean append)： 创建文件输出流以写入由指定的 File对象表示的文件。
                - public FileOutputStream(String name, boolean append)： 创建文件输出流以指定的名称写入文件。
                参数append: 如果是true,就表示追加续写(不清空),如果是false,就清空原文件中的数据
                注意:
                    1.当你创建一个字节输出流对象时，必须传入一个文件路径。
                    2.该路径下，如果没有这个文件，会创建该文件(空的)。
                    3.如果有这个文件，并且第二个参数为true,就不清空,如果第二个参数为false,就清空
         */
        // 创建字节输出流对象,关联目的地文件路径(day12\bbb\a.txt)
        FileOutputStream fos = new FileOutputStream("day12\\bbb\\a.txt",true);
        // 写出数据
        fos.write(97);
        // 关闭流,释放资源
        fos.close();

    }
}

写出换行

Windows系统里，换行符号是\r\n

public class FOSWrite {
    public static void main(String[] args) throws IOException {
          // 需求: 把这首诗写入day15\\aaa\\d.txt文件中
        // String类 byte[] getBytes();把一个字符串转换为一个字节数组
        // 创建字节输出流对象,关联目的地文件路径
        FileOutputStream fos = new FileOutputStream("day15\\aaa\\d.txt");
        // 写出数据
        fos.write("吟诗一首".getBytes());
        fos.write("\r\n".getBytes());
        fos.write("看这风景美如画".getBytes());
        fos.write("\r\n".getBytes());
        fos.write("吟诗一首赠天下".getBytes());
        fos.write("\r\n".getBytes());
        fos.write("奈何本人没文化".getBytes());
        fos.write("\r\n".getBytes());
        fos.write("只能卧槽浪好大".getBytes());

        // 关闭流,释放资源
        fos.close();
    }
}

• 回车符\r和换行符\n ：
  • 回车符：回到一行的开头（return）。
  • 换行符：下一行（newline）。
• 系统中的换行：

  • Windows系统里，每行结尾是 回车+换行 ，即\r\n；

  • Unix系统里，每行结尾只有 换行 ，即\n；

  • Mac系统里，每行结尾是 回车 ，即\r。从 Mac OS X开始与Linux统一。

2、字节输入流【InputStream】

InputStream类的概述

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

InputStream类的常用方法

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

小贴士：

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

FileInputStream类

FileInputStream类的概述

java.io.FileInputStream类是InputStream类的子类 , 用来表示文件输入流，从文件中读取字节。

FileInputStream类的构造方法

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

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

FileInputStream类的读取数据

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

小贴士：

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

使用字节数组读取：read(byte[] b)，每次读取b的长度个字节到数组中，返回读取到的有效字节个数，读取到末尾时，返回-1

小贴士：

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

五、字符流

当使用字节流读取文本文件时，可能会有一个小问题。就是遇到中文字符时，可能不会显示完整的字符，那是因为一个中文字符可能占用多个字节存储。所以Java提供一些字符流类，以字符为单位读写数据，专门用于处理文本文件。

1、字符输入流【Reader】

字符输入流Reader类的概述

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

字符输入流Reader类的常用方法

• public void close() ：关闭此流并释放与此流相关联的任何系统资源。

• public int read()： 从输入流读取一个字符。
  字符读取，作为0到65535（ 0x00-0xffff ）范围内的整数，如果已经达到流的末尾，则为-1。

• public int read(char[] cbuf)： 从输入流中读取一些字符，并将它们存储到字符数组 cbuf中 。
  读取的字符数，如果已经达到流的结尾，则为-1

FileReader类

FileReader类的概述

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

FileReader类的构造方法

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

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

public class Test1 {
    public static void main(String[] args) throws Exception{
        /*
            概述:java.io.FileReader类继承Reader类,表示字符输入流,用来读取字符数据
            构造方法:
                - FileReader(File file)： 创建一个新的 FileReader ，给定要读取的File对象。
                - FileReader(String fileName)： 创建一个新的 FileReader ，给定要读取的文件的名称。
            注意:
                    1.当你创建一个输入流对象时，必须传入一个文件路径。
                    2.该路径下，如果没有该文件,会抛出FileNotFoundException
         */
        // 文件存在:
        // 创建字符输入流对象,关联数据源文件路径
        FileReader fr1 = new FileReader("day12\\ddd\\a.txt");
        FileReader fr2 = new FileReader(new File("day12\\ddd\\a.txt"));

        // 文件不存在:
        FileReader fr3 = new FileReader("day12\\ddd\\b.txt");// 报文件找不到异常
    }
}

读取字符：read方法，每次可以读取一个字符的数据，提升为int类型，读取到文件末尾，返回-1
使用字符数组读取：read(char[] cbuf)，每次读取多个字符到数组中，返回读取到的有效字符个数，读取到末尾时，返回-1

2、字符输出流【Writer】

字符输出流Writer类的概述

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

字符输出流Writer类的常用方法

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

FileWriter类

FileWriter类的概述

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

FileWriter类的构造方法

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

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

public class Test1 {
    public static void main(String[] args) throws Exception{
        /*
            概述:java.io.FileWriter是Writer的子类,表示字符输出流,可以用来写出字符数据
            构造方法:
                - FileWriter(File file)： 创建一个新的 FileWriter，给定要读取的File对象。
                - FileWriter(String fileName)： 创建一个新的 FileWriter，给定要读取的文件的名称。
                - FileWriter(File file,boolean append)： 创建一个新的 FileWriter，给定要读取的File对象。
                - FileWriter(String fileName,boolean append)： 创建一个新的 FileWriter，给定要读取的文件的名称。
            注意:
                    1.当你创建一个字符输出流对象时，必须传入一个文件路径。
                    2.前面2个构造方法,传入的路径，如果没有这个文件，会创建该文件(空的),如果有这个文件,就会清空。
                    3.后面2个构造方法,传入的路径, 如果没有这个文件，会创建该文件(空的),如果有这个文件，并且第二个参数为true,就不清空,如果第二个参数为false,就清空
         */
        // 文件存在
        FileWriter fw1 = new FileWriter("day12\\ddd\\b.txt",true);

        // 文件不存在
        FileWriter fw2 = new FileWriter("day12\\ddd\\c.txt");

    }
}

FileWriter类写出数据

写出字符：write(int b) 方法，每次可以写出一个字符数据

public class Test2 {
    public static void main(String[] args) throws Exception{
        /*
            - public void write(int c) ：写出一个字符。
         */
        // 创建字符输出流对象,关联目的地文件路径
        FileWriter fw = new FileWriter("day12\\ddd\\d.txt");

        // 写出单个字符
        fw.write('a');
        fw.write('b');

        // 关闭流,释放资源
        fw.close();
    }
}

小贴士：

1. 虽然参数为int类型四个字节，但是只会保留一个字符的信息写出。
2. 未调用close方法，数据只是保存到了缓冲区，并未写出到文件中。
   写出字符数组 ：write(char[] cbuf) 和 write(char[] cbuf, int off, int len) ，每次可以写出字符数组中的数据，用法类似FileOutputStream

写出字符串：write(String str) 和 write(String str, int off, int len) ，每次可以写出字符串中的数据
续写和换行：操作类似于FileOutputStream。

public class FWWrite {
    public static void main(String[] args) throws IOException {
        // 使用文件名称创建流对象，可以续写数据
        FileWriter fw = new FileWriter("fw.txt"，true);     
      	// 写出字符串
        fw.write("ab");
      	// 写出换行
      	fw.write("\r\n");
      	// 写出字符串
  		fw.write("cd");
      	// 关闭资源
        fw.close();
    }
}

小贴士：字符流，只能操作文本文件，不能操作图片，视频等非文本文件。

当我们单纯读或者写文本文件时  使用字符流 其他情况使用字节流

关闭和刷新

因为内置缓冲区的原因，如果不关闭输出流，无法写出字符到文件中。但是关闭的流对象，是无法继续写出数据的。如果我们既想写出数据，又想继续使用流，就需要flush 方法了。

• flush ：刷新缓冲区，流对象可以继续使用。
• close ：关闭流，释放系统资源。关闭前会刷新缓冲区。

六、数据输入Scanner

数据输入是指获取用户键盘录入的数据，
我们可以通过 Scanner 类来获取用户的输入

    public static void main(String[] args) {
        //创建对象
        Scanner sc = new Scanner(System.in);
        //接收数据
        int x = sc.nextInt();
        //输出数据
        System.out.println("x:" + x);
    }

Scanner类的构造方法

Scanner(InputStream source) //从指定输入流扫描的值。  
Scanner(InputStream source, String charsetName) //从指定输入流扫描的值 
Scanner(File source)  //从指定文件扫描的值。  
Scanner(File source, String charsetName) //从指定文件扫描的值。 

Scanner类的常用方法

nextXxx():即获取下一个输入项。其中Xxx表示所要输入的数据的类型，比如Int、Long、Double…等基本数据类型。
hasNextXxx()：是否还有下一个输入项。

next()与nextLine()方法获取输入的字符串，
在读取之前一般需要使用hasNext()与hasNextLine()进行判断是否还有输入的数据。

public void close() // 使用完毕后要记得关闭流

nextInt():
it only reads the int value, nextInt() places the cursor（光标） in the same line after reading the input.（nextInt()只读取数值，剩下"\n"还没有读取，并将cursor放在本行中）

next(): read the input only till the space. It can’t read two words separated by space. Also, next() places the cursor in the same line after reading the input.（next()只读空格之前的数据，并且cursor指向本行）
next() 方法遇见第一个有效字符（非空格，非换行符）时，开始扫描，当遇见第一个分隔符或结束符(空格或换行符)时，结束扫描，获取扫描到的内容，即获得第一个扫描到的不含空格、换行符的单个字符串。

next()
注意：

1. 一定要读取到有效字符后才可以结束输入。
2. 对输入的有效字符之前所遇到的空白，会自动将其去除。
3. 只有输入的有效字符后才将其后面输入的空白作为结束符。
4. next()不能得到带有空格的字符串。

nextLine()
注意：
1. 以Enter作为结束符，即获取到的是输入回车之前的所有字符。
2. 可以获取空白。