2022-08-09 java之字节流、字符流

[TOC](目录)

# 一、IO概述
## 1.IO概念&分类
输入：把硬盘里的数据，读取到内存中使用
输出：把内存中的数据，写到硬盘中保存

## 3.输入流和输出流的类层次图

# 二、字节流

## 1.一切即为字节
一切文件数据(文本、图片、视频等)在存储时，都是以二进制数字的形式保存，都一个一个的字节，那么传输时一样如此。所以，字节流可以传输任意文件数据。在操作流的时候，我们要时刻明确，无论使用什么样的流对象，底层传输的始终为二进制数据。

## 2.FileInputStream
该流用于从文件读取数据，它的对象可以用关键字 new 来创建。
有多种构造方法可用来创建对象。
可以使用字符串类型的文件名来创建一个输入流对象来读取文件：

```java
InputStream f = new FileInputStream("C:/java/hello");
```

也可以使用一个文件对象来创建一个输入流对象来读取文件。我们首先得使用 File() 方法来创建一个文件对象：
```java
File f = new File("C:/java/hello");
InputStream in = new FileInputStream(f);
```

## 3.FileOutputStream
该类用来创建一个文件并向文件中写数据。
如果该流在打开文件进行输出前，目标文件不存在，那么该流会创建该文件。
有两个构造方法可以用来创建 FileOutputStream 对象。

使用字符串类型的文件名来创建一个输出流对象：

```java
OutputStream f = new FileOutputStream("C:/java/hello")
```

也可以使用一个文件对象来创建一个输出流来写文件。我们首先得使用File()方法来创建一个文件对象：

```java
File f = new File("C:/java/hello");
OutputStream fOut = new FileOutputStream(f);
```

# 三、字符流
## 1.FileReader

FileReader相关方法：

（1）new FileReader(File/String)

（2）read：每次读取单个字符，返回该字符，如果到文件末尾返回-1

（3）read( char[] )：将char[]转成String

相关API：

（1）new String( char[] )：将char[]转换成String

（2）new String(char[],off,len)：将char{]的指定部分转换成String


## 2.2.FileWriter
FileWriter常用方法

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

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

（3）writer(int)：写入单个字符

（4）writer(chat[])：写入指定数组

（5）writer(char[],off,len)：写入指定数组的指定部分

（6）writer(String)：写入整个字符串

（7）writer(String，off，len)：写入字符串的指定部分

相关API：

String类：toCharArray：将String转换为char[]

注意：

FileWriter使用后，必须要关闭（close）或刷新（flush），否则写入不到指定的文件

# 四、节点流和处理流
## 1.基本介绍
1.节点流可以从一个特定的数据源读写数据，如FileReader，FlieWriter
2.处理流（也叫包装流）是连接在已存在的流（节点流或处理流）之上，为程序提供更为强大的读写功能，如BufferedReader、BufferedWriter

## 2.节点流和处理流的区别和联系

1.节点流是底层流/低级流，直接跟数据源相连接

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

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

处理流的功能主要体现在以下两个方面：

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

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

## 3.BufferedReader
使用BufferedReader，读取d盘中的文件

代码演示：

```java
package com.shangma.java.reader_;

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

/**
* 演示BufferedReader使用
*/
public class BufferedReader_ {
public static void main(String[] args) {

String filePath = "d:\\story.txt";
BufferedReader bufferedReader = null;
try {
bufferedReader = new BufferedReader(new FileReader(filePath));

String line;
while ((line = bufferedReader.readLine())!=null){
System.out.println(line);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally {
if (bufferedReader != null){
try {
//关闭流，这里注意，只需要关闭BufferedReader，因为底层会自动的去关闭节点流
bufferedReader.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
```

## 4.BufferedWriter
使用BufferedWriter，向d盘中写入文字

代码演示：

```java
/**
* 演示BufferedWriter的使用
*/
public class BufferedWriter_ {
public static void main(String[] args) {

String filePath = "d:\\hello.txt";
BufferedWriter bufferedWriter = null;
String str = "救赎之道，就在其中~";
try {
bufferedWriter = new BufferedWriter(new FileWriter(filePath,true));
bufferedWriter.write(str);
bufferedWriter.newLine();//插入一个换行符
bufferedWriter.write(str);
bufferedWriter.write(str);
System.out.println("写入成功！");
} catch (IOException e) {
e.printStackTrace();
}finally {
if (bufferedWriter != null){
try {
bufferedWriter.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
```

4.使用BufferedReader和BufferedWriter完成文件拷贝
综合使用BufferedReader和BufferedWriter完成文件拷贝，注意编码格式

代码演示：

```java

/**
* 演示使用BufferedReader和BufferedWriter完成文件拷贝
*/
public class BufferedCopy_ {
public static void main(String[] args) {

//注意
//1.BufferedReader和BufferedWriter是按照字符操作的
//2.不要去操作二进制文件，可能造成文件损坏

String sourceFilePath = "d:\\story.txt";//源文件路径
String destFilePath = "d:\\dest.txt";//目的地文件路径

BufferedReader bufferedReader = null;
BufferedWriter bufferedWriter = null;

try {
bufferedReader = new BufferedReader(new FileReader(sourceFilePath));
bufferedWriter = new BufferedWriter(new FileWriter(destFilePath));
String line;
while ((line = bufferedReader.readLine()) != null){
//每读入一行，就写入一行
bufferedWriter.write(line);
//换行
bufferedWriter.newLine();
}
System.out.println("文件拷贝成功！");
} catch (IOException e) {
e.printStackTrace();
}finally {
//关闭输入输出流
try {
if (bufferedReader != null){
bufferedReader.close();
}
if (bufferedWriter != null){
bufferedWriter.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
```
## 5.BufferedInputStream
BufferedInputStream是字节流，在创建BufferedInputStream时，会创建一个内部缓冲数组

 

## 6.BufferedOutputStream
BufferedOutputStream是字节流，实现缓冲的输出流，可以将多个字节写入底层输出流中，而不必对每次字节写入调用底层系统

 

## 7.使用BufferedInputStream和BufferedOutputStream完成图片/音乐的拷贝
要求：编程完成图片/音乐的拷贝

代码演示：

```java
/**
* 演示BufferedInputStream和BufferedOutputStream的使用
*/
public class BufferedCopy02_ {
public static void main(String[] args) {

String sourceFilePath = "d:\\picture.jpg";
String destFilePath = "d:\\picture02.jpg";

BufferedInputStream bufferedInputStream = null;
BufferedOutputStream bufferedOutputStream = null;

try {
bufferedInputStream = new BufferedInputStream(new FileInputStream(sourceFilePath));
bufferedOutputStream = new BufferedOutputStream(new FileOutputStream(destFilePath));

//循环读取文件，并写入到destFilePath
byte[] buf = new byte[1024];
int readLength = 0;
//当返回-1，就表示文件读取完毕
while((readLength = bufferedInputStream.read(buf)) != -1){
bufferedOutputStream.write(buf);
}
System.out.println("拷贝完毕~~~");
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally {
try {
if (bufferedInputStream != null){
bufferedInputStream.close();
}
if (bufferedOutputStream != null){
bufferedOutputStream.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
```
# 五、对象流
1.序列化与反序列化
看一个需求：

1.将int num = 100，这个int数据保存到文件中，注意不是数字，而是int 100，并且，能够从文件中直接恢复int 100

2.将Dog dog = new Dog(”小黄“,3)，这个dog对象保存到文件中，并且能够从文件恢复

3.上面的要求，就是能够将基本数据类型或者对象进行序列化和反序列化操作

序列化和反序列化

1.序列化就是在保存数据时，保存数据的值和数据类型

2.反序列化就是在恢复数据时，恢复数据的值和数据类型

3.需要让某个对象支持序列化机制，则必须让其类时可序列化的，为了让某个类是可序列化的，该类必须实现如下两个接口之一：
Serializable：这是一个标记接口，没有方法

Externalizable：该接口有方法需要实现，因此我们一般实现上面的Serializable接口
## 2.对象流介绍
1.功能：提供了对基本类型或对象类型的序列化和反序列化

2.ObjectOutStream提供了序列化功能

3.ObjectInputStream提供了反序列化功能

 

 

## 3.ObjectOutStream
使用ObjectOutStream序列化基本数据类型和一个Dog对象(name,age)，并保存到data.dat文件中

代码演示：

```java
/**
* 演示ObjectOutputStream的使用，完成数据的序列化
*/
public class ObjectOutputStream_ {
public static void main(String[] args) {
//序列化后，保存的文件格式，不是存文本，而是按照他的格式来保存
String destFilePath = "d:\\data.dat";

ObjectOutputStream objectOutputStream = null;

try {
objectOutputStream = new ObjectOutputStream(new FileOutputStream(destFilePath));
//序列化数据到 e：\\data.dat
objectOutputStream.writeInt(100);//int -> Integer(实现了 Serializable接口)
objectOutputStream.writeBoolean(true);//boolean -> Boolean(实现了 Serializable接口)
objectOutputStream.writeChar('a');//char -> Character(实现了 Serializable接口)
objectOutputStream.writeDouble(9.5);//double -> Double(实现了 Serializable接口)
objectOutputStream.writeUTF("哈哈");//String(实现了 Serializable接口)

//保存一个dog对象
objectOutputStream.writeObject(new Dog("旺财",12));

System.out.println("数据保存完毕(序列化形式)");
} catch (IOException e) {
e.printStackTrace();
}finally {
if (objectOutputStream != null){
try {
objectOutputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}

//如果需要序列化某个类的对象，实现Serializable接口
class Dog implements Serializable{
private String name;
private int age;

public Dog(String name, int age) {
this.name = name;
this.age = age;
}
}
```
## 4.ObjectInputStream
使用ObjectInputStream读取data.dat，并反序列化恢复数据

代码演示：
```java
/**
* 演示ObjectInputStream的使用，对数据反序列化
*/
public class ObjectInputStream_ {
public static void main(String[] args) {

String filePath = "d:\\data.dat";
ObjectInputStream objectInputStream = null;


try {
objectInputStream = new ObjectInputStream(new FileInputStream(filePath));

//读取
//1.读取（反序列化）的顺序需要和你保存数据（序列化）的顺序一样
//2.否则就会出现异常
System.out.println(objectInputStream.readInt());
System.out.println(objectInputStream.readBoolean());
System.out.println(objectInputStream.readChar());
System.out.println(objectInputStream.readDouble());
System.out.println(objectInputStream.readUTF());
System.out.println(objectInputStream.readObject());

} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
```

## 5.对象处理流使用细节
1.读写顺序要一致

2.要求实现序列化或反序列化

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

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

5.序列化对象时，要求里边属性的类型也需要序列化接口

6.序列化具备可继承性，也就是如果某类已经实现了序列化，则它的所有子类也已经默认实现了序列化
# 六、Properties类
## 1.基本介绍
1. 专门用于读写配置文件的集合类
配置文件的格式： 键=值
2. 注意：键值对不需要有空格，值不需要用引号引起来。默认类型String
3. Properties的常见方法：

load：加载配置文件的键值对到Properties对象
list：将数据显示到指定设备
getProperty(key)：根据键获取值
setProperty(key,value)：设置键值对到Properties对象
store：将Properties中的键值对存储到配置文件，在idea中，保存信息到配置文件，如果含有中文，会存储为Unicode码

 

## 2.应用案例
1.使用Properties类完成对mysql.properties的读取

```java
/**
* 使用Properties类来读取mysql.properties文件
*/
public class Properties01 {
public static void main(String[] args) throws IOException {

//1.创建Properties对象
Properties properties = new Properties();
//2.加载指定配置文件
properties.load(new FileReader("mysql.properties"));
//3.把k-v显示控制台
properties.list(System.out);
//4.根据key获取对应的值
String username = properties.getProperty("username");

}
}
```

2.使用Properties类添加key-val到新文件mysql02.properties中

```java

/**
* 使用Properties类来创建配置文件，修改文件内容
*/
public class Properties01 {
public static void main(String[] args) throws IOException {

Properties properties = new Properties();

//创建
//1.如果该文件没有key，就是创建
//2.如果该文件有key，就是修改
/**
* Properties父类是Hashtable，底层就是Hashtable核心方法
*/
properties.setProperty("username","汤姆");
properties.setProperty("password","123456");

//将k-v储存文件即可
//如果使用的是字节流是unicode编码
//properties.store(new FileOutputStream("src\\mysql02.properties"),null);//unicode编码

properties.store(new FileWriter("src\\mysql02.properties"),"mysqlPropertiesFile");//中文
System.out.println("保存配置文件成功~");
}
}
```