Java（8）I/O

时间 2020-11-26

标签 java 面试 windows 数组网络多线程 app dom ide 单元测试栏目 Java 繁體版

原文原文链接

1、File类

一、File类概述

java.io.File类：一个java.io.File类的对象，表示文件和文件目录路径（就是文件夹）
File 能新建、删除、重命名文件和目录，但 File 不能访问文件内容自己。若是须要访问文件内容自己，则须要使用输入/输出流。
想要在Java程序中表示一个真实存在的文件或目录，那么必须有一个File对象，可是Java程序中的一个File对象，可能没有一个真实存在的文件或目录。

经典应用场景：File对象能够做为参数传递给流的构造器。

二、File类实例化

构造器

构造器	描述
File(String pathname)	由路径名称来建立
File(String parent, String child)	由上层目录路径+文件名来建立
File(File parent, String child)	由上层文件名+文件名来建立
File(URI uri)	由uri来建立

路径java
- 绝对路径：是一个固定的路径,从盘符开始
- 相对路径：是相对于某个位置开始。在IDEA中是相对于当前的module
路径分隔符面试
- windows和DOS系统默认使用“\”来表示
- UNIX和URL使用“/”来表示
- Java程序支持跨平台运行，所以路径分隔符要慎用。为了解决这个隐患，File类提供了一个常量：public static final String separator，根据操做系统，动态的提供分隔符。
- 举例
```
File file1 = new File("d:\\atguigu\\info.txt");

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

File file3 = new File("d:/atguigu");
```

三、File类经常使用方法

**获取

方法	描述
getAbsolutePath()	获取绝对路径
getPath()	获取路径
getName()	获取名
getParent()	获取上层文件目录路径。若无，返回null
length()	获取文件长度（即：字节数）。不能获取目录的长度。
lastModified()	获取最后一次的修改时间，毫秒值
下面两个是针对目录的
public String[] list()	获取指定目录下的全部文件或者文件目录的名称数组
public File[] listFiles()	获取指定目录下的全部文件或者文件目录的File数组

重命名

public boolean renameTo(File dest)：把文件重命名为指定的文件路径。（实际上就是把file1的内容复制到file2，并把file1删除）windows

对于 file1.renameTo(file2)要求：file1存在，file2不存在数组

判断

方法	描述
isDirectory()	判断是不是文件目录
isFile()	判断是不是文件
exists()	判断是否存在
canRead()	判断是否可读
canWrite()	判断是否可写
isHidden()	判断是否隐藏

建立和删除

方法	描述	注意事项
public boolean createNewFile()	建立文件	若文件存在，则不建立，返回false
public boolean mkdir()	建立文件目录	若是此文件目录存在，就不建立；若是此文件目录的上层目录不存在，也不建立
public boolean mkdirs()	建立文件目录	若是上层文件目录不存在，一并建立
public boolean delete()	删除文件或者文件夹	Java中的删除不走回收站要删除的文件目录内不能包含文件或文件目录

若是你建立文件或者文件目录没有写盘符路径，那么，默认在项目路径下。网络

2、IO流的原理

一、IO流的原理

I/O是input/output的缩写，IO技术用于设备之间的数据传输。（如。读/写文件、网络通信）
Java程序中，数据的输入/输出操做以“流(stream)” 的方式进行。
java.io包下提供了各类“流”类和接口，用以获取不一样种类的数据，并经过标准的方法输入或输出数据。

二、input和output的理解

首先对于入和出，咱们是站在程序的角度来讲的，想象本身身处程序内部。
input：磁盘、光盘等存储设备的数据----->程序、内存
output：程序、内存中的数据----->磁盘、光盘等存储设备

3、IO流的分类

一、分类

√√√按操做的数据单位不一样分为：字节流（8bit）、字符流（16bit）。字节流适合操做图片、视频等文件，字符流适合操做文本文件。多线程
按数据流的流向不一样分为：输入流、输出流。app
按流的角色不一样分为：**节点流、处理流。dom
- 节点流：直接从数据源或目的地读写数据。也叫文件流ide
- 处理流：不直接链接到数据源或目的地，而是“链接”在已存在的流（节点流或处理流）之上，经过对数据的处理为程序提供更为强大的读写功能单元测试

二、图示

三、四个抽象基类

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

四、IO流体系

4、FileReader和FileWriter

一、IDEA中单元测试方法和main()下相对路径对比

单元测试方法下的相对路径是：相较于当前module而言
main()下的相对路径：相较于当前工程而言

二、使用FileReader读入数据

最初的代码实现

public void test1() throws IOException {
        //1.实例化File类,指明要操做的对象.这一步的目的是创建硬盘中的文件和Java中类的对应关系.
        File file = new File("hello1.txt");

        //2.提供具体的流.参数的做用就是帮助咱们并链接上文件这个"大水库"
        FileReader fileReader = new FileReader(file);

        //3.用流读取到内存
        //read():返回读入的字符,是int须要转换为char.到了文件结尾返回-1
        int read = fileReader.read();
        while (read != -1) {
            System.out.print((char) read);
            read = fileReader.read();
        }

        //4.关闭流
        fileReader.close();
    }
    //整个过程结合图示去理解很合理

改进后的代码实现

/*
    优化:
        1.第三部能够在语法上的优化,可是效率实际上是同样的
        2.为了保证关闭操做必定执行,使用try-catch-finally
        3.读入的文件必定要存在,不然会出现:FileNotFoundException
    */
public void test2() {

        FileReader fileReader = null;
        try {
            File file = new File("hello1.txt");

            fileReader = new FileReader(file);

            //改进1
            int read;
            while ((read = fileReader.read()) != -1){
                System.out.print((char) read);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (fileReader != null)
                    fileReader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

使用缓冲流改进（这个是用的最多的★★★★★）

//使用数组
char[] charBuffer = new char[5];
int len;//记录每次读入到charBuffer数组中的字符个数
while ((len = fileReader.read(charBuffer)) != -1){
    for (int i = 0; i < len; i++) {//这里要用len(读取的字符数)二不是数组的长度
        System.out.print(charBuffer[i]);
    }
}

//固然for循环也能够换位String的构造器来把字符串数组转换为String
String string = new String(charBuffer, 0, len);
System.out.print(string);

三、使用FileWriter写出数据

代码实现

File file = new File("hello2.txt");
FileWriter fw = new FileWriter(file);
fw.write("i have a dream!");
fw.close();
//最后用try-catch处理一下异常，上面的步骤更清晰一些

说明
- 输出时，File能够不存在，不会报异常。
- File对应的硬盘的文件若是不存在，自动建立
- File对应的硬盘的文件若是存在
  - 若是流使用的构造器是FileWriter(file, false)/FileWriter(file)，对原有的文件进行覆盖
  - 若是流使用的构造器是FileWriter(file, true)，对原有的文件进行追加

四、使用FileReader和FileWriter复制文本文件

代码实现

public void test5() throws IOException {
        File srcFile = new File("hello2.txt");
        File destFile = new File("hello3.txt");

        FileReader fr = new FileReader(srcFile);
        FileWriter fw = new FileWriter(destFile);

        char[] charBuffer = new char[5];
        int len;
        while ((len = fr.read(charBuffer)) != -1) {
            fw.write(charBuffer, 0, len);//和用String来取是相似的★★★★★
        }

        fw.close();
        fr.close();
}
//最后用try-catch处理一下异常，上面的步骤更清晰一些

五、使用FileReader和FileWriter不能处理图片的复制的测试

当把hello.txt文本文件改成图片文件时，发现代码是能够正常运行，可是复制结果并不对，新图片打不开。
这是由于，图片是用字节来存储的。用字符流来处理显然不行。

5、FileInputStream和FileOutputStream

一、用FileInputStream和FileOutputStream处理文本文件会怎样？

结论
- 输出到控制台时：英文不乱码，中文可能会乱码
- 单纯复制，而不在内存层面查看：不会乱码，是能够的。
解释
- 对于英文，utf-8和gbk都是用一个字节（4bit位）来存一个字母，所以每一个字母都是完完整整的存入byte数组，从而能完整的复制过去。
- 对于中文，utf-8中用的是三个字节来存一个汉字，那么字节数组中的数据在输出时，不肯定在哪里截断，就会出现一部分字的乱码。

二、肯定使用字符流仍是字节流

对于文本文件（.txt, .java, .cpp），使用字符流
对于非文本文件（.jpg, .mp3, .mp4, .avi, .doc, .ppt...），使用字节流

三、用FileInputStream和FileOutputStream复制图片

同“使用FileReader和FileWriter复制文本文件”，只要
- 使用FileInputStream和FileOutputStream
- 把数组改成byte数组

6、缓冲流

一、缓冲流有哪些

BufferedInputStream、BufferedOutputStream、BufferedReader、BufferedWriter

二、做用

提升读写速度

三、缘由

在使用这些流类时，会建立一个内部缓冲区数组，缺省使用8192个字节(8Kb)的缓冲区。
当读取数据时，数据按块读入缓冲区，其后的读操做则直接访问缓冲区。
当使用BufferedInputStream读取字节文件时，BufferedInputStream会一次性从文件中读取8192个(8Kb)，存在缓冲区中，直到缓冲区装满了，才从新从文件中读取下一个8192个字节数组。
向流中写入字节时，不会直接写到文件，先写到缓冲区中直到缓冲区写满， BufferedOutputStream才会把缓冲区中的数据一次性写到文件里。
使用方法 flush()能够强制将缓冲区的内容所有写入输出流。
若是是带缓冲区的流对象的close()方法，不但会关闭流，还会在关闭流以前刷新缓冲区，关闭后不能再写出。
- 填坑：本身写代码的时候忘记关闭流操做，致使复制的图片打不开的缘由就是，没有关闭流，缓冲区内还有一部分数据没能复制过去。

四、使用缓冲流复制图片

public void test() throws IOException {
        //1.建立File
        File srcFile = new File("img1.png");
        File destFile = new File("img2.png");

        //2.建立流
        //2.1建立文件流
        FileInputStream fis = new FileInputStream(srcFile);
        FileOutputStream fos = new FileOutputStream(destFile);

        //2.2建立字节流
        BufferedInputStream bis = new BufferedInputStream(fis);
        BufferedOutputStream bos = new BufferedOutputStream(fos);

        //3.复制
        byte[] bytes = new byte[10];
        int len;
        while ((len = bis.read(bytes)) != -1){
            bos.write(bytes,0,len);
        }

        //4.关闭流
        bis.close();
        bos.close();
}

关闭外层的流的同时，会自动关闭内层的流。因此只写外层的关闭操做就能够。

五、使用缓冲流复制文本文件

public void test1() throws IOException {
        //1.建立文件和流
        BufferedReader br = new BufferedReader(new FileReader(new File("hello1.txt")));
        BufferedWriter bw = new BufferedWriter(new FileWriter(new File("hello4.txt")));

//        //2.复制
//        char[] chars = new char[10];
//        int len;
//        while ((len = br.read(chars)) != -1) {
//            bw.write(chars, 0, len);
//        }


        // 复制:用String来实现★★★★★★★★★★★
        String data;//可是是不带换行的,能够用一如下两种方法实现
        while ((data = br.readLine()) != null) {
//          //方法一★★★★★★★★
//            bw.write(data + "\n");
            //方法二★★★★★★★★
            bw.write(data);
            bw.newLine();
        }

        //3.关闭
        br.close();
        bw.close();
    }

六、练习：统计文本每一个字符出现次数

7、转换流

一、什么是转换流

转换流提供了在字节流和字符流之间的转换
转换流属于字符流
Java API提供了两个转换流
- InputStreamReader：将InputStream转换为Reader
  - 构造器一：public InputStreamReader(InputStream in)默认使用utf-8字符集
  - 构造器二：public InputSreamReader(InputStream in,String charsetName)能够本身选择字符集。
- OutputStreamWriter：将Writer转换为OutputStream
  - 构造器和上面相似
字节流中的数据都是字符时，转成字符流操做更高效。
不少时候咱们使用转换流来处理文件乱码问题。实现编码和解码的功能。

二、编码与解码

编码：字节、字节数组--->字符数组、字符串
解码：字符数组、字符串--->字节、字节数组

三、字符集

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

按照地区辅助记忆	编码表	描述
美国	ASCII	用一个字节的7位来表示全部英文和符号
欧洲	ISO8859-1	用一个字节的8位表示全部欧洲语言的字母
中国	GB2312 GBK	最多两个字节编码全部汉字升级版，加入了更多的汉字
国际通用	Unicode UTF-8	Unicode编码是对UTF-8/16的统称用1-4个字节表示人类全部文字

四、转换流的做用示意图

五、练习题

综合使用：将文本文件从utf-8转换为gbk编码
代码实现

@Test
    public void test2() throws Exception {
        //1.造文件、造流
        File file1 = new File("dbcp.txt");
        File file2 = new File("dbcp_gbk.txt");

        FileInputStream fis = new FileInputStream(file1);
        FileOutputStream fos = new FileOutputStream(file2);

        InputStreamReader isr = new InputStreamReader(fis,"utf-8");
        OutputStreamWriter osw = new OutputStreamWriter(fos,"gbk");

        //2.读写过程
        char[] cbuf = new char[20];
        int len;
        while((len = isr.read(cbuf)) != -1){
            osw.write(cbuf,0,len);
        }

        //3.关闭资源
        isr.close();
        osw.close();
    }

8、标准输入输出流（了解）

一、简介

标准输入流：System.in。默认输入设备是键盘。类型是InputStream。
标准输出流：System.out。默认输出设备是控制台。类型是PrintStream，是OutputStream的子类。

2.练习

题目：从键盘输入字符串，要求将读取到的整行字符串转成大写输出。而后继续进行输入操做，直至当输入“e”或者“exit”时，退出程序。
代码实现

public class Exercise {
    public static void main(String[] args) {//idea不支持在单元测试中输入内容,因此改用main()来测试
        BufferedReader br = null;
        try {
            InputStreamReader isr = new InputStreamReader(System.in);
            br = new BufferedReader(isr);

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

9、打印流（了解）

一、打印流简介

实现将基本数据类型的数据格式转化为字符串来输出
包含两个：PrintStream和PrintWriter
- 提供了一系列重载的print()和println()方法，用于多种数据类型的输出
- System.out返回的是PrintStream的实例

二、代码演示

把标准输出流(控制台输出)改为文件

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

10、数据流（了解）

一、简介

引入：为了方便地操做Java语言的基本数据类型和String的数据，可使用数据流
数据流有两个类：(用于读取和写出基本数据类型、String类的数据，方便持久化）
- DataInputStream 和 DataOutputStream
- DataInputStream中的方法
  
  boolean readBoolean()
  
  char readChar()
  
  double readDouble()
  
  long readLong()
  
  String readUTF()
  
  byte readByte()
  
  float readFloat()
  
  short readShort()
  
  int readInt() void
  
  readFully(byte[] b)
- DataOutputStream中的方法
  
  将上述的方法的read改成相应的write便可

二、练习

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

    注意：处理异常的话，仍然应该使用try-catch-finally.
     */
    @Test
    public void test3() throws IOException {
        //1.
        DataOutputStream dos = new DataOutputStream(new FileOutputStream("data.txt"));
        //2.
        dos.writeUTF("刘建辰");
        dos.flush();//刷新操做，将内存中的数据写入文件
        dos.writeInt(23);
        dos.flush();
        dos.writeBoolean(true);
        dos.flush();
        //3.
        dos.close();


    }
    /*
    将文件中存储的基本数据类型变量和字符串读取到内存中，保存在变量中。

    注意点：读取不一样类型的数据的顺序要与当初写入文件时，保存的数据的顺序一致！

     */
    @Test
    public void test4() throws IOException {
        //1.
        DataInputStream dis = new DataInputStream(new FileInputStream("data.txt"));
        //2.
        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);

        //3.
        dis.close();

    }

11、对象流

一、简介

包含：两个类ObjectInputStream和ObjectOutputStream
是：用于存储和读取基本数据类型数据或对象的处理流
强大之处：能够把Java中的对象写入到数据源中，也能把对象从数据源中还原回来。

二、对象的序列化★★★★★

什么是对象的序列化机制（面试题）
- 一方面，对象的序列化机制容许内存中的Java对象转换为平台无关的二进制流。从而容许吧二进制流持久化到磁盘，或，经过网络传给另外一个网络节点；
- 另外一方面，其余程序获取了二进制流，就能够恢复成原来的Java对象。
序列化的好处：可将任何实现了Serializable接使其在保存和传输时可被还原。

三、代码实现String类的对象的序列化和反序列化

public class ObjectInputOutputStream {
    /*
    代码实现String类的对象的序列化和反序列化
     */

    @Test//序列化
    public void testObjectOutputStream(){
        ObjectOutputStream oos = null;
        try {
            //1.造流和文件
            oos = new ObjectOutputStream(new FileOutputStream(new File("objectString.dat")));
            //2.写出
            oos.writeObject(new String("我爱你中国"));
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //3.关闭流
            try {
                if (oos != null) {
                    oos.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    @Test
    public void testObjectInputStream(){
        ObjectInputStream ois = null;
        try {
            ois = new ObjectInputStream(new FileInputStream(new File("objectString.dat")));

            Object readObject = ois.readObject();
            System.out.println(readObject);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            try {
                if (ois != null) {
                    ois.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

四、自定义类的序列化

要求
- 实现Serializable接口（这是一个标识接口，内部没有方法）
- 提供一个全局常量public static final long serialVersionUID = xxxxxxxxL;
  - 若是类没有显示定义这个静态常量，它的值是Java运行时环境根据类的内部细节自动生成的。若类的实例变量作了修改，serialVersionUID 可能发生变化。故建议，显式声明。
- 还要保证类的因此属性也是可序列化的。
  - 基本数据类型是可序列化的
注意：ObjectOutputStream和ObjectInputStream不能序列化static和transient修饰的成员变量
- 由于static修饰的变量是类全部的
- 不想序列化的就能够用transient

五、面试题

谈谈你对java.io.Serializable接口的理解，咱们知道它用于序列化，是空方法接口，还有其它认识吗？
- 实现了Serializable接口的对象，可将它们转换成一系列字节，并可在之后彻底恢复回原来的样子。这一过程亦可经过网络进行。这意味着序列化机制能自动补偿操做系统间的差别。换句话说，能够先在Windows机器上创建一个对象，对其序列化，而后经过网络发给一台Unix机器，而后在那里准确无误地从新“装配”。没必要关心数据在不一样机器上如何表示，也没必要关心字节的顺序或者其余任何细节。
- 因为大部分做为参数的类如String、Integer等都实现了 java.io.Serializable的接口，也能够利用多态的性质，做为参数使接口更灵活。

12、RandomAccessFile

一、简介

RandomAccessFile，随机存取文件流，直接继承于java.lang.Object类。
随机：RandomAccessFile 对象包含一个记录指针，用以标示当前读写处的位置。 RandomAccessFile 类对象能够自由移动记录指针
- long getFilePointer()：获取文件记录指针的当前位置
- void seek(long pos)：将文件记录指针定位到 pos 位置（这是他的灵魂所在）
  - 应用场景：能够多线程断点下载同一文件再拼接起来；下载不完，下次接着下载。
存取：实现了DataInput、DataOutput两个接口，因此这个类既能够读也能够写**。
- 能够用构造器里的参数决定是输出流仍是输入流。
  - public RandomAccessFile(File file, String mode)
  - public RandomAccessFile(String name, String mode)
- mode参数指定了访问模式
  - r: 以只读方式打开（经常使用）
  - rw：打开以便读取和写入（经常使用）
  - rwd:打开以便读取和写入；同步文件内容的更新
  - rws:打开以便读取和写入；同步文件内容和元数据的更新

二、用RandomAccessFile类实现文本文件的复制

@Test
public void test1() throws IOException {
    //用参数mode标识,让类表明输入
    RandomAccessFile r = new RandomAccessFile(new File("hello1.txt"), "r");
    //用参数mode标识,让类表明输出
    RandomAccessFile rw = new RandomAccessFile(new File("hello5.txt"), "rw");

    byte[] bytes = new byte[1024];
    int len;
    while ((len=r.read(bytes)) != -1){
        rw.write(bytes,0,len);
    }

    r.close();
    rw.close();
}

三、用 RandomAccessFile做为输出流时的特色

若是写出到的文件不存在，就建立
若是写出到的文件存在，会对原文从头开始进行覆盖，能覆盖多少算多少。

四、如何使用 RandomAccessFile对文本文件实现插入效果

/*
    使用RandomAccessFile实现数据的插入效果
     */
    @Test
    public void test3() throws IOException {

        RandomAccessFile raf1 = new RandomAccessFile("hello.txt","rw");

        raf1.seek(3);//将指针调到角标为3的位置
        //保存指针3后面的全部数据到StringBuilder中
        StringBuilder builder = new StringBuilder((int) new File("hello.txt").length());
        byte[] buffer = new byte[20];
        int len;
        while((len = raf1.read(buffer)) != -1){
            builder.append(new String(buffer,0,len)) ;
        }
        //调回指针，写入“xyz”
        raf1.seek(3);
        raf1.write("xyz".getBytes());

        //将StringBuilder中的数据写入到文件中
        raf1.write(builder.toString().getBytes());

        raf1.close();
    }

十3、第三方jar包的使用

一、为何使用

第三方jar包提供了不少方便高效的API，方便咱们开发中使用，实际开发中也是用这些jar包来提升工做效率，而不仅是根据JDK提供的API，由于有些不够简练。

二、IDEA中导入第三方jar包

当前module下建立名为lib或libs的directory
复制第三方jar包到lib目录
右键jar包，选择 add as library
搞定

三、用第三方jar包实现文件复制

public class JarTest {
    public static void main(String[] args) throws IOException {
        File srcFile = new File("s6_IO/hello1.txt");
        File destFile = new File("s6_IO/hello6.txt");

        FileUtils.copyFile(srcFile,destFile);

    }
}