前面我们学习的了多线程，今天开始要学习IO流了，java中IO流的知识非常重要。但是其实并不难，因为他们都有固定的套路。
一、流的概念
流是个抽象的概念,是对输入输出设备的抽象,Java程序中,对于数据的输入/输出操作都是以"流"的方式进行。设备可以是文件,网络,内存等
流具有方向性,至于是输入流还是输出流则是一个相对的概念,一般以程序为参考,如果数据的流向是程序至设备,我们成为输出流,如果数据的流向是设备至程序称为输入流。
数据以二进制的形式在程序与设备之间流动传输,就想水在管道里流动一样,所以就把这种数据传输的方式称之为输入流输出流二、流的分类
1)按照流的方向分为输入流和输出流
2)按照处理数据的单位不同分为字节流和字符流
字节流读取的最小单位是一个字节(1byte=8bit),而字符流一次可以读取一个字符(1char = 2byte = 16bit)
3)按照功能的不同分为节点流和处理流
节点流是可以"直接"从一个数据源中读写数据的流。
处理流也可以称为功能流或者包装流,它是可以对节点流进行封装的一种流,封装后可以增加节点流的功能。
例如:FileInputStream是一个节点流,可以直接从文件读取数据,而BufferedInputStream可以包装 FileInputStream,使得其有缓冲数据的功能。
4)除了以上三种分类外,还有其他的一些类型的:对象流、缓冲流、压缩流、文件流等等,其实这些都是节点流或者处理流的子分类。当然还可以分出来其他的流类型,如果有这样需要的话。
5)不管流的分类是多么的丰富和复杂，其根源来自于四个基本的父类
字节输入流:InputStream
字节输出流:OutputStream
字符输入流:Reader 这四个父类都是抽象类
字符输出流:Writer
二、字节流中常用节点流
注:java中常用的io流都在java.io包中
1.1、InputStream
1）方法介绍
public abstract int read();
从输入流中读取数据的下一个字节；如果到达流的末尾则返回 -1
public int read(byte[] b){..}
把读到的字节存到字节数组b中,并返回本次读到了多少个字节
public int read(byte[] b,int off,int len){..}
把读到的字节存到字节数组b中,同时指定开始存的位置以及最大字节数,并返回本次读到了多少个字节
public int available(){..}
返回此输入流下一个方法调用可以不受阻塞地从此输入流读取(或跳过)的估计字节数
public long skip(long n){..}
跳过此输入流中数据的 n 个字节
public void close(){..}
关闭此输入流并释放与该流关联的所有系统资源
public boolean markSupported(){..}
测试此输入流是否支持 mark 和 reset 方法
public void mark(int readlimit){..}
在此输入流中标记当前的位置
public void reset(){..}
将此流重新定位到最后一次对此输入流调用mark方法时的位置
1.2、OutputStream
1）方法介绍
public abstract void write(int b);
将指定的字节写入此输出流
public void write(byte[] b){..}
将字节数组b中的所有字节写入此输出流
public void write(byte[] b,int off,int len){..}
将字节数组b中的字节写入此输出流,指定开始位置及最大字节数
public void flush(){..}
刷新此输出流并强制写出所有缓冲的输出字节
public void close(){..}
关闭此输出流并释放与此流有关的所有系统资源
注意：InputStream的子类和OutputStream的子类几乎都是成对出现的,一个负责读数据的工作,一个负责写数据的工作
1.3、System.out和System.in
标准输入流会默认从控制台读取数据
标准输出流会默认把数据输出到控制台
System.out.println(System.in.getClass());
System.out.println(System.out.getClass());
输出结果为:
class java.io.BufferedInputStream
class java.io.PrintStream
System类的部分源码:
public final class System{
//标准输入流
public final static InputStream in = null;
//标准输出流。
public final static PrintStream out = null;
//标准错误输出流
public final static PrintStream err = null;
public static void setIn(InputStream in){..}
public static void setOut(PrintStream out){..}
public static void setErr(PrintStream err){..}
}
在使用流的时候一定要注意它的步骤：
首先想清楚：1.是读是写 2.是字节是字符 3.从哪里读/写（这个非常的重要）比如在这个System.out和System.in中，in从控制台读取数据，out是把数据输出控制台
举例：
对输入流的操作
import java.io.IOException;
import java.io.InputStream;
import java.util.Arrays; public class InAndOutTest { /*
* 1.是读还是写
* 2.是字节还是字符
* 3.从哪读/写
*/
public static void main(String[] args) { //1.声明流
InputStream in = null; try {
//2.创建流
in = System.in; //3.操作流 /*int data = in.read();
System.out.println(data); data = in.read();
System.out.println(data); data = in.read();
System.out.println(data); data = in.read();
System.out.println(data);*/ //h e l l o
//104, 101, 108, 108, 111
//104, 101, 108, 108, 111, 119, 111, 114, 108, 100
/*byte[] b = new byte[10];
int len = in.read(b);
System.out.println(len);
System.out.println(Arrays.toString(b));*/
//输入hello
//结果：7
// [104, 101, 108, 108, 111, 13, 10, 0, 0, 0] /*int data = -1;
while((data=in.read())!=-1){
System.out.println(data);
}*/ /*byte[] b = new byte[10];
int len = -1;
while((len=in.read(b))!=-1){
System.out.println(len+":"+Arrays.toString(b));
}*/ /*byte[] b = new byte[10];
int len = -1; len = in.read(b, 4, 5);
System.out.println(len+":"+Arrays.toString(b));*/
//输入：helloworld
//输出：5:[0, 0, 0, 0, 104, 101, 108, 108, 111, 0] //System.out.println(in.available()); // long len = in.skip(10);
// System.out.println(len); //h e l l o w o r l d
//104, 101, 108, 108, 111
/* System.out.println(in.markSupported());
int data = -1;
while((data=in.read())!=-1){
if(data==101){
in.mark(10);
}
else if(data==111){
in.reset();
}
System.out.println(data);
Thread.sleep(1000);
}*/ } catch (Exception e) {
e.printStackTrace();
}finally {
//4.关闭流
try {
if(in!=null)in.close();
} catch (IOException e) {
e.printStackTrace();
}
} } }
InAndOutTest
对输出流的操作
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.text.SimpleDateFormat;
import java.util.Date; public class InAndOutTest2 { /*
* 1.是读还是写
* 2.是字节还是字符
* 3.从哪读/写
*/
public static void main(String[] args) { //1.声明流
InputStream in = null;
OutputStream out = null; try {
//2.创建流
in = System.in;
out = System.out; //3.操作流
// System.out.println(out.getClass());
// out.write(97);
// out.flush(); //h e l l o
//104, 101, 108, 108, 111
// byte[] b = {104,101,108,108,111};
// byte[] b = "hello".getBytes();
/*
byte[] b1 = "你好".getBytes();
System.out.println(Arrays.toString(b1)); byte[] b2 = "你好".getBytes("UTF-8");
System.out.println(Arrays.toString(b2)); byte[] b3 = "你好".getBytes("GBK");
System.out.println(Arrays.toString(b3)); byte[] b4 = "你好".getBytes("unicode");
System.out.println(Arrays.toString(b4)); out.write(b1);
out.write(10);
out.write(b2);
out.write(10);
out.write(b3);
out.write(10);
out.write(b4);
out.flush();
*/ /*
byte[] b = "helloworld".getBytes();
out.write(b, 3, 5);
out.flush();
*/ /*
int data = -1;
while((data=in.read())!=-1){
out.write(data);
out.flush();
}*/ byte[] b = new byte[];
int len = -; //[98, 121, 101]
// System.out.println(Arrays.toString("bye".getBytes()));
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
while((len=in.read(b))!=-){
if(len==){
String str = new String(b,,);
if("bye".equals(str)){
out.write("欢迎下次再来".getBytes());
out.flush();
break;
}
}
else if(len==){
String str = new String(b,,);
if("time".equals(str)){
out.write(sdf.format(new Date()).getBytes());
out.flush();
continue;
}
}
out.write(b,,len);
out.flush();
} } catch (Exception e) {
e.printStackTrace();
}finally {
//4.关闭流
try {
if(in!=null)in.close();
} catch (IOException e) {
e.printStackTrace();
}
try {
if(out!=null)in.close();
} catch (IOException e) {
e.printStackTrace();
}
} } }
InAndOutTest2
1.4、ByteArrayInputStream和ByteArrayOutputStream
这个节点流非常的重要：
ByteArrayInputStream可以从数组中读取字节
ByteArrayOutputStream可以把字节写到对象中的缓冲区里面,其实就是一个字节数组
相关的方法查看API
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Arrays; public class ByteArrayInputStreamTest {
public static void main(String[] args) { InputStream in = null;
OutputStream out = null; try {
byte[] buf = "helloworld".getBytes();
in = new ByteArrayInputStream(buf);
out = new ByteArrayOutputStream(); // System.out.println(Integer.toBinaryString(1000)); /*int data = -1;
while((data=in.read())!=-1){
out.write(data);
out.flush();
}*/ byte[] b = new byte[];
int len = in.read(b); out.write(b, , len);
out.flush(); byte[] dataBuf = ((ByteArrayOutputStream)out).toByteArray();
System.out.println(Arrays.toString(dataBuf)); } catch (Exception e) {
e.printStackTrace();
}finally {
try {
if(in!=null)in.close();
} catch (IOException e) {
e.printStackTrace();
}
try {
if(out!=null)out.close();
} catch (IOException e) {
e.printStackTrace();
}
} }
}
ByteArrayInputStreamTest
1.5、FileInputStream和FileOutputStream
FileInputStream可以读取文件中的字节
查看api：
long skip(long n) 从输入流中国跳过并丢弃n个字节的数据
int available() 返回下一次对此输入流调用的方法可以不受阻塞地从此输入流读取（或跳过）的估计剩余字节数。
FileOutputStream可以向文件中写进去字节
例子：
从文件中读写到控制台中
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream; public class FileInputStreamTest {
public static void main(String[] args) { InputStream in = null;
OutputStream out = null; try { String filePath = "src/com/zyh/chap11/b.txt";
in = new FileInputStream(filePath);
out = System.out; System.out.println("in.available() = "+in.available());
byte[] b = new byte[];
int len = -; while((len=in.read(b))!=-){
out.write(b, , len);
}
out.flush(); } catch (Exception e) {
e.printStackTrace();
}finally {
try {
if(in!=null)in.close();
} catch (IOException e) {
e.printStackTrace();
}
try {
if(out!=null)out.close();
} catch (IOException e) {
e.printStackTrace();
}
} }
}
FileInputStreamTest
自己建立一个字节数组写到文件中去
import java.io.FileOutputStream;
import java.io.OutputStream; public class FileOutputStreamTest { public static void main(String[] args) {
OutputStream out = null; try {
String file = "src/com/zyh/ioday02/b.txt";
out = new FileOutputStream(file,true); byte[] b = "hello".getBytes();
// out.write(b);
out.write(b, , b.length);
out.flush(); } catch (Exception e) {
e.printStackTrace();
}finally{
try {
if (out != null)
out.close();
} catch (Exception e) {
e.printStackTrace();
}
}
} }
FileOutputStreamTest
从控制台读写到文件中去
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream; public class FileOutputStreamTest2 { public static void main(String[] args) {
InputStream in = null;
OutputStream out = null; try {
in =System.in;
String file = "src/com/zyh/ioday02/b.txt";
out = new FileOutputStream(file); byte[] buf = new byte[];
int len = -;
while((len=in.read(buf))!=-){
out.write(buf, , len);
}
out.flush(); } catch (Exception e) {
e.printStackTrace();
}finally{
try {
if (in != null)
in.close();
} catch (Exception e) {
e.printStackTrace();
}
try {
if (out != null)
out.close();
} catch (Exception e) {
e.printStackTrace();
}
}
} }
FileOutputStreamTest2
读取一个文件内容写到另一个文件中
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream; public class FileInputStreamAndFileOutputStream { public static void main(String[] args) {
InputStream in = null;
OutputStream out = null; try {
String filePath1 = "src/com/zyh/ioday02/b.txt";
String filePath2 = "src/com/zyh/ioday02/c.txt"; in = new FileInputStream(filePath1);
out = new FileOutputStream(filePath2); // in.skip(in.available()/2);
byte[] buf = new byte[];
int len = -;
while((len=in.read(buf))!=-){
out.write(buf,,len);
}
out.flush(); } catch (Exception e) {
e.printStackTrace();
}finally{
if(in!=null)
try {
in.close();
} catch (IOException e) {
e.printStackTrace();
}
if(out!=null)
try {
out.close();
} catch (IOException e) {
e.printStackTrace();
}
} } }
FileInputStreamAndFileOutputStream
1.6、PipedInputStream和PipedOutputStream
PipedInputStream管道字节输入流
PipedOutputStream管道字节输出流
注:使用时需要把俩个管道进行对接
在写关于IO流的用法时，一定要知道：
是字节流和还是字符
是输入还是输出
是读还是写（在下面这个例子中，首先PipedOutputStream从一个for循环中得到字节，然后PipedInputStream读到字节，通过System.out输出）
import java.io.IOException;
import java.io.PipedInputStream;
import java.io.PipedOutputStream; public class PipedInputAndOutputStreamTest {
public static void main(String[] args) { try {
PipedInputStream in = new PipedInputStream();
PipedOutputStream out = new PipedOutputStream(in); Thread t1 = new PipedReadThread(in);
Thread t2 = new PipedWriteThread(out); t1.start();
t2.start(); } catch (IOException e) {
e.printStackTrace();
} }
} //负责读取数据的线程
class PipedReadThread extends Thread{
private PipedInputStream in; public PipedReadThread(PipedInputStream in) {
this.in = in;
} @Override
public void run() {
try {
int data = -;
while((data=in.read())!=-){
System.out.write(data);
System.out.flush();
}
System.out.println("data = "+data);
} catch (IOException e) {
e.printStackTrace();
}finally {
try {
if(in!=null)in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
} //负责写入数据的线程
class PipedWriteThread extends Thread{
private PipedOutputStream out; public PipedWriteThread(PipedOutputStream out) {
this.out = out;
} @Override
public void run() {
try {
for(int i=;i<=;i++){
out.write(i);
out.flush();
Thread.sleep();
}
} catch (Exception e) {
e.printStackTrace();
}finally {
try {
if(out!=null)out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
PipedInputAndOutputStreamTest
1.7、ObjectInputStream和ObjectOutputStream（对象流）
1）序列化和反序列化
Java中的序列化是指把Java对象转换为字节序列的过程
对象---序列化--->01010101
Java中的反序列化是指把字节序列恢复为Java对象的过程
01010101---反序列化--->对象
2）实现序列化和反序列化
使用对象流即可实现对象的序列化和反序列化
2.1）ObjectOutputStream类中的方法可以完成对象的序列化:（注:这俩个对象流都属于字节流）
public final void writeObject(Object obj){..}
构造方法：
protected |
ObjectOutputStream() 为完全重新实现 ObjectOutputStream 的子类提供一种方法，让它不必分配仅由 ObjectOutputStream 的实现使用的私有数据。 |
|
ObjectOutputStream(OutputStream out)创建写入指定 OutputStream 的 ObjectOutputStream。 |
实例:
首先编写了一个工具类：User
import java.io.Serializable;
public class User implements Serializable{
private static final long serialVersionUID = 1L;
private long id;
private String name;
private int age;
private transient double salary;
public User() {}
public User(long id, String name, int age) {
this.id = id;
this.name = name;
this.age = age;
}
public long getId() {
return id;
}
public void setId(long id) {
this.id = id;
}
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;
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
@Override
public String toString() {
return "User [id=" + id + ", name=" + name + ", age=" + age + ", salary=" + salary + "]";
}
}
User
将序列化写到文件当中
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream; public class ObjectOutputStreamTest {
public static void main(String[] args) { ObjectOutputStream out = null;
// ByteArrayOutputStream bos = null;
FileOutputStream fos = null;
try {
String filePath = "src/com/zyh/chap11/obj.txt";
fos = new FileOutputStream(filePath);
out = new ObjectOutputStream(fos); User u = new User(1L,"tom",);
u.setSalary();
//序列化
out.writeObject(u);
out.flush(); // byte[] array = bos.toByteArray();
// System.out.println(Arrays.toString(array)); } catch (Exception e) {
e.printStackTrace();
}finally {
try {
if(fos!=null)fos.close();
} catch (IOException e) {
e.printStackTrace();
}
try {
if(out!=null)out.close();
} catch (IOException e) {
e.printStackTrace();
}
} }
}
ObjectOutputStreamTest
我们查看文件会发现乱码，以为我们序列化之后是字节，当我们把它写到文件中的时候会通过设置的编码解析成字符，所以出现乱码。当然这个不是给我们看的，接下来我们要去做反序列化把它转回对象。
2.2） ObjectInputStream类中的方法可以完成对象的反序列化:
public final Object readObject(){..}
从刚才我们把序列化写到的那个文件中读，进行反序列化
import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream; public class ObjectInputStreamTest {
public static void main(String[] args) { ObjectInputStream in = null;
FileInputStream fis = null; try {
String filePath = "src/com/zyh/chap11/obj.txt";
fis = new FileInputStream(filePath);
in = new ObjectInputStream(fis); //反序列化
User obj = (User)in.readObject();
System.out.println(obj); } catch (Exception e) {
e.printStackTrace();
}finally {
try {
if(fis!=null)fis.close();
} catch (IOException e) {
e.printStackTrace();
}
try {
if(in!=null)in.close();
} catch (IOException e) {
e.printStackTrace();
}
} }
}
ObjectInputStreamTest
注意：在我们进行了序列化之后，如果给User类新增一个Salary的属性，然后进行反序列化的时候，会发现报错了（在没有添加serialVersionUID的时候）。会出现两个序列号（没有写序列号系统会有一个默认的）。
当我们设置了serialVersionUID的时候，并且给Salary进行set属性，会发现输出了User对象。
三、字节流常用的处理流
也可以称为功能流或者包装流,因为它是对节点流进行包装的一种流,包装后可以增加节点流的功能。但是处理流本身并不能直接读写数据
3.1、BufferedInputStream和BufferedOutputStream
作用：可以给字节流中的节点流提供代码缓冲区的输入/输出流
我们使用使用BufferedInputStream来读取的时候，明显比FileInputStream本身来读取的时候快很多。
import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException; public class BufferedInputStreamTest { @SuppressWarnings("unused")
public static void main(String[] args) { BufferedInputStream in = null;
FileInputStream fis = null; try {
String filePath = "src/com/zyh/chap11/note.txt";
fis = new FileInputStream(filePath); in = new BufferedInputStream(fis); byte[] b = new byte[];
int len = -;
long start = System.currentTimeMillis();
while((len=in.read(b))!=-){ }
long end = System.currentTimeMillis();
System.out.println(end-start+"毫秒");
} catch (Exception e) {
e.printStackTrace();
}finally {
try {
if(fis!=null)fis.close();
} catch (IOException e) {
e.printStackTrace();
}
try {
if(in!=null)in.close();
} catch (IOException e) {
e.printStackTrace();
}
} } }
BufferedInputStreamTest
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException; public class BufferedOutputStreamTest {
public static void main(String[] args) { BufferedOutputStream out = null;
FileOutputStream fos = null; try {
String filePath = "src/com/zyh/chap11/d.txt";
fos = new FileOutputStream(filePath);
out = new BufferedOutputStream(fos); byte[] b = "test".getBytes(); out.write(b);
out.flush(); } catch (Exception e) {
e.printStackTrace();
}finally {
try {
if(fos!=null)fos.close();
} catch (IOException e) {
e.printStackTrace();
}
try {
if(out!=null)out.close();
} catch (IOException e) {
e.printStackTrace();
}
} }
}
BufferedOutputStreamTes
3.2、DataInputStream和DataOutputStream
可以给字节流中的节点流提供输入/输出java中不同类型的数据
首先我们先来看一下DataOutputStream
构造函数：
DataOutputStream(OutputStream out)
创建一个新的数据输出流，将数据写入指定基础输出流。
import java.io.DataOutputStream;
import java.io.FileOutputStream;
import java.io.IOException; public class DataOutputStreamTest {
public static void main(String[] args) { DataOutputStream out = null;
FileOutputStream fos = null; try {
String filePath = "src/com/zyh/chap11/d.txt";
fos = new FileOutputStream(filePath);
out = new DataOutputStream(fos); out.writeInt();
out.writeLong(1000L);
out.writeBoolean(false);
out.writeDouble(10.5);
out.writeFloat(10.5f);
out.writeUTF("你好"); out.flush(); } catch (Exception e) {
e.printStackTrace();
}finally {
try {
if(fos!=null)fos.close();
} catch (IOException e) {
e.printStackTrace();
}
try {
if(out!=null)out.close();
} catch (IOException e) {
e.printStackTrace();
}
} }
}
DataOutputStreamTest
查看文件我们发现乱码了，这是因为我们本来就是就只字节写到文件中去的，所以经过文件的编码解析之后就会乱码。只有其中的“你好”不会，因为我们用UTF-8编写，而文件也是通过UTF-8解析的。通过
DataInputStream来查看。
import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException; public class DataInputStreamTest {
public static void main(String[] args) { DataInputStream in = null;
FileInputStream fis = null; try {
String filePath = "src/com/zyh/chap11/d.txt";
fis = new FileInputStream(filePath);
in = new DataInputStream(fis); System.out.println(in.readInt());
System.out.println(in.readLong());
System.out.println(in.readBoolean());
System.out.println(in.readDouble());
System.out.println(in.readFloat());
System.out.println(in.readUTF()); // System.out.println(in.read()); } catch (Exception e) {
e.printStackTrace();
}finally {
try {
if(fis!=null)fis.close();
} catch (IOException e) {
e.printStackTrace();
}
try {
if(in!=null)in.close();
} catch (IOException e) {
e.printStackTrace();
}
} }
}
DataInputStreamTest
注意：我们要什么写的就要对应着怎么读。所以在开发中我们一般把同一个文件的东西写进去，读出来的时候就很方便了。
同时我们包装流可以包装任何的节点流，比如说ByteArrayOutputStream
import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.util.Arrays; public class DataOutputStreamTest2 {
public static void main(String[] args) { DataOutputStream out = null;
ByteArrayOutputStream bos = null; try {
bos = new ByteArrayOutputStream();
out = new DataOutputStream(bos); // out.writeLong(1000L);
// out.writeInt(1000);
// out.writeBoolean(false);
// out.writeChar('中');
out.writeFloat(10.5f);
out.flush(); byte[] b = bos.toByteArray();
System.out.println(Arrays.toString(b)); } catch (Exception e) {
e.printStackTrace();
}finally {
try {
if(bos!=null)bos.close();
} catch (IOException e) {
e.printStackTrace();
}
try {
if(out!=null)out.close();
} catch (IOException e) {
e.printStackTrace();
}
} }
}
DataOutputStreamTest2
3.3、PrintStream
PrintStream为其他输出流添加了功能，使它们能够方便地打印各种数据值表示形式
常用的System.out中的out变量就是PrintStream类型的
它是在OutputStream下面的，在InputStream中没有和它对应的流，所以在IO中大多数流都是成对出现的。也有极少数单个的。
举例：
我们使用System.out.println()都是往控制台输出的，我们知道System.out中out是一个PrintStream类型的。所以重写里面的println()方法来把它写到文件中.
import java.io.FileOutputStream;
import java.io.PrintStream;
import java.text.SimpleDateFormat;
import java.util.Date; public class PrintStreamTest {
static{
try {
String filePath = "src/com/zyh/chap11/c.txt";
PrintStream out = new PrintStream(new FileOutputStream(filePath,true)){
private SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
@Override
public void println(String x) {
super.println(sf.format(new Date())+" mylog: "+x);
}
};
System.setOut(out);
} catch (Exception e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
System.out.println("hello world");
System.out.println("hello world");
System.out.println("hello world");
System.out.println("hello world");
System.out.println("hello world");
System.out.println("hello world");
System.out.println("hello world");
}
}
PrintStreamTest
觉得不错的点个“推荐”哦！