JAVA IO分析二:字节数组流、基本数据&对象类型的数据流、打印流
上一节,我们分析了常见的节点流(FileInputStream/FileOutputStream FileReader/FileWrite)和常见的处理流(BufferedInputStream/BufferedOutputStream BufferedReader/BufferedWrite),经常而言我们都是针对文件的操作,然后带上缓冲的节点流进行处理,但有时候为了提升效率,我们发现频繁的读写文件并不是太好,那么于是出现了字节数组流,即存放在内存中,因此有称之为内存流;其中字节数组流也一种节点流;除了节点流外,我们也将学习另外一种处理流,即数据流。数据处理流是用于针对数据类型传输处理的,是一种处理流,即是在节点流之上的增强处理,一般用于序列化和反序列化的时候用到。下面我们言归正传,进入学习:
一、字节数组流【节点流】
字节数组流对象分为输入流和输出流。分别是:ByteArrayInputStream和ByteArrayOutputStream。
1.ByteArrayInputStream类
字节数组输入流在内存创建一个字节数组缓冲区,从输入流读取的数据保存在该字节数组缓冲区中。创建字节数组输入流对象有以下方式:
//方法 1
ByteArrayInputStream bArray = new ByteArrayInputStream(byte [] a);
//方法 2
ByteArrayInputStream bArray = new ByteArrayInputStream(byte []a, int off, int len)
字节数组流对象的方法:
序号 | 方法及描述 |
---|---|
1 | public int read() 从此输入流中读取下一个数据字节。 |
2 | public int read(byte[] r, int off, int len) 将最多 len 个数据字节从此输入流读入字节数组。 |
3 | public int available() 返回可不发生阻塞地从此输入流读取的字节数。 |
4 | public void mark(int read) 设置流中的当前标记位置。 |
5 | public long skip(long n) 从此输入流中跳过 n 个输入字节。 |
输入流样例:
ByteArrayInputStream bis=new ByteArrayInputStream(destByte);
InputStream bis=new BufferedInputStream(new ByteArrayInputStream(destByte))
说明,因为ByteArrayInputStream 是一种节点流,BufferedInputStream 一种处理流,因此可以装饰增强处理,且字节数组输入流没有新增方法,因此可以使用多态性。
/**
* 输入流 操作与 文件输入流操作一致
* 读取字节数组
* @throws IOException
*/
public static void read(byte[] src) throws IOException{
//数据源传入 //选择流
InputStream is =new BufferedInputStream(
new ByteArrayInputStream(
src
)
);
//操作
byte[] flush =new byte[1024];
int len =0;
while(-1!=(len=is.read(flush))){
System.out.println(new String(flush,0,len));
}
//释放资源
is.close();
}
2.ByteArrayOutputStream类
字节数组输出流在内存中创建一个字节数组缓冲区,所有发送到输出流的数据保存在该字节数组缓冲区中。
创建方式:
//方法 1
OutputStream bOut = new ByteArrayOutputStream();
//方法 2
OutputStream bOut = new ByteArrayOutputStream(int a);
字节数组输出流对象的方法:
序号 | 方法及描述 |
---|---|
1 | public void reset() 将此字节数组输出流的 count 字段重置为零,从而丢弃输出流中目前已累积的所有数据输出。 |
2 | public byte[] toByteArray() 创建一个新分配的字节数组。数组的大小和当前输出流的大小,内容是当前输出流的拷贝。 |
3 | public String toString() 将缓冲区的内容转换为字符串,根据平台的默认字符编码将字节转换成字符。 |
4 | public void write(int w) 将指定的字节写入此字节数组输出流。 |
5 | public void write(byte []b, int off, int len) 将指定字节数组中从偏移量 off 开始的 len 个字节写入此字节数组输出流。 |
6 | public void writeTo(OutputStream outSt) 将此字节数组输出流的全部内容写入到指定的输出流参数中。 |
说明:
输出流:ByteArrayOutputStream bos=new ByteArrayOutputStream();
由于输出流有新增方法,所以这里不可以使用多态,所以没法直接采用OutputStream来进行。
样例:
/**
* 输出流 操作与文件输出流 有些不同, 有新增方法,不能使用多态
* @throws IOException
*/
public static byte[] write() throws IOException{
//目的地
byte[] dest;
//选择流 不同点
ByteArrayOutputStream bos =new ByteArrayOutputStream();
//操作 写出
String msg ="操作与 文件输入流操作一致";
byte[] info =msg.getBytes();
bos.write(info, 0, info.length);
//获取数据
dest =bos.toByteArray();
//释放资源
bos.close();
return dest;
}
之前使用节点流中的字节流进行文件的拷贝,利用字符流进行纯文本文件的拷贝,也可以使用处理流中的字节缓冲流与字符缓冲流进行文件/文本文件的拷贝,为了将字节数组流与之前的节点流联系在一起,这里利用字节数组流做中转站,实现文件的拷贝。
步骤一:利用文件输入流读取到被拷贝文件的数据,利用字节数组输出流保存在字节数组中
步骤二:利用字节数组输入流以及文件输出流,将数据写出到目的文件中。
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream; /**
*1、文件 --程序->字节数组
*1)、文件输入流
* 字节数组输出流
*
*
* 2、字节数组 --程序->文件
* 1)、字节数组输入流
* 文件输出流
* @author Administrator
*
*/
public class ByteArrayDemo02 { /**
* @param args
* @throws IOException
*/
public static void main(String[] args) throws IOException {
byte[] data =getBytesFromFile("e:/xp/test/1.jpg");
toFileFromByteArray(data,"e:/xp/test/arr.jpg");
}
/**
* 2、字节数组 --程序->文件
*/
public static void toFileFromByteArray(byte[] src,String destPath) throws IOException{
//创建源
//目的地
File dest=new File(destPath); //选择流
//字节数组输入流
InputStream is =new BufferedInputStream(new ByteArrayInputStream(src));
//文件输出流
OutputStream os =new BufferedOutputStream(new FileOutputStream(dest)); //操作 不断读取字节数组
byte[] flush =new byte[1];
int len =0;
while(-1!=(len =is.read(flush))){
//写出到文件中
os.write(flush, 0, len);
}
os.flush(); //释放资源
os.close();
is.close();
} /**
* 1、文件 --程序->字节数组
* @return
* @throws IOException
*/
public static byte[] getBytesFromFile(String srcPath) throws IOException{
//创建文件源
File src =new File(srcPath);
//创建字节数组目的地
byte[] dest =null; //选择流
//文件输入流
InputStream is =new BufferedInputStream(new FileInputStream(src));
//字节数组输出流 不能使用多态
ByteArrayOutputStream bos =new ByteArrayOutputStream(); //操作 不断读取文件 写出到字节数组流中
byte[] flush =new byte[1024];
int len =0;
while(-1!=(len =is.read(flush))){
//写出到字节数组流中
bos.write(flush, 0, len);
}
bos.flush(); //获取数据
dest =bos.toByteArray(); bos.close();
is.close();
return dest;
} }
二、数据流【处理流】
1.DataInputStream
DataInputStream 是数据输入流。它继承于FilterInputStream。
DataInputStream 是用来装饰其它输入流,它“允许应用程序以与机器无关方式从底层输入流中读取基本 Java 数据类型”。应用程序可以使用DataOutputStream(数据输出流)写入由DataInputStream(数据输入流)读取的数据。[一句话,是给机器看的]
2.DataOutputStream
DataOutputStream 是数据输出流。它继承于FilterOutputStream。
DataOutputStream 是用来装饰其它输出流,将DataOutputStream和DataInputStream输入流配合使用,“允许应用程序以与机器无关方式从底层输入流中读写基本 Java 数据类型”。
重点:
样例操作如下: 有如下的订单数据
import java.io.DataOutputStream ;
import java.io.File ;
import java.io.FileOutputStream ;
public class DataOutputStreamDemo{
public static void main(String args[]) throws Exception{ // 所有异常抛出
DataOutputStream dos = null ; // 声明数据输出流对象
File f = new File("d:" + File.separator + "order.txt") ; // 文件的保存路径
dos = new DataOutputStream(new BufferedOutputStream(new FileOutputStream(f))) ; // 实例化数据输出流对象
String names[] = {"衬衣","手套","围巾"} ; // 商品名称
float prices[] = {98.3f,30.3f,50.5f} ; // 商品价格
int nums[] = {3,2,1} ; // 商品数量
for(int i=0;i<names.length;i++){ // 循环输出
dos.writeChars(names[i]) ; // 写入字符串
dos.writeChar('\t') ; // 写入分隔符
dos.writeFloat(prices[i]) ; // 写入价格
dos.writeChar('\t') ; // 写入分隔符
dos.writeInt(nums[i]) ; // 写入数量
dos.writeChar('\n') ; // 换行
}
dos.close() ; // 关闭输出流
}
};
使用DataOutputStream写入的数据要使用DataInputStream读取进来。前面说过,是给机器看的,人类看不懂.
import java.io.DataInputStream ;
import java.io.File ;
import java.io.FileInputStream ;
public class DataInputStreamDemo{
public static void main(String args[]) throws Exception{ // 所有异常抛出
DataInputStream dis = null ; // 声明数据输入流对象
File f = new File("d:" + File.separator + "order.txt") ; // 文件的保存路径
dis = new DataInputStream(new BufferedInputStream(new FileInputStream(f)) ); // 实例化数据输入流对象
String name = null ; // 接收名称
float price = 0.0f ; // 接收价格
int num = 0 ; // 接收数量
char temp[] = null ; // 接收商品名称
int len = 0 ; // 保存读取数据的个数
char c = 0 ; // '\u0000'
try{
while(true){
temp = new char[200] ; // 开辟空间
len = 0 ;
while((c=dis.readChar())!='\t'){ // 接收内容
temp[len] = c ;
len ++ ; // 读取长度加1
}
name = new String(temp,0,len) ; // 将字符数组变为String
price = dis.readFloat() ; // 读取价格
dis.readChar() ; // 读取\t
num = dis.readInt() ; // 读取int
dis.readChar() ; // 读取\n
System.out.printf("名称:%s;价格:%5.2f;数量:%d\n",name,price,num) ;
}
}catch(Exception e){}
dis.close() ;
}
};
5.2f 表示的是 总共的数字长度为5位,其中2位表示小数,3位表示整数。
下面我们再看一个例子,即回顾到我们开始说的,一般DataInputStream 和 DataOutputStream 这种处理流,和对应的节点流ByteArrayInputStream ByteArrayOutputStream 关联在一起使用,即我们说的将字节数组中内存中存放当做一个小文件对待,例子如下:
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException; /**
* 数据类型(基本+String)处理流
* 1、输入流 DataInputStream readXxx()
* 2、输出流 DataOutputStream writeXxx()
* 新增方法不能使用多态
*
* java.io.EOFException :没有读取到相关的内容
* @author Administrator
*
*/
public class DataDemo02 { /**
* @param args
*/
public static void main(String[] args) {
try {
byte[] data=write();
read(data);
System.out.println(data.length);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} }
/**
* 从字节数组读取数据+类型
* @throws IOException
*/
public static void read(byte[] src) throws IOException{
//选择流
DataInputStream dis =new DataInputStream(
new BufferedInputStream(
new ByteArrayInputStream(src)
)
); //操作 读取的顺序与写出一致 必须存在才能读取
double num1 =dis.readDouble();
long num2 =dis.readLong();
String str =dis.readUTF(); dis.close(); System.out.println(num1+"-->"+num2+"-->"+str); }
/**
* 数据+类型输出到字节数组中
* @throws IOException
*/
public static byte[] write() throws IOException{
//目标数组
byte[] dest =null;
double point =2.5;
long num=100L;
String str ="数据类型"; //选择流 ByteArrayOutputStream DataOutputStream
ByteArrayOutputStream bos =new ByteArrayOutputStream();
DataOutputStream dos =new DataOutputStream(
new BufferedOutputStream(
bos
)
);
//操作 写出的顺序 为读取准备
dos.writeDouble(point);
dos.writeLong(num);
dos.writeUTF(str);
dos.flush(); dest =bos.toByteArray(); //释放资源
dos.close(); return dest; } }
三、对象流【处理流】
因为前面的是针对于基本的数据类型的操作,那么针对对象,于是就有了对象流;ObjectInputStream 和 ObjectOutputStream 的作用是,对基本数据和对象进行序列化操作支持。
创建“文件输出流”对应的ObjectOutputStream对象,该ObjectOutputStream对象能提供对“基本数据或对象”的持久存储;当我们需要读取这些存储的“基本数据或对象”时,可以创建“文件输入流”对应的ObjectInputStream,进而读取出这些“基本数据或对象”。
注意: 只有支持 java.io.Serializable 或 java.io.Externalizable 接口的对象才能被ObjectInputStream/ObjectOutputStream所操作!
主要的作用是用于写入对象信息与读取对象信息。 对象信息一旦写到文件上那么对象的信息就可以做到持久化了
使用:
对象的输出流将指定的对象写入到文件的过程,就是将对象序列化的过程,对象的输入流将指定序列化好的文件读出来的过程,就是对象反序列化的过程。既然对象的输出流将对象写入到文件中称之为对象的序列化,那么可想而知对象所对应的class必须要实现Serializable接口。(查看源码可得知:Serializable接口没有任何的方法,只是作为一个标识接口存在)。
1、将User类的对象序列化
class User implements Serializable{//必须实现Serializable接口
String uid;
String pwd;
public User(String _uid,String _pwd){
this.uid = _uid;
this.pwd = _pwd;
}
@Override
public String toString() {
return "账号:"+this.uid+" 密码:"+this.pwd;
}
} public class Demo1 { public static void main(String[] args) throws IOException {
//假设将对象信息写入到obj.txt文件中,事先已经在硬盘中建立了一个obj.txt文件
File f = new File("F:\\obj.txt");
writeObjec(f);
System.out.println("OK");
} //定义方法把对象的信息写到硬盘上------>对象的序列化。
public static void writeObjec(File f) throws IOException{
FileOutputStream outputStream = new FileOutputStream(f);//创建文件字节输出流对象
ObjectOutputStream objectOutputStream = new ObjectOutputStream(outputStream);
objectOutputStream.writeObject(new User("酒香逢","123"));
//最后记得关闭资源,objectOutputStream.close()内部已经将outputStream对象资源释放了,所以只需要关闭objectOutputStream即可
objectOutputStream.close();
}
}
运行程序得到记事本中存入的信息:可见已经序列化到记事本中
2、将序列化到记事本的内容反序列化
public class Demo1 { public static void main(String[] args) throws IOException, ClassNotFoundException {
//假设将对象信息写入到obj.txt文件中,事先已经在硬盘中建立了一个obj.txt文件
File f = new File("F:\\obj.txt");
//writeObjec(f);
readObject(f);
System.out.println("OK");
} //定义方法把对象的信息写到硬盘上------>对象的序列化。
public static void writeObjec(File f) throws IOException{
FileOutputStream outputStream = new FileOutputStream(f);//创建文件字节输出流对象
ObjectOutputStream objectOutputStream = new ObjectOutputStream(outputStream);
objectOutputStream.writeObject(new User("酒香逢","123"));
//最后记得关闭资源,objectOutputStream.close()内部已经将outputStream对象资源释放了,所以只需要关闭objectOutputStream即可
objectOutputStream.close();
}
//把文件中的对象信息读取出来-------->对象的反序列化
public static void readObject(File f) throws IOException, ClassNotFoundException{
FileInputStream inputStream = new FileInputStream(f);//创建文件字节输出流对象
ObjectInputStream objectInputStream = new ObjectInputStream(inputStream);
User user = (User)objectInputStream.readObject();
System.out.println(user);
}
}
运行代码得到的结果:
账号:酒香逢 密码:123
OK
但是,如果这时候这个obj.txt是我们项目中一个文件,而项目到后期在原来User类的基础上添加成员变量String userName;
class User implements Serializable{//必须实现Serializable接口
String uid;
String pwd;
String userName="名字";//新添加的成员变量
public User(String _uid,String _pwd){
this.uid = _uid;
this.pwd = _pwd;
}
@Override
public String toString() {
return "账号:"+this.uid+" 密码:"+this.pwd;
}
}
这时候如果我们再反序列化,则会引发下面的异常:
Exception in thread "main" java.io.InvalidClassException: com.User; local class incompatible: stream classdesc serialVersionUID = 2161776237447595412, local class serialVersionUID = -3634244984882257127
at java.io.ObjectStreamClass.initNonProxy(ObjectStreamClass.java:604)
at java.io.ObjectInputStream.readNonProxyDesc(ObjectInputStream.java:1601)
at java.io.ObjectInputStream.readClassDesc(ObjectInputStream.java:1514)
at java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:1750)
at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1347)
at java.io.ObjectInputStream.readObject(ObjectInputStream.java:369)
。。。。。
异常信息解读:
serialVersionUID 是用于记录class文件的版本信息的,serialVersionUID这个数字是JVM(JAVA虚拟界)通过一个类的类名、成员、包名、工程名算出的一个数字。而这时候序列化文件中记录的serialVersionUID与项目中的不一致,即找不到对应的类来反序列化。
3、如果序列化与反序列化的时候可能会修改类的成员,那么最好一开始就给这个类指定一个serialVersionUID,如果一类已经指定的serialVersionUID,然后
在序列化与反序列化的时候,jvm都不会再自己算这个 class的serialVersionUID了。
去掉刚才添加的成员变量userName;,并且在User类中指定一个serialVersionUID
class User implements Serializable{//必须实现Serializable接口 private static final long serialVersionUID = 1L;
String uid;
String pwd;
//String userName="名字";//新添加的成员变量
public User(String _uid,String _pwd){
this.uid = _uid;
this.pwd = _pwd;
}
@Override
public String toString() {
return "账号:"+this.uid+" 密码:"+this.pwd;
}
}
重新序列化到obj.txt文件中,然后再类中再将userName添加回来(将上面User类中userName字段解注释),再一次执行反序列化操作,执行的结果跟之前反序列化的结果是一致的。可见这样解决后我们后期修改类也是可行的。
4、如果在User类中再添加成员变量,而这个变量为一个class ,如Address,那么Address类也必须要实现Serializable接口。
class Address implements Serializable{
String country;
String city;
} class User implements Serializable{//必须实现Serializable接口 private static final long serialVersionUID = 1L;
String uid;
String pwd;
String userName="名字";//新添加的成员变量
Address address;//成员变量为Address
public User(String _uid,String _pwd){
this.uid = _uid;
this.pwd = _pwd;
}
@Override
public String toString() {
return "账号:"+this.uid+" 密码:"+this.pwd;
}
}
5、最后再提一下关键字transient关键字,当你不想要某些字段序列化时候,可以用transient关键字修饰
class User implements Serializable{//必须实现Serializable接口 private static final long serialVersionUID = 1L;
String uid;
String pwd;
transient String userName="名字";//新添加的成员变量//添加关键字transient后,序列化时忽略
Address address;//成员变量为Address
public User(String _uid,String _pwd){
this.uid = _uid;
this.pwd = _pwd;
}
@Override
public String toString() {
return "账号:"+this.uid+" 密码:"+this.pwd;
}
}
上面我们演示的文件的操作,如果换成字节数组流也是一样的方式。最后总结下:
1. 如果对象需要被写出到文件上,那么对象所属的类必须要实现Serializable接口。 Serializable接口没有任何的方法,是一个标识接口而已。
2. 对象的反序列化创建对象的时候并不会调用到构造方法的、(这点文中没有说到,想要验证的同学在构造方法后面加一句System.out.println("构造方法执行吗?");,实际上构造方法是不执行的,自然这句话也没有输出了)
3. serialVersionUID 是用于记录class文件的版本信息的,serialVersionUID这个数字是通过一个类的类名、成员、包名、工程名算出的一个数字。
4. 使用ObjectInputStream反序列化的时候,ObjeectInputStream会先读取文件中的serialVersionUID,然后与本地的class文件的serialVersionUID
进行对比,如果这两个id不一致,反序列则失败。
5. 如果序列化与反序列化的时候可能会修改类的成员,那么最好一开始就给这个类指定一个serialVersionUID,如果一类已经指定的serialVersionUID,然后
在序列化与反序列化的时候,jvm都不会再自己算这个 class的serialVersionUID了。
6. 如果一个对象某个数据不想被序列化到硬盘上,可以使用关键字transient修饰。
7. 如果一个类维护了另外一个类的引用,则另外一个类也需要实现Serializable接口。
四、打印流【处理流】
PrintStream 用于向文本输出流打印对象的格式化表示形式。它实现在PrintStream 中的所有 print 方法。它不包含用于写入原始字节的方法,对于这些字节,程序应该使用未编码的字节流进行写入。
在理解PrintStream如何使用之前,先了解一下System类中三个字段:
往控制台输出时 ,使用System.out.println();
其中System.out这个字段返回的就是打印流,PrintStream
PrintStream ps=System.out; ps.print("hello"); 就等同于 System.out.println("hello");
err和out其实是一样的,只不过在控制台输出时,err输出内容是红色的
Scanner也是一个处理流,创建一个Scanner对象使用到的就是in字段
Scanner console=new Scanner(System.in);
Scanner类其实就是一个输入流,那么我们可以从控制台输入,怎样从文件中输入呢?
InputStream is=System.in;
File file=new File("F:/Picture/test/test2.txt");
is=new BufferedInputStream(new FileInputStream(file));
Scanner sc=new Scanner(is);
System.out.println(sc.nextLine());
从上面也可以看出Scanner 其实就一个处理流,用于增强节点流。
使用打印流输出内容到文件中,也是很容易的
这是PrintStream的构造方法
File file=new File("F:/Picture/test/test.txt");
PrintStream ps=new PrintStream(new BufferedOutputStream(new FileOutputStream(file)));
ps.append("hellohahaha");
ps.close();
最后总结一句话:对于标准的输入和输出,JDK 中封装好了比较好的操作类,输入的Scanner 输出PrintStream
最后一个小问题:如何将system.out 的输出不是输出到控制台,而是记录到文件中呢?即记录日志利用打印流来实现的。
文本信息中的内容为String类型。而像文件中写入数据,我们经常用到的还有文件输出流对象FileOutputStream.
1 File file = new File("F:\\a.txt");
2 FileOutputStream outputStream = new FileOutputStream(file,true);//第二个参数为追加文本
3 outputStream.write(97);
上面的代码执行完之后,a.txt中的内容存的是a,因为write方法接收的为byte类型的数据,97对应的ASCII码为a。
假设我就想将97写入到文件中呢?那么得将第三行代码改为
outputStream.write("97".getBytes());//先将97作为字符串再转换为byte数组
而PrintStream得出现,是的我们写数据入文件变得十分方便,你传入的是什么,就会给你写入什么数据。原因是他内部帮我们转换了
File file = new File("F:\\a.txt");
PrintStream printStream = new PrintStream(file);
printStream.println(97);
printStream.println('a');
printStream.println("hello world");
printStream.println(true);
printStream.println(3.14);
printStream.println(new Student("酒香逢"));
上面这段代码得到的结果为:
可见不管什么数据类型,都会转换为字符串,甚至是对象也不例外。
这里再说一下学习java时少不了用到的一句代码:System.out.println();代码中的out,为System类中的一个PrintStream对象,称之为标准输出流对象。标准输出流对象会将数据打印到控制台上。查阅API可知有如下方法,
static void setOut(PrintStream out) //重新分配“标准”输出流。
可以重新指定输出流对象,即将System.out.println();的输出内容打印到我们想打印到的地方。
1 File file = new File("F:\\a.txt");
2 PrintStream printStream = new PrintStream(file);
3 System.setOut(printStream);
4 System.out.println("打印到F:\\a.txt中");
这时候内容回写入到文件a.txt中去,而不是打印在控制台中。
最后回归本文重点,日志信息的保存。
假设有代码:
1 try{
2 int n = 5/0;
3 }catch(Exception e){
4 e.printStackTrace();
5 }
执行结果会抛出我们想要的错误日志信息。
java.lang.ArithmeticException: / by zero
at log.DemoLog.main(DemoLog.java:26)
这时候想将日志信息保存起来怎么办呢?
看到Exception类中的这3个重载方法,我们不难得知,只要给他指定一个打印输出流对象当中,即可将日志信息保存到我们想要的地方。
File file = new File("F:\\a.log");
PrintStream printStream = new PrintStream(file);
try{
int n = 5/0;//除数为零异常
}catch(Exception e){
e.printStackTrace(printStream);
}
上面这段代码执行重复执行多次,
但是记录的日志信息永远只会记录一条。这明显不是我们想得到的,日志信息,总不能只记录一条吧?那么它存在又有什么用?
其实,追加文本信息的决定者不是e.printStackTrace(printStream);方法,关键点在于流对象,
可见打印流对象是存在一个OutputStream接口作为参数的传入对象。既然是接口,那么就无法new出OutputStream的对象了,可以用他的子类FileOutputStream对象作为参数传入。并且,FileOutputStream流是可以追加的,
new FileOutputStream(file,true);//第二个参数为追加文本
此时将其作为参数传入,PrintStream流自然也就可以追加内容了。
File file = new File("F:\\a.log");
PrintStream printStream = new PrintStream(new FileOutputStream(file,true),true);
try{
int n = 5/0;//除数为零异常
}catch(Exception e){
e.printStackTrace(printStream);
}
将代码执行3次后:
可以看到日志信息是保存有3条的,日志信息记录保存目的达成!
最后如果我们如果想回来呢?
改为控制台输出需要借助FileDescript这个类,之后的输出就会显示在控制台了
System.setOut(new PrintStream(new FileOutputStream(FileDescriptor.out),true));
备注:部分资料来源于网络,表示感谢.
JAVA IO分析二:字节数组流、基本数据&对象类型的数据流、打印流的更多相关文章
- Java IO(二)File
Java IO(二)File 一.概述 在 Java 中,File 类是 java.io 包中唯一代表磁盘文件本身的对象,也就是说,如果希望在程序中操作文件和目录,则都可以通过 File 类来完成.F ...
- Java将文件转为字节数组
Java将文件转为字节数组 关键字:文件,文件流,字节流,字节数组,二进制 摘要:最近工作中碰到的需求是,利用http传输二进制数据到服务器对应接口,需要传输userId, file(加密后)等一系列 ...
- java对获取的字节数组进行处理
java对获取的字节数组bytes[]进行处理: 第一种,直接将该字节数组转换为字符串(部分): String content = ,); //从位置0开始获取2个字节 这样,对获取的数据报进行全部转 ...
- Java中的二维数组
Java 中的二维数组 所谓二维数组,可以简单的理解为是一种"特殊"的一维数组,它的每个数组空间中保存的是一个一维数组. 那么如何使用二维数组呢,步骤如下: 1. 声明数组并分配空 ...
- java学习之二维数组
java当中的二维数组,存储一组比较特殊的对象.他存储一个数组,同时存储的数组当中又存储着元素. java二维数组的声明方式一: class Arr2Demo { public static void ...
- JAVA生成一个二维数组,使中间元素不与相邻的9个元素相等,并限制每一个元素的个数
JAVA生成一个二维数组,使中间元素不与相邻的9个元素相等,并限制每一个元素的个数 示例如下 至少需要九个元素:"A","B","C",&q ...
- Java IO(二十) PrintStream 和 DataOutputStream 异同
Java IO(二十) PrintStream 和 DataOutputStream 异同 一.相同点 都是继承与FileOutputStream,用于包装其它输出流. 二.不同点 (一).Print ...
- Java基础教程——二维数组
二维数组 Java里的二维数组其实是数组的数组,即每个数组元素都是一个数组. 每个数组的长度不要求一致,但最好一致. // 同样有两种风格的定义方法 int[][] _arr21_推荐 = { { 1 ...
- Java一维与二维数组的拷贝与排序
Java一维与二维数组的拷贝与排序 目录 Java一维与二维数组的拷贝与排序 Arrays.sort() 一维数组升序排序 二维数组按行升序排序 二维数组按列升序排序 Java中的数组 Java中数组 ...
随机推荐
- Flex 基础语法(一)
任何一个容器都可以指定为Flex布局. .box{ display: flex; } 行内元素也可以使用Flex布局. .box{ display: inline-flex; } Webkit内核的浏 ...
- Ajax 跨域 异步 CORS
HTTP access control (CORS) 核心在于使用定制(添加新的header)HTTP header让浏览器和服务器有更多的相互了解,从而决定一个请求或者响应成功还是失败 对于一个 ...
- airodump-ng使用手册
选项: -i, --ivs 捕捉WEP加密的包,忽略出IV之外的所有的包,保存为.ivs格式 airodump-ng wls35u1 -i -w captures airodump-ng wls35u ...
- HttpClient发送Post请求,get请求
// 创建默认的httpclient实例 CloseableHttpClient httpclient = getHttpClient(); CloseableHttpResponse respons ...
- Boost LRU-Cache使用方法简介
缓存是提高系统运行效率的常用组件,可以将"有效的"业务数据直接返回用户,避免繁琐的计算过程.除了Redis.MemCache等常用缓存系统,应用程序内部也可以根据需要设置一定容量的 ...
- Python中的三种数据结构
Python中,有3种内建的数据结构:列表.元组和字典.1.列表 list是处理一组有序项目的数据结构,即你可以在一个列表中存储一个序列的项目.列表中的项目.列表中的项目应该包括在方括号中,这 ...
- Docker Register安装与基本认证
准备 基本事项 Docker环境 登录授权方式 镜像存放地址 HTTPS外网访问 启动Docker Registry 1. 基本事项 本篇涉及到的数据文件都放在/data目录下, 其中会有三个子目录 ...
- OpenTSDB - 分布式可扩展的监控系统
OpenTSDB - A Distributed, Scalable Monitoring System http://opentsdb.net/getting-started.html http:/ ...
- cgg之类型转换
3.类型转换 3.1算术类型转换 编译器默认的隐式转换等级: long double >double >float >long long >long >int >c ...
- Xshell 的安装教程
Xshell就是一个远程控制RHEL的软件:其他的还有很多,用什么都无所谓(根据公司情况). 下面我们来安装下这个工具: 双击exe 点下一步: 选 免费的 然后下一步:(免费的功能足够用了) 点接受 ...