大家好，又见面了，我是你们的朋友全栈君。

JAVA面试部分重点内容

五、输入输出流IO流

  1.File类的常用方法?

  java.io.File，使用该类的构造函数就可以创建文件对象，将硬盘中的一个具体的文件以 Java 对象的形式来表示。

  2.说说IO流?

  Input 输入流（将外部文件读入到 Java 程序中）

  Output 输出流（将 Java 程序中的数据输出到外部）

  Java 中的流有很多种不同的分类。

• 按照方向分，输入流和输出流
• 按照单位分，可以分为字节流和 字符流（字节流是指每次处理数据以字节为单位，字符流是指每次处理数据以字符为单位）
• 按照功能分，可以分为节点流（字节流）和处理流(对节点流进行处理，生成其他类型的流）。

  方法定义时的异常如果直接继承自 Exception，实际调用的时候需要手动处理（捕获异常/丢给虚拟机去处理)；方法定义时的异常如果继承自 RuntimeException，调用的时候不需要处理。

  3.字节流的常用方法?

  InputStream 的常用方法

  FileInputStream是抽象类InputStream的实现类，构造函数可以接受File实例对象，但要保证文件存在。

  OutputStream的常用方法

  FileOutputStream是抽象类OutputStream的实现类，构造方法可以接受File实例对象，文件不存在时，会创建文件。

  4.说说字符流?

  字节流是单位时间内处理一个字节的数据（输入+输出）

  字符流是单位时间内处理一个字符的数据（输入+输出）

  字符流：

• 输入字符流 Reader
• 输出字符流 Writer

   Reader是一个抽象类

  Closeable接口的作用:及时关闭资源，而不是让GC回收

  Readable 接口的作用:可以将数据以字符的形式读入到缓冲区
  InputStream(字节输入流) —> Reader（字符输入流）

  InputStreamReader 的功能是将字节输入流转换为字符输入流，是处理流

import java.io.FileInputStream;
import java.io.FileReader;
import java.io.InputStream;
import java.io.Reader;

public class Test { 
   
    public static void main(String[] args) throws Exception { 
   
        //字符流
        Reader reader = new FileReader("/Users/southwind/Desktop/test.txt");
        int temp = 0;
        System.out.println("*******字符流读取********");
        while ((temp = reader.read())!=-1){ 
   
            System.out.println(temp);
        }
        reader.close();

        //字节流
        InputStream inputStream = new FileInputStream("/Users/southwind/Desktop/test.txt");
        temp = 0;
        System.out.println("*******字节流读取********");
        while ((temp = inputStream.read())!=-1){ 
   
            System.out.println(temp);
        }
        inputStream.close();
    }
}

import java.io.FileReader;
import java.io.Reader;

public class Test2 { 
   
    public static void main(String[] args) throws Exception { 
   
        Reader reader = new FileReader("/Users/southwind/Desktop/test.txt");
        char[] chars = new char[8];
        int length = reader.read(chars);
        System.out.println("数据流的长度是"+length);
        System.out.println("遍历数组");
        for (char aChar : chars) { 
   
            System.out.println(aChar);
        }

    }
}

read() 返回的是 int ，直接将字符转成字节（1-1，1-3），每次读一个字节。

read(char[ ] chars) 返回的是 char 数组，直接就返回字符个数，不会转成字节的。

read(char[ ] chars, int off, int len)：读len个字符，放到chars数组中off处。

  5.说说缓冲流?

  论是字节流还是字符流，使用的时候都会频繁访问硬盘，对硬盘是一种损伤，同时效率不高，如何解决？
  可以使用缓冲流，缓冲流自带缓冲区，可以一次性从硬盘中读取部分数据存入缓冲区，再写入内存，这样就可以有效减少对硬盘的直接访问。

  缓冲流属于处理流，如何来区分节点流和处理流？

  1、节点流使用的时候可以直接对接到文件对象 File

  2、处理流使用的时候不可以直接对接到文件对象 File，必须要建立在字节流的基础上才能创建。

  缓冲流又可以分为字节缓冲流和字符缓冲流，按照方向再细分，又可以分为字节输入缓冲流和字节输出缓冲流，以及字符输入缓冲流和字符输出缓冲流。

  字节输⼊缓冲流

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.InputStream;

public class Test { 
   
    public static void main(String[] args) throws Exception { 
   
        //1、创建节点流
        InputStream inputStream = new FileInputStream("/Users/southwind/Desktop/test.txt");
        //2、创建缓冲流
        BufferedInputStream bufferedInputStream = new BufferedInputStream(inputStream);
// int temp = 0;
// while ((temp = bufferedInputStream.read())!=-1){ 
   
// System.out.println(temp);
// }

        byte[] bytes = new byte[1024];
        int length = bufferedInputStream.read(bytes,10,10);
        System.out.println(length);
        for (byte aByte : bytes) { 
   
            System.out.println(aByte);
        }

        bufferedInputStream.close();
        inputStream.close();
    }
}

  字符输⼊缓冲流
  readLine ⽅法

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.Reader;字节输出缓冲流
public class Test2 { 
   
 public static void main(String[] args) throws
Exception { 
   
 //1、创建字符流（节点流）
 Reader reader = new
FileReader("/Users/southwind/Desktop/test.txt");
 //2、创建缓冲流（处理流）
 BufferedReader bufferedReader = new
BufferedReader(reader);
 String str = null;
 int num = 0;
 System.out.println("***start***");
 while ((str =
bufferedReader.readLine())!=null){ 
   
 System.out.println(str);
 num++;
 }
 System.out.println("***end***,共读取
了"+num+"次");
 bufferedReader.close();
 reader.close();
 }
}

  字节输出缓冲流

import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.OutputStream;字符输出缓冲流
public class Test { 
   
 public static void main(String[] args) throws
Exception { 
   
 OutputStream outputStream = new
FileOutputStream("/Users/southwind/Desktop/test2.txt
");
 BufferedOutputStream bufferedOutputStream =
new BufferedOutputStream(outputStream);
 String str = "由于在开发Oak语⾔时，尚且不存在运⾏
字节码的硬件平台，所以为了在开发时可以对这种语⾔进⾏实验研究，
他们就在已有的硬件和软件平台基础上，按照⾃⼰所指定的规范，⽤软
件建设了⼀个运⾏平台，整个系统除了⽐C++更加简单之外，没有什么
⼤的区别。";
 byte[] bytes = str.getBytes();
// for (byte aByte : bytes) { 
   
// bufferedOutputStream.write(aByte);
// }
 bufferedOutputStream.write(bytes,9,9);
 bufferedOutputStream.flush();
 bufferedOutputStream.close();
 outputStream.close();
 }
}

  字符节输出缓冲流

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.Writer;
public class Test2 { 
   输⼊流没有 flush ⽅法，但不代表它没有缓冲流，输出流是有 flush
⽅法的，实际开发中在关闭输出缓冲流之前，需要调⽤ flush ⽅
法。
序列化和反序列化
序列化就是将内存中的对象输出到硬盘⽂件中保存。
反序列化就是相反的操作，从⽂件中读取数据并还原成内存中的对
象。
序列化
 public static void main(String[] args) throws
Exception { 
   
 Writer writer = new
FileWriter("/Users/southwind/Desktop/test2.txt");
 BufferedWriter bufferedWriter = new
BufferedWriter(writer);
// String str = "由于在开发语⾔时尚且不存在运⾏字节
码的硬件平台，所以为了在开发时可以对这种语⾔进⾏实验研究，他们
就在已有的硬件和软件平台基础上，按照⾃⼰所指定的规范，⽤软件建
设了⼀个运⾏平台，整个系统除了⽐C++更加简单之外，没有什么⼤的
区别。";
// bufferedWriter.write(str,5,10);
 char[] chars = { 
   'J','a','v','a'};
// bufferedWriter.write(chars,2,1);
 bufferedWriter.write(22902);
 bufferedWriter.flush();
 bufferedWriter.close();
 writer.close();
 }
}

  输入流没有 flush 方法，但不代表它没有缓冲流，输出流是有 flush 方法的，实际开发中在关闭输出缓冲流之前，需要调用 flush 方法。

  6.说说序列化和反序列化?

• 序列化就是将内存中的对象输出到硬盘文件中保存。

• 反序列化就是相反的操作，从文件中读取数据并还原成内存中的对象。

  1、实体类需要实现序列化接口，Serializable

import java.io.Serializable;

public class User implements Serializable { 
   
    private Integer id;
    private String name;
    private Integer age;

    public Integer getId() { 
   
        return id;
    }

    public void setId(Integer id) { 
   
        this.id = id;
    }

    public String getName() { 
   
        return name;
    }

    public void setName(String name) { 
   
        this.name = name;
    }

    public Integer getAge() { 
   
        return age;
    }

    public void setAge(Integer age) { 
   
        this.age = age;
    }

    @Override
    public String toString() { 
   
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public User(Integer id, String name, Integer age) { 
   
        this.id = id;
        this.name = name;
        this.age = age;
    }
}

  2、实体类对象进行序列化处理，通过数据流写入到文件中，ObjectOutputStream。

import com.southwind.entity.User;

import java.io.File;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;

public class Test { 
   
    public static void main(String[] args) throws Exception { 
   
        User user = new User(1,"张三",22);
        OutputStream outputStream = new FileOutputStream("/Users/southwind/Desktop/obj.txt");
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(outputStream);
        objectOutputStream.writeObject(user);
        objectOutputStream.flush();
        objectOutputStream.close();
        outputStream.close();
    }
}

  3、反序列化

import com.southwind.entity.User;

import java.io.FileInputStream;
import java.io.InputStream;
import java.io.ObjectInputStream;

public class Test2 { 
   
    public static void main(String[] args) throws Exception { 
   
        InputStream inputStream = new FileInputStream("/Users/southwind/Desktop/obj.txt");
        ObjectInputStream objectInputStream = new ObjectInputStream(inputStream);
        User user = (User) objectInputStream.readObject();
        System.out.println(user);
        objectInputStream.close();
        inputStream.close();
    }
}