一、文件

1.基本概念

文件：文件是保存数据的地方，比如经常使用的word文档，txt文件，excel文件…都是文件。它既可以保存一张图片，也可以保持视频，声音…

文件流：文件在程序中是以流的形式来操作的

流：数据在数据源(文件)和程序(内存)之间经历的路径

输入流：数据从数据源(文件)到程序(内存)的路径

输出流：数据从程序(内存)到数据源(文件)的路径

理解：输入和输出是针对java程序(内存)而言的

2.常用操作

（一）创建文件对象相关构造器

（1）new File(String pathname)//根据路径构建一个File对象

需要注意的是：这里的file对象，在java程序中，只是一个对象，只有执行了createNewFile 方法，才会真正的在磁盘创建该文件

String filePath = "D:\\news1.txt";
File file = new File(filePath);

（2）new File(File parent,String child)//根据父目录文件+子路径构建

File parentFile = new File("D:\\");
String fileName = "news2.txt";
File file = new File(parentFile, fileName);

（3）new File(String parent,Stringchild)//根据父目录+子路径构建

String parentPath = "D:\\";
String fileName = "news3.txt";
File file = new File(parentPath, fileName);

说明：

• 文件路径中的第一个\是转义字符
• D:\\不能写成D,如果写成D表示在当前目录下 

（二）创建新文件

利用文件对像的createNewFile()方法创建新文件

file.createNewFile();

（三）获取文件的相关信息

使用文件对象的方法获取文件的相关信息

方法名	作用	使用
String getName()	获取文件名	file.getName()
String getAbsolutePath()	获取文件的绝对路径	file.getAbsolutePath()
String getParent()	获取文件的父目录	file.getParent()
long length()	获取文件的大小(字节)	file.length()
boolean exists()	判断文件/目录是否存在	file.exists()
boolean isFile()	判断是否是文件	file.isFile()
boolean isDirectory()	判断是否是目录	file.isDirectory()

（四）目录的操作和文件删除

mkdir创建一级目录、mkdirs创建多级目录、delete删除空目录或文件

方法名	作用	使用
boolean mkdir()	创建一级目录	file.mkdir()
boolean mkdirs()	创建多级目录	file.mkdirs()
boolean delete()	delete删除空目录或文件	file.delete()

二、IO流原理及流的分类

1.IO流原理

(1)l/O是Input/Output的缩写，l/O技术是非常实用的技术，用于处理数据传输。如读/写文件，网络通讯等。

(2)Java程序中，对于数据的输入/输出操作以”流(stream)”的方式进行。

(3)java.io包下提供了各种“流”类和接口，用以获取不同种类的数据，并通过方法输入或输出数据

(4)输入input:读取外部数据(磁盘、光盘等存储设备的数据)到程序(内存)中。

(5)输出output:将程序(内存)数据输出到磁盘、光盘等存储设备中

2.流的分类

（一）按操作数据单位不同分为：字节流(一个字节8 bit)一般用于二进制文件，字符流(按字符，每一个字符对应的字节数由编码方式确定，默认编码为utf-8)一般用于文本文件

（二）按数据流的流向不同分为：输入流，输出流

（三）按流的角色的不同分为：节点流，处理流/包装流

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

说明：

• Java的IO流共涉及40多个类，实际上非常规则，都是从如上4个抽象基类派生的。
• 由这四个类派生出来的子类名称都是以其父类名作为子类名后缀。
• UTF-8编码方式中，一个汉字或者中文符号是3三个字节，一个英文字母或英文符号是一个字节

3.IO 流体系图

三、节点流和处理流

1.概念

（1）节点流可以从一个特定的数据源读写数据，如FileReader、FileWriter

（2）处理流(也叫包装流)是“连接”在已存在的流(节点流或处理流)之上，为程序提供更为强大的读写功能，也更加灵活，如BufferedReader、BufferedWriter 

2.节点流和处理流一览图

3.节点流和处理流的区别 

（1）节点流是底层流/低级流，直接跟数据源相接。

（2）处理流(包装流)包装节点流，既可以消除不同节点流的实现差异，也可以提供更方便的方法来完成输入输出。

（3）处理流(也叫包装流)对节点流进行包装，使用了修饰器设计模式，不会直接与数据源相连

（4）调用方法时，根据传入的对象，动态绑定到对应类的实现方法

4.处理流的功能

（1）性能的提高：主要以增加缓冲的方式来提高输入输出的效率。

（2）操作的便捷：处理流提供了一系列便捷的方法来一次输入输出大批量的数据，使用更加灵活方便

四、对象流

1.序列化和反序列化

（1）序列化就是在保存数据时，保存数据的值和数据类型
（2）反序列化就是在恢复数据时，恢复数据的值和数据类型

例如：将Dog dog =new Dog(“小黄”,3)这个dog对象保存到文件中，并且能够从文件恢复。就是将基本数据类型或者对象进行序列化和反序列化操作

2.将类可序列化

需要让某个对象支持序列化机制，则必须让其类是可序列化的，为了让某个类是可序列化的，该类必须实观如下两个接口之一：

• Serializable //这是一个标记接口，没有方法
• Externalizable //该接口有方法需要实现，因此我们一般实现上面的Serializable接口

3.对象流介绍

（1）对象流提供了对基本类型或对象类型的序列化和反序列化的方法

（2）ObjectOutputStream 提供 序列化功能

（3）ObjectInputStream 提供 反序列化功能

（4）对象流都是包装流，使用的修饰器设计模式

4.对象流注意事项

（1）读写顺序要一致，即读取(反序列化)的顺序需要和你保存数据(序列化)的顺序一致

（2）要求序列化或反序列化对象，需要实现Serializable接口

（3）序列化的类中建议添加SerialVersionUID,为了提高版本的兼容性

private static final long serialVersionUID = 1L;

（4）序列化对象时，默认将里面所有属性都进行序列化，但除了static或transient修饰的成员

（5）序列化对象时，要求里面属性的类型也需要实现序列化接口

（6）序列化具备可继承性，也就是如果某类已经实现了序列化，则它的所有子类也已经默认实现了序列化
 

五、输入流

1.InputStream

InputStream抽象类是所有类字节输入流的超类

（一）FileInputStream

（1）构造器

1)FileInputStream(File file)

参数为一个File对象

2)FileInputStream(FileDescriptor fdObj)

通过使用文件描述符 fdObj 创建一个 FileInputStream，该文件描述符表示到文件系统中某个实际文件的现有连接。

3)FileInputStream(String name)

参数name里面写文件的路径

String filePath = "D:\\news1.txt";
FileInputStream fileInputStream = new FileInputStream(filePath);

（2）常用方法

1)int read(),每次从该输入流读取一个字节的数据。 如果没有输入可用，此方法将阻止。如果返回-1 , 表示读取完毕

while ((read = fileInputStream.read()) != -1){
     System.out.println((char)read);
}

2)void close(),关闭文件流,释放资源。

fileInputStream.close();

3)int read(byte[ ] b), 从该输入流读取最多b.length字节的数据到该字节数组。读取完毕，返回-1。正常读取，返回实际读取的字节个数

String filePath = "D:\\news1.txt";
FileInputStream fileInputStream = new FileInputStream(filePath);
byte[] b = new byte[5];//建立一个字节数组
//获取读取到的字节数
int readDate = 0;
while ((readDate = fileInputStream.read(b)) != -1){
    //将获取到的字节流数据转成字符串输出
    System.out.println(new String(b,0,readDate));
}
fileInputStream.close();

运行结果：

（二）BufferedInputStream

BufferedInputStream的直接父类是FilterInputStream,而FilterInputStream的直接父类才是InputStream

（1）构造器

1)BufferedInputStream(InputStream input),传入的是InputStream的哪个实现子类，该输入流就是对该实现子类相应种类的数据源进行操作

FileInputStream input = new FileInputStream("D:\\img1.png");
BufferedInputStream bufferedInput = new BufferedInputStream(input);

（2）常用方法

1)int read(),效果和传入参数由创建输r入流时，传入的InputStream对象决定

FileInputStream input = new FileInputStream("D:\\img1.png");
BufferedInputStream bufferedInput = new BufferedInputStream(input);
byte[] b = new byte[1024];
//这里实际调用的就是FileInputStream类实现的read方法
int len = bufferedInput.read(b);
//关闭外层包装流即可
bufferedInput.close();

（三）ObjectInputStream

该输入流为对象流，可用来序列化对象

（1）构造器

1)ObjectInputStream(InputStream input),传入的是InputStream的哪个实现子类，该输入流就是对该实现子类相应种类的数据源进行操作

String filePath = "D:\\data.dat";
ObjectInputStream ois = new ObjectInputStream(new FileInputStream(filePath));

（2）常用方法

 1)int readInt(),反序列化读入一个Int类型的值

int i = ois.readInt();

2)Boolean readBoolean(),反序列化读入一个布尔类型的值

boolean b = ois.readBoolean();

3)char readChar(),反序列化读入一个字符

char ch = ois.readChar();

4)double readDouble(),反序列化读入一个浮点数

double d = ois.readDouble();

5)String readUTF(),反序列化读入一个字符串

String s = ois.readUTF();

6)Object readObject(),反序列化读入一个对象

Object o = oos.readObject();

2.Reader

（一）FileReader

FileReader的直接父类是InputStreamReader，InputStreamReader的直接父类才是Reader

（1）构造器

1)FileReader(String s),传入一个字符串，创建一个字符输入流，字符串里为实际文件的地址

String fileName = "D:\\news2.txt";
FileReader fileReader = new FileReader(fileName);

2)FileReader(File file),传入一个文件对象，创建字符输入流

（2）常用方法

1)int read:每次读取单个字符，返回该字符，如果到文件未尾返回-1

System.out.println((char) fileReader.read());

2)int read(char[]):批量读取多个字符到数组，返回读取到的字符数，如果到文件未尾返回-1

String fileName = "D:\\news2.txt";
FileReader fileReader = new FileReader(fileName);
char[] chars = new char[3];
int len = 0;
while ((len = fileReader.read(chars)) != -1){
    String s = new String(chars, 0, len);
    System.out.println(s);
}
fileReader.close();

相关API:
new String(char[]):将char]转换成String
new String(char[],off,len):将char[的指定部分转换成String

（二）BufferedReader

BufferedReader属于字符流，是按照字符来读取数据的，关闭时只需要关闭外层包装流即可

（1）构造器

1)BufferedReader(Reader reader),传入的是reader的哪个实现子类，该输入流就是对该实现子类相应种类的数据源进行操作

FileReader fileReader = new FileReader("D:\\a.txt");
BufferedReader bufferedReader = new BufferedReader(fileReader);

（2）常用方法

1)readerLine(),按行读取，返回一个字符串，包含行内容，读取到文件末尾，就返回null

FileReader fileReader = new FileReader("D:\\a.txt");
BufferedReader bufferedReader = new BufferedReader(fileReader);
String s = "";
while ((s = bufferedReader.readLine()) != null){
    System.out.println(s);
}
//只需要关闭外层包装流即可，因为底层会自动关闭节点流
bufferedReader.close();

六、输出流

1.OutputStream

（一）FileOutputStream

（1）构造器

1)FileOutputStream(File file)传入一个 File 对象创建文件输出流。

2)FileOutputStream(File file, boolean append)传入File对象和一个布尔值创建文件输出流。布尔值如果为true，表示以追加的方式写入

3)FileOutputStream(FileDescriptor fdObj)传入一个文件描述符处创建输出文件流

4)FileOutputStream(String name)传入一个字符串，在字符串里指定文件名

5)FileOutputStream(String name, boolean append)传入一个字符串和布尔值，在字符串里指定文件名。布尔值如果为true，表示以追加的方式写入

（2）常用方法

1)void write(int b),写入一个指定字节

String fileName = "D:\\news2.txt";
FileOutputStream fileOutputStream = new FileOutputStream(fileName);
fileOutputStream.write(12);
fileOutputStream.close();

2)void write(byte[ ] b),写入指定字节数组

String fileName = "D:\\news2.txt";
FileOutputStream fileOutputStream = new FileOutputStream(fileName);
String str = "北京欢迎你";
fileOutputStream.write(str.getBytes());
fileOutputStream.close();

3)void write(byte[ ] b, int off, int len),从指定字节数组索引为off处开始，写入len个字节的数据

String fileName = "D:\\news2.txt";
FileOutputStream fileOutputStream = new FileOutputStream(fileName);
String str = "北京欢迎你";
fileOutputStream.write(str.getBytes(), 0, 6);
fileOutputStream.close();

说明：用write写入时，如果文件不存在，会新建该文件，前提是目录存在。如果文件中有内容，写入的数据会将原来的数据的覆盖

（二）BufferedOutputStream

（1）构造器

1)BufferedOutputStream(OutputStream output),传入的是OutputStream的哪个实现子类，该输入流就是对该实现子类相应种类的数据源进行操作

FileOutputStream output = new FileOutputStream("D:\\img2.png");
BufferedOutputStream bufferedOutput = new BufferedOutputStream(output);

（2）常用方法

1)void write() ,效果和传入参数由创建输出流时，传入的OutputStream对象决定

//这里实现了二进制文件的复制
FileInputStream input = new FileInputStream("D:\\img1.png");
BufferedInputStream bufferedInput = new BufferedInputStream(input);
FileOutputStream output = new FileOutputStream("D:\\img2.png");
BufferedOutputStream bufferedOutput = new BufferedOutputStream(output);
int len = 0;
byte[] b = new byte[1024];
while ((len = bufferedInput.read(b)) != -1) {
    //这里实际调用的就是FileOutputStream实现的write方法
    bufferedOutput.write(b, 0, len);
}
bufferedInput.close();
bufferedOutput.close();

（三）ObjectOutputStream

该输出流为对象流，可用来反序列化对象

（1）构造器

1)ObjectOutputStream(IOutputStream output),传入的是OutputStream的哪个实现子类，该输入流就是对该实现子类相应种类的数据源进行操作

String filePath = "e:\\data.dat";
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(filePath));

（2）常用方法

1)void write(Integer /byte[]),写入一个序列化的Integer或者字节数组

oos.writeInt(100);// int -> Integer (实现了 Serializable)

2)void writeBoolean(true),写入一个序列化的布尔值

oos.writeBoolean(true);// boolean -> Boolean (实现了 Serializable)

3)void writeChar('a'),写入一个序列化的字符

oos.writeChar('a');// char -> Character (实现了 Serializable)

4)void writeDouble(9.5),写入一个序列化的浮点数

oos.writeDouble(9.5);// double -> Double (实现了 Serializable)

5)void writeUTF("北京你好"),写入一个序列化的字符串

oos.writeUTF("北京你好");//String

6)void writeObject(new Dog_("旺财", 10),写入一个序列化的对象

oos.writeObject(new Dog_("旺财", 10));

2.Writer

（一）FileWriter

FileWriter的直接父类是OutputStreamReader，OutputStreamReader的直接父类才是Writer

（1）构造器

1)new FileWriter(File/String):覆盖模式，相当于流的指针在首端

String fileName = "D://note.txt";
FileWriter fileWriter = new FileWriter(fileName);

2)new FileWriter(File/String,true):追加模式，相当于流的指针在尾端

（2）常用方法

1)write(int):写入单个字符

2)write(char[]):写入指定数组

3)write(char[],off,len):写入指定数组的指定部分

4)write(string):写入整个字符串

String fileName = "D://note.txt";
FileWriter fileWriter = new FileWriter(fileName);
fileWriter.write("风雨过后，定见彩虹");
fileWriter.close();

5)write(string,off,len):写入字符串的指定部分

相关API:String类：toCharArray:将String转换成char[]

注意：FileWriter使用后，必须要关闭(close)或刷新(flush),否则写入不到指定的文件! 

说明：

• 用write写入时，如果文件不存在，会新建该文件，前提是目录存在。如果用覆盖模式写，第一次写入时，会先把文件中原有的内容全部删除，同一个FileWriter对象多次写入不会覆盖
• close的作用相当于关闭+flush
• 字符输出流底层依然是使用字节写入的

（二）BufferedWriter

BufferedWriter属于字符流，是按照字符来读取数据的，关闭时只需要关闭外层包装流即可

（1）构造器

BufferedWriter(Writer writer),传入的是writer的哪个实现子类，该输入流就是对该实现子类相应种类的数据源进行操作

FileWriter fileWriter = new FileWriter("a.txt",true);
BufferedWriter bufferedWriter = new BufferedWriter(fileWriter);

（2）常用方法

1)void write() ,效果和传入参数由创建输出流时，传入的reader对象决定

FileWriter fileWriter = new FileWriter("a.txt",true);
BufferedWriter bufferedWriter = new BufferedWriter(fileWriter);
//这里实际调用的是FileWriter类实现的write方法
bufferedWriter.write("string");
//关闭外层流即可
bufferedWriter.close()

2)void newLine(),插入一个换行符

bufferedWriter.newLine();

七、转换流

1.介绍

（1）InputStreamReader是Reader的子类，可以将InputStream(字节流)包装成Reader(字符

（2）OutputStreamWriter是Writer的子类，实现将OutputStream(字节流)包装成Writer(字符流)

（3）当处理纯文本数据时，如果使用字符流效率更高，并且希望有效解决中文问题，就可以将字节流转换成字符流

（4）转换流可以在使用时指定编码格式(比如utf-8,gbk,gb2312,ISO8859-1等)

2.使用

关键构造器(传入字节流和编码方式)

InputStreamReader(InputStream in, String charsetName)

OutputStreamWriter(OutputStream out, String charsetName)

（一）InputStreamReader转换流使用步骤

（1）创建字节输入流

String filePath = "D:\\a.txt";
FileInputStream fileInput = new FileInputStream(filePath);

（2）把 FileInputStream 转成 InputStreamReader，并指定编码 gbk

InputStreamReader isr = new InputStreamReader(fileInput, "gbk");

（3）把 InputStreamReader 传入 BufferedReader

BufferedReader br = new BufferedReader(isr);

（4）读取

String s = br.readLine();

（5）关闭资源，关闭外层即可

br.close()

（二） OutputStreamWriter转换流使用步骤

（1）创建字节输出流

String filePath = "D:\\a.txt";
FileOutputStream fileOutput = new FileOutputStream(filePath);

（2）把 FileOutputStream 转成 OutputStreamWriter，并指定编码 gbk

OutputStreamWriter osw = new OutputStreamWriter(fileOutput, "gbk");

（3）写入

osw.write("北京欢迎你");

（4）关闭资源，关闭外层即可

osw.close();

八、标准输入输出流

1.介绍

System.in 标准输入   默认输入设备键盘

System.out 标准输出   默认输出设备显示器

2.说明

（1）in 和 out 是System类中的属性，源码如下

public final static InputStream in = null;
public final static PrintStream out = null;

（2）System.in 的编译类型为   InputStream，运行类型为   BufferedInputStream

（3）System.out 的编译类型和运行类型都是 PrintStream

3.使用

（1）System.in

Scanner scanner = new Scanner(System.in);

（2）System.out

System.out.println("北京你好");

九、打印流 

PrintStream是字节打印流，PrintWriter是字符打印流

1.PrintStream

（一）结构

PrintStream的直接父类是FilterOutputStream，FilterOutputStream的直接父类才是OutputStream

（二）构造器

（1）PrintStream(OutputStream)

（2）PrintStream(String)

（3）PrintStream(File)

（三）常用方法

（1）void write(byte[])

//标准输出，打印到控制台
PrintStream printStream = System.out;
printStream.write("北京你好".getBytes());

（1）void print(String),不换行打印到控制台(该方法底层调用的就是write方法)

PrintStream printStream = System.out;
printStream.print("北京你好");

（3）修改打印流输出的位置/设备

System.setOut(new PrintStream("D:\\f1.txt"));
System.out.println("北京你好");

2.PrintWriter

（一）结构

PrintWriter的直接父类介绍Writer

（二）构造器

（1）PrintWriter(Writer)

（2）PrintWriter(OutputStream)

//传入标准输出就会打印到控制台
PrintWriter printWriter = new PrintWriter(System.out);

（3）PrintWriter(String)

（4）PrintWriter(File)

（三）常用方法

（1）print(String),打印，最后必须调用close方法才会真正打印成功

PrintWriter printWriter = new PrintWriter(new FileWriter("D:\\f2.txt"));
printWriter.print("hi, 北京你好~~~~");
printWriter.close();//flush + 关闭流, 才会将数据写入到文件..

十、Properties类

1.介绍

（1）专门用于读写配置文件的集合类

配置文件的格式：

键=值

键=值

ip=192.168.100.100
user=root
pwd=12345

（2）键值对不需要有空格，值不需要用引号括起来。默认类型是String

（3）创建Properties类对象

Properties properties = new Properties();

2.常用方法

（1）void load(Reader),加载指定配置文件的键值对到Properties对象(maven项目的相对路径从模块名开始写，我这里的模块名为chapter19_)

properties.load(new FileReader("chapter19_\\src\\main\\resources\\mysql.properties"));

（2）void list(PrintStream/printWrite),将键值对显示到指定设备

//显示到控制台
properties.list(System.out);

（3）String getProperty(String key),根据键获取值

String user = properties.getProperty("user");

（4）Object setProperty(String key, String value),设置键值对到Properties对象,如果key相同会替换value

 properties.setProperty("user", "汤姆");//注意保存时，是中文的 unicode码值

（5）void store(OutputStream,String),将Properties中的键值对存储到配置文件，在idea中，保存信息到配置文件，如果含有中文，会存储为unicode码，第二个参数为描述信息

properties.store(new FileOutputStream("chapter19_\\src\\main\\resources\\mysql2.properties"), null);