节点流和处理流：
- 节点流：可以从一个特定的数据源读写数据，如FileReader、FileWriter
-
处理流(也叫包装流)是”链接”在已存在的流(节点流或处理流)之上，为程序提供更为强大的读写功能，也更加灵活，如BufferedReader、BufferWrier
区别和联系：
- 节点流是底层流/低级流，直接跟数据源相接
- 处理流包装节点流，既可以消除不同节点流的现实差异，也可以提供更方便的方法来完成输入输出
- 处理流(也叫包装流)对节点流进行包装，使用了修饰器设计模式，不会直接于数据源相连
处理流的功能主要体现在以下两个方面：
- 性能的提高：主要以增加缓冲的方式来提高输入输出的效率
- 操作的边界：处理流可能提供了一系列便捷的方法来一次输入输出大批量的数据，使用更加灵活方便
处理流：BufferedReader 和 BufferrdWriter
BufferedReader 和 BufferrdWriter属于字符流，使按照字符来读取数据的，关闭处理流时，只需要关闭外层流即可
BufferedReader类：
BufferedReader类中，有属性Reader，即可以封装一个节点流，该节点流可以是任意的，只要是Reader子类
例1：BufferedReader
public static void main(String[] args) {
String filePath = "e:\\a.java";
//创建BufferedReader
BufferedReader bufferedReader = new BufferedReader(new FileReader(filePath));
//读取
String line; //按行读取
/*
1、bufferedReader.leadLine() 是按行读取文件
2、当返回null时，表示文件读取完毕
*/
while ((line = bufferedReader.leadLine()) != null) {
System.out.print(line);
}
//关闭流，注意：只需要关闭BufferedReader，因为底层回自动关闭节点流
bufferReader.close();
}
例2：BufferedWriter
public static void main(String[] args) {
String filePath = "e:\\ok.txt";
//创建BufferedWriter
BufferedWriter bufferedWriter = new BufferrdWriter(new FileWriter(filePath));
// (new FileWriter(filePath,true)),追加
bufferrdWriter.writer("hello,bufferedWriter");
bufferrdWriter.newLine(); //插入一个和系统相关的换行
bufferrdWriter.writer("hello,bufferedWriter");
bufferrdWriter.newLine(); //插入一个和系统相关的换行
bufferrdWriter.writer("hello,bufferedWriter");
//关闭外层流即可，传入的FileWriter(filePath)会自动关闭
bufferedWriter.close();
}
Buffered拷贝：
public static void main(String[] args) {
//BufferedReader 和 BufferrdWriter是按照字符操作的，
//不要操作 二进制文件(声音，视频，doc，pdf)，可能会造成文件损坏
String srcFilePath = "e:\\a.java";
String destFilePath = "e:\\a2.java";
BufferedReader br = null;
bufferrdWriter bw = null;
String line;
//try-catch
br = new BufferedReader(new FileReader(srcFilePath));
bw = new BufferrdWriter(new FileWriter(destFilePath));
while ((line = br.readLine()) != null) {
//每读取一行，就写入
bw.writer(line);
//插入换行符
bw.newLine();
}
System.out.print("拷贝完成~");
//try-catch
finally{
//try-catch
//关闭流
if (br != nill) {
br.close()；
}
if (bw != nill) {
bw.close()；
}
//try-catch
}
}
BufferedInputStream 和 BufferedOutputStream:
- BufferedInputStream 是字节流，在创建BufferedInputStream时，会创建一个内部缓冲区数组
- BufferedOutputStream 是字节流，实现缓冲的输出流，可以将多个字节写入底层输出流中，而不必对每次字节写入调用底层系统
字节处理流拷贝文件：
public static void main(String[] args) {
String srcFilePath = "e:\\Kaola.jpg";
String destFilePath = "e:\\hsp.avi";
//创建BufferedInputStream对象 和 BufferedOutputStream对象
BufferedInputStream bis = null;
BufferedOutputStream bos = null;
//try-catch
bis = new BufferedInputStream(new FileInputStream(srcFilePath));
bos = new BufferedOutputStream(new FileOutputStream(destFilePath));
//循环读取文件，并写入到destFilePath
byte[] buff = new byte[1024];
int readLen = 0;
//当返回-1时，表示文件读取完毕
while ((readLen = bis.read(buff)) != -1) {
bos.writer(buff, 0, readLen);
}
//try-catch
finally{
//try-catch
//关闭外层处理流即可，底层会关闭节点流
if (bis != null) {
bis.close();
}
if (bos != null) {
bos.close();
}
//try-catch
}
}
对象处理流：
对象流：ObjectInputStream 和 ObjectOutputStream
需求：
- 将int num = 100 这个int数据保存到文件中，注意不是100数字，而是 int 100，并且，能够从文件中直接恢复int 100
- 将 Dog dog = new Dog(“大狗”,3) 这个dog对象 保存到文件中，并且能够从文件恢复
- 上面的要求，就是 能够将 基本数据类型 或者 对象 进行 序列化 和 反序列化操作
序列化和反序列化：
- 序列化就是在保存数据时，保存数据的值和数据类型
- 反序列化就是在恢复数据时，恢复数据的值和数据类型
- 需要让某个对象支持序列化机制，则必须让其他类是可序列化的，为了让某个类是可序列化的，
- 该类必须实现如下两个接口之一：
- SerializableSerializable //这是一个标记接口,没有方法，一般都用这个
- Externalizable //该接口有方法需要实现
基本介绍：
- 功能：提供了对基本类型或对象类型的序列化和反序列化的方法
- ObjectOutputStream 提供 序列化功能
- ObjectInputStream 提供 反序列化功能
例：
使用ObjectOutputStream序列化 基本数据类型和一个Dog对象(name,age)，并保存到data.dat文件中
public static void main(String[] args) {
//序列化后，保存的文件格式不是纯文本，而是按照他的格式来保存
String filePath = "e:\\data.dat";
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(filePath));
//序列化数据到 e:\\data.dat
oos.writeInt(100); //int->Integer(实现了 Serializable)
oos.writeBoolean(true); //boolean -> Boolean(实现了Serializable)
oos.writeChar("a"); //char->Character (实现了 Serializable)
oos.writeDouble(9.5); //doubel->Double(实现了 Serializable)
oos.writeUTF("UTF UTF");//String
//保存一个dog对象
oos.writeObject(new Dog("旺财",10));
oos.close();
System.out.print("数据保存完毕(序列化形式)");
}
//如果需要序列化某个类的对象，必须实现Serializable接口
class Dog implements Serializable{
private String name;
private int age;
/*
构造器、get、set、重写toString
*/
}
例2：
使用ObjectInputStream读取data.dat并反序列化恢复数据
public static void main(String[] args) {
//指定序列化的文件
String filePath = "e:\\data.dat";
ObjectInputStream ois = new ObjectInputStream(new FileInputStream(filePath));
//读取
/*
1、读取(但序列化)的顺序需要和保存数据(序列化)的顺序一致
2、否则会出现异常
*/
System.out.print(ois.readInt());
System.out.print(ois.readBoolean());
System.out.print(ois.readChar());
System.out.print(ois.readDouble());
System.out.print(ois.readUTF());
//dog的编译类型是Object，运行类型是Dog
Object dog = ois.readObject();
System.out.print("运行类型 = " + dog.getClass());
System.out.print("dog信息 = " + dog); //底层 Object->Dog
//如果我们希望调用Dog方法，需要向下转型
//需要我们将Dog类的定义，拷贝到可以引用的位置
//把dog类单独出来，然后导包
Dog dog2 = (Dog)dog;
System.out.print(dog2.getName());
//关闭外层流即可，底层会关闭FileInputStream流
ois.close();
}
注意事项和细节说明：
- 读写顺序要一致
- 要求实现序列化或反序列化对象，需要 实现Serializable
- 序列化的类中建议添加SerialVersionUID，为了提高版本的兼容性
- 序列化对象时，默认将里面所有属性都进行序列化，但除了static或transient修饰的成员
- 序列化对象时，要求里面属性的类型也需要实现序列化接口
- 序列化具备可继承性，也就是如果某类已经实现了序列化，则它的所有子类也已经默认实现了序列化
如：
public class Dog implements Serializable{
private String name;
private int age;
//SerialVersionUID 序列化的版本号，可以提高兼容性
private static final long serialVersionUID = 1L;
}
标准输入输出流：
| 类型 | 默认设备 | ||
|---|---|---|---|
| System.in | 标准输入 | InputStream | 键盘 |
| System.out | 标准输出 | PrintStream | 显示器 |
System.in：
System类的 public final static InputStream in = null;
System.in 的编译类型：InputStream
System.in 的运行类型：BufferedInputStream
System.out：
System.out public final static PrintStream out = null;
System.out 编译类型：PrintStream
System.out 运行类型：PrintStream
转换流:
InputStreamReader 和 OutputStreamWriter
public static void main(String[] args) {
//读取 e:\\a.txt 文件到程序
/*
1、创建字符输入流 BufferedReader(处理流)
2、使用BufferedReader 对象读取 a.txt
3、默认情况下，读取文件是按照UTF-8编码
*/
String filePath = "e:\\a.txt";
BufferedReader br = new BufferedReader(new FileReader(filePath));
String s = br.readLine();
System.out.print("读取到的内容：" + s); //如果不是按照UTF-8编码，可能会出现乱码
br.close();
}
InputStreamReader:
- InputStreamReader:Reader的子类，可以将InputStream(字节流)包装称Reader(字符流)
- OutputStreamWriter:Writer的子类，实现将OutputStream(字节流)包装成Writer(字符流)
- 当处理纯文本数据时，如果使用字符流效率更高，并且可以有效解决中文问题，所以建议将字节流转换成字符流
- 可以在使用时指定编码格式(比如 utf-8,gbk,gb2312,ISO8859-1等)
案例1：
编程将 字节流FileInputStream 包装成(转换成)字符流InputStreamReader,对文件进行读取(按照 utf-8/gbk格式)，进而再包装成BufferedReader
public static void main(String[] args) {
String filePath = "e:\\a.txt";
//1、把FileInputStream 转成InputStreamReader
//2、指定编码gbk
InputStreamReader isr = new InputStreamReader(new FileInputStream(filePath),"gbk")
//3、把InputStreamReader传入BufferedReader
BufferedReader br = new BufferedReader(isr);
//将2 和 3 合在一起
BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(filePath),"gbk"));
//4、读取
String s = br.readLine();
System.out.print("读取内容 = " + s);
//5、关闭外层流
br.close();
}
案例2：
编程将 字节流FileOutputStream 包装成(转换成)字符流OutputStreamWriter,对文件进行写入(按照gbk格式，可以指定成其他，比如utf-8)
public static void main(String[] args) {
String filePath = "e:\\hsp.txt";
String charSet = "gbk";
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(filePath),charSet);
osw.write("hi~~~");
osw.close();
System.out.print("按照 " + charSet + "保存文件成功~");
}
打印流：
只有输出流，没有输入流
PrintStream 和 PrintWriter
PrintStream：
public static void main(String[] args) {
PrintStream out = System.out;
//在默认情况下，PrintStream 输出数据的位置是 标准输出，即显示器
/*
public void print(String s){
if(s == null){
s = "null"
}
write(s)
}
*/
out.print("john,hello");
//因为print底层使用的是writer，所以我们可以直接调用writer进行打印/输出
out.write("hello~~".getBytes());
out.close();
//修改打印流输出的位置/设备
//1、修改到 e:\\f1.txt
//2、就会输出到 e:\\f1.txt
System.setOut(new PrintStream("e:\\f1.txt"));
System.out.print("hello~~~~~~~");
}
PrintWriter：
public static void main(String[] args) {
// PrintWriter printWriter = new PrintWriter(System.out);
PrintWriter printWriter = new PrintWriter(new FileWriter("e:\\f2.txt"));
printWriter.print("hi~北京~");
printWriter.close();
}
Properties类：
- 专门用于读写配置文件的集合类
配置文件的格式：
键=值
键=值
- 注意：键值对不需要有空格，值不需要用引号引起来。默认类型是String
- Properties的常见方法：
load：加载配置文件的键值对到Properties对象
list：将数据显示到指定设备
getProperty(key)：根据获取值
setProperty(key,value)：设置键值对到Properties对象
store：将Properties中的键值对存储到配置文件，在idea中，保存信息到配置文件，如果含有中文，会 存储为unicode码
public static void main(String[] args) {
//使用Properties类来读取mysql.properties文件
//1、创建Properties对象
Properties properties = new Properties();
//2、加载指定配置文件
properties.load(new FileReader("src\\mysql.properties"));
//3、把K-V显示到控制台
properties.list(System.out);
//4、根据key获取对应的值
String user = properties.getProperty("user");
String pwd = properties.getProperty("pwd");
System.out.print("用户名=" + user);
System.out.print("密码是=" + pwd);
}
案例：
- 使用Properties类完成对mysql.properties的读取
- 使用Properties类添加key-val到新文件 mysql2.properties中
- 使用Properties类完成对mtsql.properties的读取，并修改某个key-val
public static void main(String[] args) {
//使用Properties类来创建 配置文件，修改配置文件内容
Properties properties = new Properties();
//创建
//1、如果该文件没有key，就是创建
//2、如果该文件有key，就是修改
properties.setProperty(“charset”,”utf-8″);
properties.setProperty(“user”,”汤姆”); //注意保存时，是中文的 unicode码
properties.setProperty(“pwd”,”abc111″);//将k-v存储文件中即可 properties.store(new FileOutputStream("src\\mysql2.properties"),null); //null表示没有注释，也可以"XXX"写注释 System.out.print("保存配置文件成功~~");}
