9.1 File 类
File 类分为两种
-
绝对路径:就是资源文件在硬盘上的真实路径或者部署到web服务器上之后引用资源的完整路径
-
相对路径:相对于当前项目/文件的路径的相对路径
9.1.1操作文件和目录
-
File 类表示操作系统的文件或文件夹。
-
File 类的构造方法:
public File (String pathName);-
pathName 表示在创建File对象的时候需要给的文件路径
-
创建File 对象语法:
File file=new File("文件路径");####File 类的常用语法
| 方法名称 | 说 明 |
| boolean exists( ) | 判断文件或目录是否存在 |
| boolean isFile( ) | 判断是否是文件 |
| boolean isDirectory( ) | 判断是否是目录 |
| String getPath( ) | 返回此对象表示的文件的相对路径名 |
| String getAbsolutePath( ) | 返回此对象表示的文件的绝对路径名 |
| String getName( ) | 返回此对象表示的文件或目录的名称 |
| boolean delete( ) | 删除此对象指定的文件或目录 |
| boolean createNewFile( ) | 创建新文件 |
| long length() | 返回文件的长度，单位为字节, 如果文件不存在，则返回 0L |
public class Test {
public static void main(String[] args) {
try {
File file = new File("abc/def/啦啦啦.txt");
// file.createNewFile();
//创建一个文件不包含文件夹
// System.out.println(file.getParentFile());
//拿到上一层文件夹对象 返回File
// System.out.println(file.getParent());
//返回值String
// file.mkdir();
//创建一个文件夹 但是不能创建多级
// file.mkdirs();
//创建多级文件夹
// file.renameTo(new File("abc/def/啦啦啦.txt")); //文件重命名
// file.delete();
//删除文件
//查询
System.out.println(file.exists());
//判断上层文件是否存在 boolean
System.out.println(file.isAbsolute());
//判断文件是否是绝对路径 boolean
System.out.println(file.getName());
//查找当前文件名 String
System.out.println(file.isDirectory());
//判断文件是否是文件夹
System.out.println(file.isFile());
//判断文件是否是文件 boolean
System.out.println(file.length());
//文件大小 int
System.out.println(file.getName());
//当前文件名
} catch (Exception e) {
e.printStackTrace();
}
}
}I/O 流概述
I 对应的是input，指读入操作，O 对应 output，指写出操作。
流的分类:
-
按照读写的方向来讲,分为输入流和输出流,站在程序的角度去分析
-
按照读写内容的单位来讲,分为字节流和字符流
-
按照流的功能不同分为节点流和处理流
节点流: 直接连接在文件上的
处理流: 套在其他流上的
1.按流向划分:输入流和输出流
输入流
程序读取数据源
只能从中读取数据，不能写入数据流，实现程序从数据源中读数据。
输出流
程序向数据源写程序
只能向其写入数据，而不能从中读取数据的流，实现程序向目标数据源中写程序
2.按处理单元划分:字节流和字符流
-
字节流:以 8 位通用字节流，字符流是 16 位 Unicode 字符流，可用于二进制数据。
-
字符流:以16位的字符为操作数据单元的流，可用于操作文本数据
字节流和字符流的用法几乎相同。向下细分，还可以划分为字节输入流、字节输出流、字符出入流、字符输出流
| 输入 | 输出 | |
| 字节流 | InputStream | OutpueStream |
| 字符流 | Reader | writer |
-
可以把I/O 流看做一个水管，水管里有依次排列的水滴，每个水滴就是一个处理单元。
-
在字节流中每滴水滴是一个字节。
-
字符流中每滴水滴是一个字符。
3.按流的角色划分:节点流和处理流
节点流:可以直接向一个特定的存储介质(如磁盘、文件)读写数据的流。
处理流:用于对一个已存在的流进行连接和封装，通过封装后的流实现数据读写操作的流。
9.3 字节流
字节流主要操作的是byte 类型数据，其基类就是 OutputStream 类和 InputStream 类。
9.3.1 字节输出流基类:OutputStream
OutputStream 类为抽象类，必须使用该类的子类进行实例化对象。
需要操作文件使用 FileOutputStream 实例化。
表 OutputStream 类中的主要操作方法
| 方法 | 描述 |
| void close() | 关闭输出流 |
| void flush() | 刷新缓冲区 |
| void write(byte[] b) | 将每个 byte 数组写入数据流 |
| void write(byte[] b,int off,int len) | 将每个指定范围的byte 数组写入数据流 |
| void write(int b) | 将一个字节数据写入数据流 |
9.3.2 字节输出流 FileOutputStream 类
-
三种构造方法
-
在创建对象的时候需要传参
| 方法 | 描述 |
| FileOutputStream(File file) | 用于创建向指定 File 对象写数据的文件输出流 file:指定目标文件的对象 |
| FileOutputStream(String name) | 用于创建向指定路径的文件写数据的文件输出流 name:指定目标文件的路径字符串 |
| FileOutpueStream(String name,boolean append) | 创建一个向指定路径的文件写入的数据的文件输出流。 name:指定一个目标文件的路径字符串 append:表示是否在文件末尾追加数据，true:追加 |
import java.io.File;
import java.io.FileNotFoundException;
import java.io.OutputStream;
import java.io.UnsupportedEncodingException;
public class FileOutputStream {
//字节输出流类
public static void main(String[] args) {
//第一种创建对象 String
// String url="D:\\lyc.txt";
// OutputStream ops=new java.io.FileOutputStream(url);
//第二种直接在里边写
// OutputStream ops=new java.io.FileOutputStream(D:\lyc.txt);
//第三种创建一个 File 对象给一个路径 ，在将File 对象写到 FileOutputStream() 里边
File file=new File("D:\\lyc.txt");
try {
OutputStream ops=new java.io.FileOutputStream(file);
String name="刘家乐";
byte [] bytes=name.getBytes();
// 字节数组，从0开始，到bytes.length结束
ops.write(bytes,0,bytes.length);
if(ops!=null)
{
//格式化刷新缓冲区
ops.flush();
//关闭流
ops.close();
}
} catch (Exception e) {
e.printStackTrace();
}
}
}9.3.3 字节输入流基(父)类:InputStream
可以通过 InputStream 类从文件中读数据。InputStream 类同样也是抽象类。
InputStream 类定义的主要方法
| 方法 | 描述 |
| int read() | 读取一个字节数据 |
| int read(byte[] b) | 将数据读取到字节数组里 |
| int read(byte[] b,int off,int len) | 从输入流中读取最多 len 长度的字节，保存到字节数组中，保存的位置从off开始 |
| void clear() | 关闭输入流 |
| int available() | 返回输入流读取的字节数 |
9.3.4 字节输入流 FileInputStream 类
-
通常使用 InputStream 类的FileInputStream 子类实现文本文件的读取
| 方法 | 描述 |
| FileInputStream(File file) | 用于创建从指定 File 对象读取数据的文件路径 file:指定路径的对象 |
| FileInputStream(String s) | 用于创建从指定路径读取数据的文件路径 s:指定路径 |
实例
通过使用字节输入流从指定文件中读取数据。
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
public class FileInputStream {
//字节输入流类
public static void main(String[] args) {
File file=new File("D:\\lyc.txt");
try {
InputStream is=new java.io.FileInputStream(file);
int len=0;
//读取一个字节 读取到的是阿克斯码值
System.out.println(is.read());
//可读取的字节数
System.out.println(is.available());
//第一种方法循环读取数据
// while ((len=is.read())!=-1){
// System.out.print((char) len);
// }
//第二种方法读取
byte[] bytes=new byte[(int)file.length()-1];
if ((len=is.read(bytes))>0){
System.out.println(new String(bytes));
}
//关闭输入流
is.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}注意
1.按字节读取并显示数据时需要进行强制类型转换
-
使用 read() 方法读取数据，每次读取一个8为字节，把它转换为 0~255的整数返回。
2.对是否读到文件末尾的判断
-
使用read() 方法读取文件中的数据，当返回结果为 -1时，即输入流已经读到末尾，在循环读取的过程中，可以一次作为循环结束的条件。
3.与字节输出流用法相同，在创建输入流对象、读取数据、关闭流时必须进行异常处理
9.4 字符流
一个字符占用内存的两个字节。如果用字节流处理文本文件，程序内部需要字节转换成字符，降低了执行效率，当输入和输出文本文件时，尽量使用字符流。
9.4.1 字符输出流基(父)类:Writer
Writer 类时字符除数流的抽象父类。
Writer 类中的常用方法
| 方法 | 描述 |
| void write(String str) | 将str 字符串中包含的字符输出到输出流中 |
| void write(String str,int off,int len) | 将字符串中从 off 位置开始、长度为 len 的字符输出到输出流中 |
| void close() | 关闭输出流 |
| void flush() | 刷新输出流 |
9.4.2 字符输出流 FileWriter 类
FileWriter 类时 Writer 类常用的子类，使用 FileWriter 可以以字符为数据处理单元向文本文件中写数据。
import java.io.IOException;
import java.io.Writer;
public class FileWriter {
//字符输出流
public static void main(String[] args) {
//创建一个null的对象
Writer fw=null;
try {
// 创建一个 FileWriter 将文件路径交给它
fw=new java.io.FileWriter("D:\\zf.txt");
fw.write("成功的男人");
fw.flush();
System.out.println("文件写入成功");
} catch (IOException e) {
e.printStackTrace();
System.out.println("文件不存在");
}finally {
if(fw!=null)
{
try {
fw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}使用 flush() 方法清空输出流 FileWriter，它可以强制将其中残余的数据写入文本文件，这样，才算完成全部数据的写操作，这时再使用 close() 方法关闭流。
9.4.3 字符输入流基(父)类: Reader
Reader 类是字符输入流的基(父)类，它是抽象类。
Reader 类中的常用方法
| 方法 | 描述 |
| int read() | 从输入流中读取单个字符，返回所读取的字符数据 |
| int read(char[] c) | 从输入流中最多读取 c.length 个字符数据并将其存储在字符数据 c 中，返回实际读取的字符数 |
| int read(char[] c,int off,int len) | 从输入流中最多读取 len 个字符的数据并将其存储在字符数组 c 中。 在存入数组 c 中时，并不是从数组起点开始的，而是从 off 位置开始的，返回实际读取的字符数。 |
-
Reader 类和 InputStream 类所提供的方法，它们基本是相同的。
-
如果将输入流比作水管，那么可以通过read() 方法每次读取一滴"水滴"，也可以通过 read(byte[] c)方法或read(char[] c,int off,int len)方法每次读取多滴水滴，多次重复执行去睡的过程，当方法返回值为 -1 时，表示到了输入流的结束点，也就是取水完毕。
9.4.4 字符输入流 FileReader
Reader 类同样是抽象类，可以使用其子类 FileReader 创建对象。
使用字符输入流 FileReader 实现读取 "路径"中的数据。
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.Reader;
public class FileReader {
public static void main(String[] args) {
//创建一个 File 类
File file=new File("D:\\zf.txt");
//定义一个 Reader
Reader rd=null;
try {
//nwe 一个FileReader对象
rd=new java.io.FileReader(file);
//文档的大小 字节
System.out.println(file.length());
//创建一个 char 类型的数组 将获取的字节大小给它
char [] chars=new char[(int)file.length()];
int len=0;
//循环使用read() 方法读取数据
while (( len=rd.read(chars))!=-1){
//循环输出 从0到len长度
System.out.println(new java.lang.String(chars,0,len));
}
} catch (IOException e) {
throw new RuntimeException(e);
}finally{
//关闭流对象
if(rd!=null)
{
try{
rd.close();
}catch(IOException e){
}
}
}
}
}9.5 缓冲流
缓冲流属于处理流
9.5.1 字符缓冲输出流 BufferedWriter 类
-
BufferedWriter 类使 Writer 类的子类。
-
BufferedWriter 类可以把一批数据写到缓冲区，默认情况下，只有在缓冲区满的时候，才会把缓冲区的数据真正写到目的地。
-
这样能减少物理写数据的次数，提高I/O操作的执行效率
BufferedWriter 类的常用方法
| 方法 | 描述 |
| BufferedWriter(Writer out) | 创建一个缓冲字符输出流 |
使用BufferedWriter 对象向文本文件中写数据
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
public class BufferedWriter1 {
public static void main(String[] args) {
Writer fw=null;
BufferedWriter bw=null;
try {
fw=new FileWriter("D:\\lyc.txt");
bw=new BufferedWriter(fw);
bw.write("亲爱的小伙伴们:");
bw.newLine();
bw.write("让我们一起刷新缓冲区吧");
bw.flush();
System.out.println("文件写入成功");
} catch (IOException e) {
e.printStackTrace();
}finally {
if(bw!=null&&fw!=null)
{
try {
bw.close();
fw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}-
创建 BufferedWriter 对象需要借助一个Writer 对象，在该对象的基础上进一步封装，成为一个带缓冲区的字符输出流。
-
newLine() 方法是BufferedWriter 类中的方法，作用是插入一个换行符。
-
关闭流时，需要先关闭 BufferedWriter 对象，再关闭FileWriter 对象。
9.5.2 字符缓冲输入流 BufferedReader 类
-
BufferedReader 类是 Reader 类的子类。
-
它与 FileReader 类的区别就在于 BufferedReader 类有缓冲区，它可以先把一批数据读到缓冲区中，避免每次都从数据源读取数据进行字符编码转换。
BufferedReader 类常用的构造方法
| 方法 | 描述 |
| BufferedReader(Reader in) | 创建一个缓冲字符输入流 |
使用BufferedReader 对象读取文本文件 中的数据并输出到控制台。
public class BufferedReader1 {
public static void main(String[] args) {
Reader fr =null;
BufferedReader br=null;
try {
//创建一个Reader对象
fr=new FileReader("D:\\lyc.txt");
//创建一个 BufferedReader
br=new BufferedReader(fr);
//使用 BufferedReader 类的 readLine() 方法按行读取内容
String line=br.readLine();
//利用 while 循环将读取到的内容输出到控制台中
while (line!=null){
System.out.println(line);
line=br.readLine();
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if(br!=null)
{
br.close();
}
if(fr!=null){
fr.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}-
创建BufferedReader 对象 FileReader 对象在FileReader 基础上进行封装升级
9.6 数据操作流
-
对二进制文件的读写操作
9.6.1DataOutputStream和DataInputStream 类
-
DataOutputStream 类是OutputStream 类的子类，利用 DataOutputStream 类写二进制文件的实现步骤与使用 FileOutputStream类写文件的步骤极其相似，而且用到了 File Output Stream 类。
-
DataInputStream 类是 InputStream 类的子类，在使用上也和 FileInputStream 类很相似
public class Test {
public static void main(String[] args) {
//创建File对象 赋给它路径
File file=new File("C:\\Users\\zhaom\\Pictures\\girl_3.gif");
FileInputStream fileInputStream=null;
DataInputStream dataInputStream=null;
FileOutputStream fileOutputStream=null;
DataOutputStream dataOutputStream=null;
try {
//创建输入流文件
fileInputStream=new FileInputStream(file);
dataInputStream=new DataInputStream(fileInputStream);
//创建输出流文件
File file1=new File("E:\\主题\\落败\\1234.png");
fileOutputStream=new FileOutputStream(file1);
dataOutputStream=new DataOutputStream(fileOutputStream);
int temp;
while ((temp=dataInputStream.read())!=-1){
if(temp!=255)
{
temp++;
}
dataOutputStream.write(temp);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
//关闭数据输出流
dataOutputStream.close();
//关闭字节输出流
fileOutputStream.close();
//关闭数据输入流
dataInputStream.close();
//关闭字节输入流
fileInputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}-
DataOutputStream 要和 DataInputStream 搭配着使用
-
接收进来的二进制文件都是以字节的方式存储
-
使用DataInputStream 将要复制到某一个盘中的二进制文件，先录入进系统，在使用DataOutStream 将文件输出到想要复制到的位置。
-
DataInputStream 类的 writeUTF() 方法能写入采用 UTF-8 字符编码的字符串。
-
DataOutputStream 类的readUTF() 方法能读取采用 UTF-8 字符编码的字符串
9.7 序列化与反序列化
-
序列就是将对象的状态更轻松简单地存储到特定介质中的过程，也就是将u第项转换为可保存或可传输格式的过程。
-
序列化的意义在于将java对象序列化后，可以将其转换为字节序列，这些字节序列可以保存在磁盘上，也可以借助网络进行传输
实现序列化和反序列化操作，需要使用对象操作流，
9.7.1 对象输出流 ObjectOutputStream 实现序列化
-
对象序列化是把一个对象变为二进制的数据流的一种方法，通过对象序列化可以方便地实现对象的传输和存储。
-
如果一个类的对象需要被序列化，则这个对象所属类必须实现 java.io.Serializable 接口
-
语法:
public interface Serializable()-
一旦某个类实现了 Serializable 接口，该类的对象就是可以序列化的。
import java.io.Serializable;
public class Person implements Serializable {
private String name;
private int age;
private String sex;
public Person(String name, int age, String sex) {
this.name = name;
this.age = age;
this.sex = sex;
}
public void print()
{
System.out.println("姓名:"+this.name+"年龄:"+this.age+"性别:"+this.sex);
}
}-
Person 类已经实现了 Serializable 接口，所以 Person 类可以被序列化
-
它可以将对象转成二进制字节数据输出到文件中保存。
一个对象如果进行序列化输出，则需要使用 ObjectOutputStream 类
| 方法 | 描述 | 类型 |
| ObjectOutputStream(OutputStream out) | 创建对象输出流对象 | 构造方法 |
| final void write(Object obj) | 将指定对象写入流 | 实例方法 |
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
public class PersonTest {
public static void main(String[] args) {
//创建一个对象输出流
ObjectOutputStream oss=null;
//创建一个File 文件处理对象
File file=new File("D:\\ljy.txt");
try {
//判断文件是否存在
if(!file.exists())
{
//如果不存在就创建一个新的文件
file.createNewFile();
}
//创建一个字节输出流对象
FileOutputStream fileOutputStream=new FileOutputStream(file);
//创建对象输出流 将字节输出流对象引用交给它
oss=new ObjectOutputStream(fileOutputStream);
//创建对象
Person person=new Person("杰米",18,"男");
//将创建好的类对象传到文件里
oss.writeObject(person);
System.out.println("序列化成功");
//刷新缓冲区
oss.flush();
//关闭对象输出流
oss.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}当我们需要保存多个对象时可以使用集合对象，最后将集合写入文件
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
import java.util.List;
public class ListObjectOutput {
public static void main(String[] args) {
//创建File 文件处理对象
File file=new File("D:\\ljy.txt");
ObjectOutputStream obs=null;
try {
//判断文件是否存在
if(!file.exists())
{
//如果不存在就新建一个文件
file.createNewFile();
}
//创建 FileOutputStream 字节输出流对象
FileOutputStream fileOutputStream=new FileOutputStream(file);
//创建对象输出流 ObjectOutputStream
obs=new ObjectOutputStream(fileOutputStream);
//创建Person对象
Person person1=new Person("李四",18,"男");
//创建Person 对象
Person person2=new Person("王五",20,"男");
//创建 ArrayList对象
List list=new ArrayList();
//创建了两个Person对象
//将它们分别放入ArrayList集合里
list.add(person1);
list.add(person2);
//将集合添加到文件中
obs.writeObject(list);
System.out.println("序列化成功");
//刷新缓冲区
obs.flush();
//关闭
obs.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}-
ArrayList 对象 list 中存储了两个 Person 对象，使用writeObject() 方法将其写入对象输出流，这样在文件中就保存了两个Person对象的数据信息。
使用对象输出流 ObjectOutputStream 序列化对象的主要步骤如下。
-
导入相关类。
-
创建可序列化的类，要求实现 Serializable 接口。
-
创建一个对象输出流 (ObjectOutputStream)，它可以包装一个其他类型的字节输出流，如文件输出流FileOutputStream。
-
通过对象输出流的 writeObject() 方法写对象，也就是输出可序列化对象。
-
关闭对象输出流。
9.7.2 对象输入流 ObjectInputStream 实现反序列化
-
执行反序列化操作需使用对象输出流 ObjectInputStream，它可以直接把序列化后的对象还原。
ObjectInputStream 类的常用方法
| 方法 | 描述 | 类型 |
| ObjectInputStream(InputStream in) | 创建对象输入流对象 | 构造方法 |
| final Object readObject() | 从指定位置读取对象 | 实例方法 |
使用对象输入流 ObjectInputStream 实现将之前序列化的Person对象 通过反序列化操作读取出来
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.ObjectInputStream;
public class InputStreamTest {
public static void main(String[] args) {
//创建一个File 文件处理对象
File file=new File("D:\\ljy.txt");
ObjectInputStream ops=null;
if(file.exists())
{
try {
//创建一个 字节输入流 FileInputStream 将file对象引用交给它
FileInputStream fileInputStream=new FileInputStream(file);
//创建一个对象输入流
ops=new ObjectInputStream(fileInputStream);
//用Person 类对象来接收读取到的数据 将读取到的数据强转成Person类
Person person=(Person)ops.readObject();
//在调用Person 的方法
person.print();
//关闭对象输入流
ops.close();
//关闭字节输入流
fileInputStream.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
}同样使用 ArrayList将文件读取到数据里
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.util.ArrayList;
import java.util.List;
public class ListInputStream {
public static void main(String[] args) {
//创建一个File 文件处理对象
File file=new File("D:\\ljy2.txt");
ObjectInputStream ops=null;
try {
if(file.exists())
{
//创建一个 字节输入流 FileInputStream 将file对象引用交给它
FileInputStream fileInputStream=new FileInputStream(file);
//创建一个对象输入流
ops=new ObjectInputStream(fileInputStream);
//使用List 集合来接受读取到的两个对象 强转成ArrayList 类型集合
List<Person> list=(ArrayList)ops.readObject();
//使用for循环遍历 将读取到的数据交给Person 对象
for (Person person:list){
//调用方法进行测试
person.print();
}
//关闭对象输入流
ops.close();
//关闭字节输入流
fileInputStream.close();
}
} catch (Exception e) {
e.printStackTrace();
}
}
}注意
-
如果使用序列化方式向文件中写入多个对象，那么反序列化恢复对象时，也要按照写入的顺序读取
-
如果希望 某一个属性信息不被序列化，只需早 属性 前添加 transient 关键字
-
private transient int age;
Java 体系中常用的流的分类
| 分类 | 字节输出流 | 字节输入流 | 字符输出流 | 字符输入流 |
| 基(父)类 | OutputStream | InputStream | Writer | Reader |
| 文件流 | FileOutputStream | FileInputStream | FileWriter | FileReader |
| 缓冲流 | BufferedOutputStream | BufferedInputStream | BufferedWriter | BufferedReader |
| 对象流 | ObjectOutputStream | ObjectInputStream | —— | |
| 数据操作流 | DataOutputStream | DataInputStream | ———— |
-
所有的基(父)类都是抽象类，无法直接创建实例，需要接触实现类。
-
所有的输出流用于实现写数据操作，所有的输入流用于实现读取操作。这个输入和输出时相对程序而言。
-
所有文件流直接与存储介质关联，也就是需指定物理节点，属于节点流其它流的创建需要在节点流的基础上进行封装，使其具有特殊的功能，比如，缓冲流再节点流的基础上增加了缓冲区，对象流在节点流的基础上可实现实例化对象。
-
在操作文本文件时，应使用字符流，操作全英文的文件时可以使用字节流、操作对象的时候可以使用对象流。
总结
-
File 类用来访问文件和目录。
-
FileInputStream 和 FileOutputStream 实现以字节流的方式读写文本文件
-
FileWriter 类和 FileReader 类实现以字符流的方式读写文件。
-
BufferedWriter 类和BufferedReader 类为字符缓冲流，具有缓冲区，执行效率高。
-
DataInputStream 和 DataOutputStream 可用于读写二进制文件。
-
序列化可以将对象储存到文件中。
-
序列化和反序列化使用对象输出/输入流 ObjectInputStream 和ObjectOutputStream。
1819
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
