1.对象流-ObjectInputStream和ObjectOutputStream（处理流包装流）的基本原理

看一个需求：

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

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

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

序列化和反序列化：

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

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

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

Serializable  //这是一个标记接口（声明性质的，没有方法）

Externalizable （该接口有方法需要实现，因此我们一般实现上面的Serializable接口

 功能：提供了对基本类型或对象类型的序列化和反序列化的方法

2.ObjectOutputStream提供序列化功能

 其中OutputStream是一个抽象类

3.ObjectInputStream提供反序列化功能

 我们从构造器里面也可以看出来处理流和包装流的概念，我们发现.ObjectInputStream有一个.构造器InputStream，它可以接收一个InputStream。即只要是InputStream的子类都可以发生进去。即像我们之前所说的修饰器模式。

2.ObjectOutputStream的使用

2.1使用ObjectOutputStream序列化基本数据类型和一个Dog对象（name,age),并保存到a.txt文件中

我们设计的代码如下所示：

package com.rgf.outputStream_;import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.Serializable;/*** 演示ObjectOutputStream的使用，完成数据的序列化*/
public class ObjectOutStream_ {public static void main(String[] args) throws Exception {//序列化后，保存的文件格式，不是存文本，而是按照他的格式来保存String filePath="E:\\a.txt";ObjectOutputStream cos = new ObjectOutputStream(new FileOutputStream(filePath));//序列化数据到E：\\a.txt;cos.writeInt(100);//int ->Integer(实现了Serializable接口)cos.writeBoolean(true); //boolean ->Boolean(实现了Serializable接口)cos.writeChar('a');//char ->Character(实现了Serializable接口)cos.writeDouble(9.5); //double->Double (实现了Serializable接口)cos.writeUTF("蕾峰编程"); //String//保存一个Dog对象cos.writeObject(new Dog("旺财",3));cos.close();System.out.println("数据保存完毕（序列化形式）");}}//如果需要序列化某个类的对象，必须实现Serializable接口
class  Dog implements Serializable {private  String name;private  int age;public Dog(String name, int age) {this.name = name;this.age = age;}}

 我们运行之后如下所示：

 虽然是乱码，但是我们也可以看出来。比如Dog，序列化的文件并不会跟着文件的后缀形式而进行保存之后的呈现。而是有自己的表现方式。

2.2使用ObjectInputStream读取a.txt并反序列化恢复数据

我们的代码如下所示：

package com.rgf.fileInputStream;import java.io.FileInputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;public class ObjectInputStream_ {public static void main(String[] args) throws Exception{//指定反序列化的文件String filePath="e:\\a.txt";ObjectInputStream ois = new ObjectInputStream(new FileInputStream(filePath));//读取//1.读取（反序列化）的顺序需要和你保存数据（序列化）的顺序一致//2.否则会出现异常System.out.println(ois.readInt());System.out.println(ois.readBoolean());System.out.println(ois.readChar());System.out.println(ois.readDouble());System.out.println(ois.readUTF());Object dog = ois.readObject();System.out.println("运行类型="+dog.getClass());System.out.println("dog信息="+dog);  //底层 将Object会转成Dog.//关闭流,关闭外层流即可，底层会关闭  FileInputStream流ois.close();}
}

我们运行之后如下所示：

我们发现在输出里面，我们没有输出dog的详细信息。为了出现这个详细信息，我们需要重写这个方法。我们重写toString方法如下所示：

package com.rgf.outputStream_;import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.Serializable;/*** 演示ObjectOutputStream的使用，完成数据的序列化*/
public class ObjectOutStream_ {public static void main(String[] args) throws Exception {//序列化后，保存的文件格式，不是存文本，而是按照他的格式来保存String filePath="E:\\a.txt";ObjectOutputStream cos = new ObjectOutputStream(new FileOutputStream(filePath));//序列化数据到E：\\a.txt;cos.writeInt(100);//int ->Integer(实现了Serializable接口)cos.writeBoolean(true); //boolean ->Boolean(实现了Serializable接口)cos.writeChar('a');//char ->Character(实现了Serializable接口)cos.writeDouble(9.5); //double->Double (实现了Serializable接口)cos.writeUTF("蕾峰编程"); //String//保存一个Dog对象cos.writeObject(new Dog("旺财",3));cos.close();System.out.println("数据保存完毕（序列化形式）");}}//如果需要序列化某个类的对象，必须实现Serializable接口
class  Dog implements Serializable {private String name;private int age;public Dog(String name, int age) {this.name = name;this.age = age;}@Overridepublic String toString() {return "Dog{"+"name='" +name + '\''+",age="+ age+'}';}}

 我们重新执行序列化代码，再执行反序列化代码，如下所示：

 我们发现可以拿到了dog的详细信息，所以我们在反序列化的时候，我们要对这个类进行处理并且拿到。

我们发现如下原因：

我们在dog里面创建get和set方法：
 

package com.rgf.outputStream_;import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.Serializable;/*** 演示ObjectOutputStream的使用，完成数据的序列化*/
public class ObjectOutStream_ {public static void main(String[] args) throws Exception {//序列化后，保存的文件格式，不是存文本，而是按照他的格式来保存String filePath="E:\\a.txt";ObjectOutputStream cos = new ObjectOutputStream(new FileOutputStream(filePath));//序列化数据到E：\\a.txt;cos.writeInt(100);//int ->Integer(实现了Serializable接口)cos.writeBoolean(true); //boolean ->Boolean(实现了Serializable接口)cos.writeChar('a');//char ->Character(实现了Serializable接口)cos.writeDouble(9.5); //double->Double (实现了Serializable接口)cos.writeUTF("蕾峰编程"); //String//保存一个Dog对象cos.writeObject(new Dog("旺财",3));cos.close();System.out.println("数据保存完毕（序列化形式）");}}//如果需要序列化某个类的对象，必须实现Serializable接口
class  Dog implements Serializable {private String name;private int age;public Dog(String name, int age) {this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}@Overridepublic String toString() {return "Dog{"+"name='" +name + '\''+",age="+ age+'}';}}

我们发现在反序列化的时候是无法进行调用dog的get方法的。

我们将Dog类公共化，我们进行修改代码如下所示

package com.rgf.outputStream_;import java.io.Serializable;public class  Dog implements Serializable {private String name;private int age;public Dog(String name, int age) {this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}@Overridepublic String toString() {return "Dog{"+"name='" +name + '\''+",age="+ age+'}';}}

我们修改代码如下所示：

package com.rgf.fileInputStream;import com.rgf.outputStream_.Dog;import java.io.FileInputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;public class ObjectInputStream_ {public static void main(String[] args) throws Exception{//指定反序列化的文件String filePath="e:\\a.txt";ObjectInputStream ois = new ObjectInputStream(new FileInputStream(filePath));//读取//1.读取（反序列化）的顺序需要和你保存数据（序列化）的顺序一致//2.否则会出现异常System.out.println(ois.readInt());System.out.println(ois.readBoolean());System.out.println(ois.readChar());System.out.println(ois.readDouble());System.out.println(ois.readUTF());//dog的编译类型是 Object,dog的运行类型是 DogObject dog = ois.readObject();System.out.println("运行类型="+dog.getClass());System.out.println("dog信息="+dog);  //底层 将Object会转成Dog.//这里是特别重要的细节：//1.如果我们希望调用Dog的方法,需要向下转型//2.需要我们将Dog类的定义，拷贝到可以引用的位置Dog dog2=(Dog)dog;System.out.println(dog2.getName());   //旺财//关闭流,关闭外层流即可，底层会关闭  FileInputStream流ois.close();}
}

我们运行之后如下所示：

 节点流和处理流

2.3节点流和处理流的注意事项

（1）读写顺序要一致

当我们改变顺序的时候，我们的代码如下所示：

package com.rgf.fileInputStream;import com.rgf.outputStream_.Dog;import java.io.FileInputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;public class ObjectInputStream_ {public static void main(String[] args) throws Exception{//指定反序列化的文件String filePath="e:\\a.txt";ObjectInputStream ois = new ObjectInputStream(new FileInputStream(filePath));//读取//1.读取（反序列化）的顺序需要和你保存数据（序列化）的顺序一致//2.否则会出现异常System.out.println(ois.readUTF());System.out.println(ois.readInt());System.out.println(ois.readBoolean());System.out.println(ois.readChar());System.out.println(ois.readDouble());//dog的编译类型是 Object,dog的运行类型是 DogObject dog = ois.readObject();System.out.println("运行类型="+dog.getClass());System.out.println("dog信息="+dog);  //底层 将Object会转成Dog.//这里是特别重要的细节：//1.如果我们希望调用Dog的方法,需要向下转型//2.需要我们将Dog类的定义，拷贝到可以引用的位置Dog dog2=(Dog)dog;System.out.println(dog2.getName());   //旺财//关闭流,关闭外层流即可，底层会关闭  FileInputStream流ois.close();}
}

我们运行之后会出现如下错误：

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

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

我们可以在我们设置的dog类进行演示：

package com.rgf.outputStream_;import java.io.Serializable;public class  Dog implements Serializable {private String name;private int age;//增加序列化的版本号后，我们增加新的东西只会认为是一个版本的修改，而不会认为是一个新的类。private String hobby; //serialVersionUID 序列化的版本号，可以提高兼容性private static final long serialVersionUID=1L;public Dog(String name, int age) {this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}@Overridepublic String toString() {return "Dog{"+"name='" +name + '\''+",age="+ age+'}';}}

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

我们进行示例如下所示：

我们的dog类如下所示：

package com.rgf.outputStream_;import java.io.Serializable;public class  Dog implements Serializable {private String name;private int age;//（4）序列化对象时，默认将里面所有属性都进行序列化，但除了static或transient修饰的成员
private static String nation;
private transient String color;public Dog(String name, int age,String nation,String color) {this.name = name;this.age = age;this.color=color;this.nation=nation;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}@Overridepublic String toString() {return "Dog{" +"name='" + name + '\'' +", age=" + age +", color='" + color + '\'' +'}' +nation ;}
}

我们增加了dog类的属性，同时用static和 transient进行修饰，我们进行写入如下所示：

package com.rgf.outputStream_;import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.Serializable;/*** 演示ObjectOutputStream的使用，完成数据的序列化*/
public class ObjectOutStream_ {public static void main(String[] args) throws Exception {//序列化后，保存的文件格式，不是存文本，而是按照他的格式来保存String filePath="E:\\a.txt";ObjectOutputStream cos = new ObjectOutputStream(new FileOutputStream(filePath));//序列化数据到E：\\a.txt;cos.writeInt(100);//int ->Integer(实现了Serializable接口)cos.writeBoolean(true); //boolean ->Boolean(实现了Serializable接口)cos.writeChar('a');//char ->Character(实现了Serializable接口)cos.writeDouble(9.5); //double->Double (实现了Serializable接口)cos.writeUTF("蕾峰编程"); //String//保存一个Dog对象cos.writeObject(new Dog("旺财",3,"中国","白色"));cos.close();System.out.println("数据保存完毕（序列化形式）");}}

我们进行输出后如下所示：

 

 我们打开文件可以查看到序列化里面只有name和age,而没有color和nation。

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

我们创建Master类如下所示：

package com.rgf.outputStream_;public class Master {}

我们之后在dog类里面引用这个类：

//序列化对象时，要求里面属性的类型也需要实现序列化接口private Master master = new Master();

 我们没有实现接口进行序列化的时候，我们发现出现了报错：

 我们修改master来实现seeializable接口：

package com.rgf.outputStream_;import java.io.Serializable;public class Master implements Serializable {}

我们修改我们的tostring,如下所示：

 public String toString() {return "Dog{" +"name='" + name + '\'' +", age=" + age +", color='" + color + '\'' +'}' +nation+ ""+master ;}
}

 我们运行之后如下所示：

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

3.标准输入输出流

	类型	默认设备
System.in  标准输入   （System里面的一个属性）	InputStream	键盘
System.out  标准输出   （System里面的一个属性）	PrintStream	显示器

我们进行演示如下所示：

package com.rgf.standard;public class InputAndOutput {public static void main(String[] args) {//public final static InputStream in = null;System.in}
}

我们查看源码如下所示：

我们查看他们的类型如下所示：

package com.rgf.standard;public class InputAndOutput {public static void main(String[] args) {//System 类 的 public final static InputStream in = null;//System.in 编译类型 InputStream//System.in 运行类型 BufferedInputStreamSystem.out.println(System.in.getClass());}
}

 我们运行之后如下所示：

 我们查看System.out的类型：

package com.rgf.standard;public class InputAndOutput {public static void main(String[] args) {//System 类 的 public final static InputStream in = null;//System.in 编译类型 InputStream//System.in 运行类型 BufferedInputStream(字节流、处理流）//表示标准输入  键盘System.out.println(System.in.getClass());//System 类 的  public final static PrintStream out = null;//System.out 编译类型  PrintStream//System.out 运行类型  PrintStream//表示标准输出  显示器System.out.println(System.out.getClass());}
}

我们运行之后如下所示：

 我们的案例如下所示：

package com.rgf.standard;import java.util.Scanner;public class InputAndOutput {public static void main(String[] args) {//System 类 的 public final static InputStream in = null;//System.in 编译类型 InputStream//System.in 运行类型 BufferedInputStream(字节流、处理流）System.out.println(System.in.getClass());//System 类 的  public final static PrintStream out = null;//System.out 编译类型  PrintStream//System.out 运行类型  PrintStreamSystem.out.println(System.out.getClass());System.out.println("hello,蕾峰编程");Scanner scanner = new Scanner(System.in); //BufferedInputStream.System.out.println("请输入内容");String next = scanner.next();System.out.println("next="+next);}
}

我们运行之后如下所示：

4.转换流  InputStreamReader和OutputStreamWriter

 我们设计的代码如下所示：
 

package com.rgf.transformation;import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;/*** 看一个中文乱码问题**/
public class CodeQuestion {public static void main(String[] args) throws IOException {//读取e:\\b.txt文件到程序//思路//1.创建字符输入流 BufferedReader (处理流，处理流里面可以放一个节点流Buffered）//2.使用BufferedReader对象读取a.txt//3.默认情况下，读取文件是按照UTF-8编码String filePath="e:\\b.txt";BufferedReader br = new BufferedReader(new FileReader(filePath));String s = br.readLine();System.out.println("读取到的内容为:"+ s);br.close();}
}

 我们运行之后如下所示：

我们打开该文件，可以了解到该文件的编码为UTF-8：

当我们转换成不是UTF-8编码的时候，我们发现如下所示：

 

ANSI为国标码，为gbk码。我们进行保存而且替换掉它。

我们继续运行之后如下所示：

我们发现出现乱码了。我们没有指定我们所要读取的文件格式。而字节流是可以指定的。我们通过转换流来解决该问题。 

 介绍：

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

我们发现里面有一个方法InputStreamReader(InputStream,Charset),InputStream是字节流的抽象父类，而Charset指定他的编码。可以传入一个InputStream对象，而且可以指定处理的编码。 

2.OutputStreamWriter:Writer的子类，实现将OutputStream(字节流）包装（转换）成Writer(字符流）

 

 我们发现里面有一个方法OutputStreamWriter(OutputStream,Charset),OutputStream是字节流的抽象父类，而Charset指定他的编码。可以传入一个OutputStream对象，而且可以指定处理的编码。 

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

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

我们利用如下实例来进行熟练：
（1）字节流FileInputStream包装成（转换成）字符流InputStreamReader,对文件进行读取（按照utf-8/gbk格式），进而在包装成BufferedReader

我们设计的代码如下所示：

package com.rgf.transformation;import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;/*** 演示使用InputStreamReader转换流解决中文乱码问题* 将字节流FileInputStream转换成字符流InputStreamReader,指定编码gbk/utf-8*/
public class InputStreamReader_ {public static void main(String[] args) throws IOException {String filePath="e:\\b.txt";//解读//1.把 FileInputStream(filePath)转成 InputStreamReader//2.指定编码InputStreamReader isr = new InputStreamReader(new FileInputStream(filePath),"gbk");//3.把InputStreamReader传入 BufferedReaderBufferedReader br = new BufferedReader(isr);//4.读取String s = br.readLine();System.out.println("读取内容="+s);//5.关闭外层流br.close();}
}

我们运行之后如下所示：

 我们也可以将代码进行简洁如下所示：

package com.rgf.transformation;import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;/*** 演示使用InputStreamReader转换流解决中文乱码问题* 将字节流FileInputStream转换成字符流InputStreamReader,指定编码gbk/utf-8*/
public class InputStreamReader_ {public static void main(String[] args) throws IOException {String filePath="e:\\b.txt";//解读//1.把 FileInputStream(filePath)转成 InputStreamReader//2.指定编码//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.println("读取内容="+s);//5.关闭外层流br.close();}
}

（2）字节流FileOutputStream包装成（转换成）字符流OutputStreamWriter,对文件进行写入（按照utf-8/gbk格式），进而在包装成BufferedWriter。

我们设计的代码如下所示：
 

package com.rgf.transformation;import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;/*** 演示OutputStreamWriter 使用* 把FileOutputStream 字节流，转成字符流* 指定处理的编码 gdk/utf-8/utf8*/
public class OutputStreamWriter_ {public static void main(String[] args) throws IOException {String  filePath="e:\\b.txt";String charSet="gbk";OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(filePath), charSet);osw.write("hello,雷锋编程教育");osw.close();System.out.println("按照"+charSet+"保存文件成功");}
}

我们运行之后如下所示：

我们打开文件如下所示：

我们查看到此时的编码为ANSI编码，即为对应的gbk码。

 我们将编码修改如下所示：

package com.rgf.transformation;import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;/*** 演示OutputStreamWriter 使用* 把FileOutputStream 字节流，转成字符流* 指定处理的编码 gdk/utf-8/utf8*/
public class OutputStreamWriter_ {public static void main(String[] args) throws IOException {String  filePath="e:\\b.txt";String charSet="utf-8";OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(filePath), charSet);osw.write("hello,雷锋编程教育");osw.close();System.out.println("按照"+charSet+"保存文件成功");}
}

 我们运行之后如下所示：

我们打开文件进行查看：

 

我们发现此时为utf-8了。

5. 打印流-PrintStream(字节流）和PrintWriter（字符流）

打印流只有输出流没有输入流

PrintStream:

我们查看他的类图如下所示：

 我们进行查看他的构造方法：

我们来发现PrintStream的用法：

我们发现system.out就是PrintStream

 我们编写如下代码进行查看：

package com.rgf.printStream;import java.io.IOException;
import java.io.PrintStream;/*** 演示PrintStream(字节打印流/输出流 )*/
public class PrintStream_ {public static void main(String[] args)  throws IOException{PrintStream out=System.out;//在默认情况下，打印流PrintStream输出数据的位置是标准输出，即显示器out.print("hello,we");out.write("woaini".getBytes());//因为print底层使用的是write方法，所以我们可以直接调用write方法进行打印/输出。
/*  out.print的源码。
public void print(String s) {if (s == null) {s = "null";}write(s);}*//*我们发现真正的打印输出的是write方法：private void write(String s) {try {synchronized (this) {ensureOpen();textOut.write(s);textOut.flushBuffer();charOut.flushBuffer();if (autoFlush && (s.indexOf('\n') >= 0))out.flush();}}catch (InterruptedIOException x) {Thread.currentThread().interrupt();}catch (IOException x) {trouble = true;}}*/out.close();//我们也可以去修改打印流输出的位置/设备//setOut可以去修改PrintStream,默认为向显示器打印的。//1.输出修改成到e:\\a.txt//2.“hello,woren”就会输出到e:\\a.txt。System.setOut(new PrintStream("e:\\a.txt"));//此时文件已经切换到PrintStream里面，然后输出就会输出到里面。/*setOut的底层代码：public static void setOut(PrintStream out) {checkIO();setOut0(out);setOut0(out)的底层代码：private static native void setIn0(InputStream in);private static native void setOut0(PrintStream out); //native方法，修改了out。private static native void setErr0(PrintStream err);setOut0(out)是一个native方法。}*/System.out.println("hello,woren");}
}

我们运行之后如下所示：

我们打开文件进行查看,我们发现成功的输送出来了。

我们通过setOut方法修改了输出的位置。

我们查看PrintWriter

 

 我们查看他的构造方法

 我们设计如下代码：

package com.rgf.printStream;import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;/*** 演示PrintWriter使用方式*/
public class PrintWriter_ {public static void main(String[] args) throws IOException {PrintWriter printWriter = new PrintWriter(System.out);//  PrintWriter printWriter = new PrintWriter(new FileWriter("e:\\a.txt"));printWriter.print("hi,北京你好");printWriter.close();//printWriter.close( );没有colse就不会刷新。}
}

我们运行之后如下所示：

我们发现输送在控制台上面了。

为了输送到文件里面，我们创建如下所示：

package com.rgf.printStream;import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;/*** 演示PrintWriter使用方式*/
public class PrintWriter_ {public static void main(String[] args) throws IOException {//PrintWriter printWriter = new PrintWriter(System.out);PrintWriter printWriter = new PrintWriter(new FileWriter("e:\\a.txt"));printWriter.print("hi,北京你好");printWriter.close(); //flush+关闭流，才会将数据写入到文件。。//printWriter.close( );没有colse就不会刷新。}
}

我们运行之后如下所示：

我们发现这里没有，我们打开文件如下所示：
 

如果里面的close没有关闭，里面是不会刷新的。我们示例如下所示：

package com.rgf.printStream;import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;/*** 演示PrintWriter使用方式*/
public class PrintWriter_ {public static void main(String[] args) throws IOException {PrintWriter printWriter = new PrintWriter(System.out);//  PrintWriter printWriter = new PrintWriter(new FileWriter("e:\\a.txt"));printWriter.print("hi,北京你好");printWriter.close();//printWriter.close( );没有colse就不会刷新。flush+关闭流，才会将数据写入到文件。}
}

我们运行之后如下苏所示：

 我们发现仍然是：

 因为我们没有close,没有close就不会刷新。我们在创建文件的时候，会首先把光标定在文件的最前面，会首先把文件截断再输出，结果我们没有close,就不会刷新。

我们分析源码来判断出close的作用：

我们debug如下所示：

 

 

 PrintStream主要操作byte流，而PrintWriter用来操作字符流，读取文本文件时一般用后者。

6.Properties类

如果我们将所需要的配置文件写死，改起来会非常困难，所以我们可以将我们需要的文件写为properties文件，然后程序进行读取修改。

 看一个需求：

如下一个配置文件mysql.properties:
ip=192.168.0.13

user=root

pwd=12345

请问编程读取ip、user和pwd的值是多少

分析：

1.传统的方法

2.使用Properties类可以方便实现

我们传统的方法为：

传统的方法比较麻烦。

我们创建配置文件如下所示：

 我们设置的代码如下所示：

package com.rgf.properties_;import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;public class Properties01 {public static void main(String[] args) throws IOException {//读取mysql.properties文件，并得到ip,user和pwdBufferedReader br = new BufferedReader(new FileReader("com\\mysql.properties"));String line="";while ((line=br.readLine())!=null){  //循环读取System.out.println(line);}br.close();}
}

我们运行之后如下所示：

 我们修改代码如下所示：

package com.rgf.properties_;import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;public class Properties01 {public static void main(String[] args) throws IOException {//读取mysql.properties文件，并得到ip,user和pwdBufferedReader br = new BufferedReader(new FileReader("com\\mysql.properties"));String line="";while ((line=br.readLine())!=null){  //循环读取String[] split = line.split("=");System.out.println(split[0]+"值是："+split[1]);}br.close();}
}

我们运行之后如下所示：

 如果只打印ip,我们将代码修改如下所示：
 

package com.rgf.properties_;import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;public class Properties01 {public static void main(String[] args) throws IOException {//读取mysql.properties文件，并得到ip,user和pwdBufferedReader br = new BufferedReader(new FileReader("com\\mysql.properties"));String line="";while ((line=br.readLine())!=null){  //循环读取String[] split = line.split("=");//如果我们要求指定得到ip值if("ip".equals(split[0])) {System.out.println(split[0] + "值是：" + split[1]);}}br.close();}
}

我们运行之后如下所示：

我们对Properties类的基本介绍：

 

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

配置文件的格式：

键=值

键=值

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

（3）Properties的常见方法

load:加载配置文件的键值对到Properties对象

list:将数据显示到指定设备/流对象

getProperty(key):根据键获取值

setProperty(key,value):设置键值对到Properties对象

store:将Properties中的键值对存储到配置文件，在idea中，保存信息到配置文件，如果含有中文，会存储为unicode码(创建文件）

我们通过案例来进行了解：

1.使用Properties类完成对mysql.properties的读取。

我们设置的代码如下所示：
 

package com.rgf.properties_;import java.io.FileReader;
import java.io.IOException;
import java.util.Properties;public class Properties02 {public static void main(String[] args) throws IOException {//使用Properties类完成对mysql.properties的读取//1.创建Properties对象Properties properties = new Properties();//2.加载指定的配置文件properties.load(new FileReader("com\\mysql.properties"));//3.把k-v显示到控制台properties.list(System.out);//4.根据key获取对应的值String user = properties.getProperty("user");String pwd = properties.getProperty("pwd");System.out.println("用户名="+user);System.out.println("密码是="+pwd);}
}

运行之后如下所示：

 

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

我们设计的代码如下所示：

package com.rgf.properties_;import java.io.File;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.util.Properties;public class Properties03 {public static void main(String[] args) throws IOException {//使用Properties类来创建配置文件，修改配置文件内容//1.创建Properties对象Properties properties = new Properties();//2.创建配置文件properties.setProperty("charset","utf8");properties.setProperty("user","汤姆"); //之一保存时，是中文的unicode码值properties.setProperty("pwd","abc111");//3.将k-v存储到文件中即可。properties.store(new FileOutputStream("com\\mysql2.properties"),null);System.out.println("保存配置文件成功");//4.加载指定的配置文件properties.load(new FileReader("com\\mysql2.properties"));//5.把k-v显示到控制台properties.list(System.out);}
}

我们运行之后如下所示：

我们查看里面的mysql2.properties:

 

我们发现将k-v存储到文件里面的时候，后面的为null，Null的含义为：注释

我们追加进去查看源码，如下所示：

public void store(OutputStream out, String comments)throws IOException{store0(new BufferedWriter(new OutputStreamWriter(out, "8859_1")),comments,true);}

我们将null换成"hello  mysql",

我们发现里面的user为unicode码。我们通过查询看这个unicode码是否为汤姆。

http://tool.chinaz.com/tools/unicode.aspx 

我们发现转换后如下所示：

 3.使用Properties类完成对mysql.properties的读取，并修改某个key-val。

我们设计代码如下所示：

package com.rgf.properties_;import java.io.File;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.util.Properties;public class Properties03 {public static void main(String[] args) throws IOException {//使用Properties类来创建配置文件，修改配置文件内容//1.创建Properties对象Properties properties = new Properties();//2.创建配置文件//如果该文件没有key,就是创建，//如果该文件有key,就是修改。properties.setProperty("charset","utf8");properties.setProperty("user","汤姆"); //之一保存时，是中文的unicode码值properties.setProperty("pwd","8888888");//3.将k-v存储到文件中即可。properties.store(new FileOutputStream("com\\mysql2.properties"),"hello world");System.out.println("保存配置文件成功");//4.加载指定的配置文件properties.load(new FileReader("com\\mysql2.properties"));//5.把k-v显示到控制台properties.list(System.out);}
}

我们运行之后如下所示：

 

我们发现成功的修改过来了。 

我们查看setProperty的源码：

public synchronized Object setProperty(String key, String value) {return put(key, value);}

//hashtable不允许value为null,否则会抛异常。
public synchronized V put(K key, V value) {// Make sure the value is not nullif (value == null) {throw new NullPointerException();}// Makes sure the key is not already in the hashtable.Entry tab[] = table;int hash = key.hashCode();int index = (hash & 0x7FFFFFFF) % tab.length;@SuppressWarnings("unchecked")Entry entry = (Entry)tab[index];for(; entry != null ; entry = entry.next) {if ((entry.hash == hash) && entry.key.equals(key)) {V old = entry.value;entry.value = value; //如果key存在，就替换return old;}}addEntry(hash, key, value, index); //如果是新的key,就addEntryreturn null;}

Properties父类是Hashtable,底层就是Hashtable核心方法，如果hash值相同，则为替换，否则就是增加新的值。