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; } @Override public 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; } @Override public 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; } @Override public 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的运行类型是 Dog Object 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的运行类型是 Dog Object 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; } @Override public 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; } @Override public 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 运行类型 BufferedInputStream System.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 运行类型 PrintStream System.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传入 BufferedReader BufferedReader 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和pwd
BufferedReader 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和pwd
BufferedReader 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和pwd BufferedReader 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 null if (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<K,V> entry = (Entry<K,V>)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,就addEntry return null; }Properties父类是Hashtable,底层就是Hashtable核心方法，如果hash值相同，则为替换，否则就是增加新的值。
扫一扫
186
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
