IO流（二）
| 阿里云国内75折 回扣 微信号：monov8 |
| 阿里云国际，腾讯云国际，低至75折。AWS 93折 免费开户实名账号 代冲值 优惠多多 微信号：monov8 飞机：@monov6 |
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.
3Properties的常见方法
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存储到文件里面的时候后面的为nullNull的含义为注释
我们追加进去查看源码如下所示
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值相同则为替换否则就是增加新的值。
