- 一、IO概述
- 1.IO概念&分类
- 3.输入流和输出流的类层次图
- 二、字节流
- 1.一切即为字节
- 2.FileInputStream
- 3.FileOutputStream
- 三、字符流
- 1.FileReader
- 2.2.FileWriter
- 四、节点流和处理流
- 1.基本介绍
- 2.节点流和处理流的区别和联系
- 3.BufferedReader
- 4.BufferedWriter
- 5.BufferedInputStream
- 6.BufferedOutputStream
- 7.使用BufferedInputStream和BufferedOutputStream完成图片/音乐的拷贝
- 五、对象流
- 2.对象流介绍
- 3.ObjectOutStream
- 4.ObjectInputStream
- 5.对象处理流使用细节
- 六、Properties类
- 1.基本介绍
- 2.应用案例
IO流(Input Output Stream，输入输出流)，表示数据在程序内存和磁盘之间的传输。按照数据流的流向不同分为输入、输出流，输入流表示程序从磁盘读入数据，输出流表示程序往磁盘写数据。按照数据读取、写的方式不同分为字节流和字符流，字节流(类名以Stream结尾)表示程序按字节读取数据，什么文件都可以读取；字符流表示程序按照字符方式读取，方便读取各种编码的文本文件，但是无法读取图片、音频及视频等文件。所有的流都实现了java.io.Closeable接口，都有close方法。所有的输出流都实现了java.io.Flushable接口，都有flush方法，字符流需要手动使用flush方法才会把数据写入磁盘。
输入：把硬盘里的数据，读取到内存中使用
输出：把内存中的数据，写到硬盘中保存
一切文件数据(文本、图片、视频等)在存储时，都是以二进制数字的形式保存，都一个一个的字节，那么传输时一样如此。所以，字节流可以传输任意文件数据。在操作流的时候，我们要时刻明确，无论使用什么样的流对象，底层传输的始终为二进制数据。
2.FileInputStream该流用于从文件读取数据，它的对象可以用关键字 new 来创建。
有多种构造方法可用来创建对象。
可以使用字符串类型的文件名来创建一个输入流对象来读取文件：
InputStream f = new FileInputStream("C:/java/hello");
也可以使用一个文件对象来创建一个输入流对象来读取文件。我们首先得使用 File() 方法来创建一个文件对象：
File f = new File("C:/java/hello");
InputStream in = new FileInputStream(f);
3.FileOutputStream
该类用来创建一个文件并向文件中写数据。
如果该流在打开文件进行输出前，目标文件不存在，那么该流会创建该文件。
有两个构造方法可以用来创建 FileOutputStream 对象。
使用字符串类型的文件名来创建一个输出流对象：
OutputStream f = new FileOutputStream("C:/java/hello")
也可以使用一个文件对象来创建一个输出流来写文件。我们首先得使用File()方法来创建一个文件对象：
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.FileWriterFileWriter常用方法
（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
1.节点流是底层流/低级流，直接跟数据源相连接
2.处理流包装节点流，既可以消除不同节点流的实现差异，也可以提供更方便的方法来完成输入输出
3.处理流（也叫包装流）对节点流进行包装，使用修饰器模式，不会直接与数据源相连
处理流的功能主要体现在以下两个方面：
-
性能的提高：主要以增加缓冲的方式来提高输入输出的效率
-
操作的便捷：处理流可能提供一系列便捷的方法来一次输入输出大批量的数据，使用更加灵活方便
使用BufferedReader，读取d盘中的文件
代码演示：
package com.shangma.java.reader_;
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
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盘中写入文字
代码演示：
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完成文件拷贝，注意编码格式
代码演示：
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.BufferedOutputStreamBufferedOutputStream是字节流，实现缓冲的输出流，可以将多个字节写入底层输出流中，而不必对每次字节写入调用底层系统
7.使用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文件中
代码演示：
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，并反序列化恢复数据
代码演示：
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.基本介绍- 专门用于读写配置文件的集合类
配置文件的格式： 键=值 - 注意：键值对不需要有空格，值不需要用引号引起来。默认类型String
- Properties的常见方法：
load：加载配置文件的键值对到Properties对象
list：将数据显示到指定设备
getProperty(key)：根据键获取值
setProperty(key,value)：设置键值对到Properties对象
store：将Properties中的键值对存储到配置文件，在idea中，保存信息到配置文件，如果含有中文，会存储为Unicode码
1.使用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中
public class Properties01 {
public static void main(String[] args) throws IOException {
Properties properties = new Properties();
//创建
//1.如果该文件没有key，就是创建
//2.如果该文件有key，就是修改
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("保存配置文件成功~");
}
}
