大家好，又见面了，我是你们的朋友全栈君。
JAVA面试部分重点内容
目录
- JAVA面试部分重点内容
- 五、输入输出流IO流
-
- 1.File类的常用方法?
- 2.说说IO流?
- 3.字节流的常用方法?
- 4.说说字符流?
- 5.说说缓冲流?
- 6.说说序列化和反序列化?
五、输入输出流IO流
1.File类的常用方法?
java.io.File，使用该类的构造函数就可以创建文件对象，将硬盘中的一个具体的文件以 Java 对象的形式来表示。
方法 | 描述 |
|---|---|
public File(String pathname) | 根据路径创建对象（是绝对路径） |
public String getName() | 获取文件名 |
public String getParent() | 获取文件所在的目录 |
public File getParentFile() | 获取文件所在目录对应的File对象 |
public String getPath() | 获取文件路径 |
public boolean exists() | 判断文件是否存在 |
public boolean isDirectory() | 判断对象是否为目录 |
public boolean isFile() | 判断对象是否为文件 |
public long length() | 获取文件的大小 |
public boolean createNewFile() | 根据当前对象创建新文件 |
public boolean delete() | 删除对象 |
public boolean mkdir() | 根据当前对象创建目录 |
public boolean renameTo(File file) | 为已存在的对象重命名 |
2.说说IO流?
Input 输入流（将外部文件读入到 Java 程序中）
Output 输出流（将 Java 程序中的数据输出到外部）
Java 中的流有很多种不同的分类。
- 按照方向分，输入流和输出流
- 按照单位分，可以分为字节流和 字符流（字节流是指每次处理数据以字节为单位，字符流是指每次处理数据以字符为单位）
- 按照功能分，可以分为节点流（字节流）和处理流(对节点流进行处理，生成其他类型的流）。
方法定义时的异常如果直接继承自 Exception，实际调用的时候需要手动处理（捕获异常/丢给虚拟机去处理)；方法定义时的异常如果继承自 RuntimeException，调用的时候不需要处理。
3.字节流的常用方法?
InputStream 的常用方法
方法 | 描述 |
|---|---|
int read() | 以字节为单位读取数据 |
int read(byte b[]) | 将数据存入 byte 类型的数组中，返回数组中有效数据的长度 |
int read(byte b[],int off,int len) | 将数据存入 byte 数组的指定区间内，返回数组长度 |
byte[ ] readAllBytes() | 将所有数据存入 byte 数组并返回 |
int available() | 返回当前数据流未读取的数据个数 |
void close() | 关闭数据流 |
FileInputStream是抽象类InputStream的实现类，构造函数可以接受File实例对象，但要保证文件存在。
OutputStream的常用方法
方法 | 描述 |
|---|---|
void write(int b) | 以字节为单位输出数据 |
void write(byte b[ ]) | 将byte数组中的数据输出 |
void write(byte b[ ],int off,int len) | 将byte数组中指定区间的数据输出 |
void close() | 关闭数据流 |
void flush() | 将缓冲流中的数据同步到输出流中 |
FileOutputStream是抽象类OutputStream的实现类，构造方法可以接受File实例对象，文件不存在时，会创建文件。
4.说说字符流?
字节流是单位时间内处理一个字节的数据（输入 输出）
字符流是单位时间内处理一个字符的数据（输入 输出）
字符流：
- 输入字符流 Reader
- 输出字符流 Writer
Reader是一个抽象类
Closeable接口的作用:及时关闭资源，而不是让GC回收
Readable 接口的作用:可以将数据以字符的形式读入到缓冲区 InputStream(字节输入流) —> Reader（字符输入流）
InputStreamReader 的功能是将字节输入流转换为字符输入流，是处理流
代码语言：javascript复制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，必须要建立在字节流的基础上才能创建。
缓冲流又可以分为字节缓冲流和字符缓冲流，按照方向再细分，又可以分为字节输入缓冲流和字节输出缓冲流，以及字符输入缓冲流和字符输出缓冲流。
字节输⼊缓冲流
代码语言：javascript复制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 ⽅法
代码语言：javascript复制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();
}
}字节输出缓冲流
代码语言：javascript复制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();
}
}字符节输出缓冲流
代码语言：javascript复制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
代码语言：javascript复制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。
代码语言：javascript复制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、反序列化
代码语言：javascript复制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();
}
}发布者：全栈程序员栈长，转载请注明出处：https://javaforall.cn/156507.html原文链接：https://javaforall.cn
