JavaSE（十二）之IO流的字节流（一）
前面我们学习的了多线程，今天开始要学习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
觉得不错的点个“推荐”哦！
JavaSE（十二）之IO流的字节流（一）的更多相关文章
- Java学习之路(十二)：IO流<二>
字符流 字符流是可以直接读写字符的IO流 使用字符流从文件中读取字符的时候,需要先读取到字节数据,让后在转换为字符 使用字符流向文件中写入字符时,需要把字符转为字节在写入文件 Reader和Write ...
- Java学习之路(十二)：IO流
IO流的概述及其分类 IO流用来处理设备之间的数据传输,Java对数据的操作是通过流的方式 Java用于操作流的类都在IO包中 流按流向分为两种:输入流(读写数据) 输出流(写数据) 流按操作 ...
- JavaEE基础（二十二）/IO流
1.IO流(序列流) 1.什么是序列流 序列流可以把多个字节输入流整合成一个, 从序列流中读取数据时, 将从被整合的第一个流开始读, 读完一个之后继续读第二个, 以此类推. 2.使用方式 整合两个: ...
- JAVA学习第五十二课 — IO流（六）File对象
File类 用来给文件或者目录封装成对象 方便对文件与目录的属性信息进行操作 File对象能够作为參数传递给流的构造函数 一.构造函数和分隔符 public static void FileDemo( ...
- Java学习之路(十二)：IO流<三>
复习:序列流 序列流可以把多个字节输入整合成一个,从序列流中读取到数据时,将从被整合的第一个流开始读取,读完这个后,然后开始读取第二个流,依次向后推. 详细见上一篇文章 ByteArrayOutput ...
- JavaSE学习笔记（14）---File类和IO流（字节流和字符流）
JavaSE学习笔记(14)---File类和IO流(字节流和字符流) File类 概述 java.io.File 类是文件和目录路径名的抽象表示,主要用于文件和目录的创建.查找和删除等操作. 构造方 ...
- Java IO（十二） 字符流 Writer 和 Reader
Java IO(十二) 字符流 Reader和 Writer 一.介绍 涉及到文件(如果是纯文本文件形式)操作时,Java除了提供 FIle(文件和目录路径名的抽象表示形式) 和 FileDescri ...
- java基础（十九）IO流（二）
这里有我之前上课总结的一些知识点以及代码大部分是老师讲的笔记 个人认为是非常好的,,也是比较经典的内容,真诚的希望这些对于那些想学习的人有所帮助! 由于代码是分模块的上传非常的不便.也比较多,讲的也是 ...
- Java基础（十二）IO输入输出
一.IO 概述 1.IO 概念 IO:I 代表 Input 输入:O 代表 Output 输出. Java 中 IO 是以流为基础进行输入输出,所有的数据被串行化(保存)写入输出流,或者从输入流读入. ...
- IO流（字节流，字符流）
一,概述 IO流(input output):用来处理设备之间的数据. Java对数据的操作是通过流的对象. Java用于操作流的对象都在IO包中. 流是一组有顺序的,有起点和终点的字节集合,是对数据 ...
随机推荐
- python 项目中的 requirements.txt
背景 java项目的话,包依赖一般都是maven管理,当然还有gradle,对于包的管理非常方便,maven的话只要在pom.xml中添加依赖包的maven坐标就可以了的,那python呢 ? 解决方 ...
- 【windows】常用快捷键
浏览器 ctrl shift del 清除网页缓存 文件系统 win+e 打开文件窗口 win+r 运行命令窗口 win+l 锁定桌面 win+m 最小化窗口 ctrl+shift +n 创建文件夹
- malloc/free 的使用要点
函数malloc的原型如下: void * malloc(size_t size); 用malloc申请一块长度为length的整数类型的内存,程序如下: int *p = (int *)mall ...
- openstack配置
参考林海峰老师的配置教程 http://blog.51cto.com/9161406/1839667
- VMware Workstation 12 Pro 之安装林耐斯Ubuntu X64系统
VMware Workstation 12 Pro 之安装林耐斯Ubuntu X64系统... -------------- Linux依照国际音标应该是/'linэks/——类似于“里讷克斯&quo ...
- servlet请求编码与响应编码问题（编码不一致可能会导致乱码）
html中的编码 <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"&g ...
- CSS 常用样式 提高网页编写速度
*{margin:0px;padding:0px;}/*内外边距初始化*/html, body, div, h1, h2, h3, h4, h5, h6, p, span, img, input, t ...
- HTTP协议初级入门
Http = HyperText Transfer Protocol即超文本传输协议 HTTPS = Hyper Text Transfer Protocol over Secure Socket L ...
- 小爬新浪新闻AFCCL
1.任务目标: 爬取新浪新闻AFCCL的文章:文章标题.时间.来源.内容.评论数等信息. 2.目标网页: http://sports.sina.com.cn/z/AFCCL/ 3.网页分析 4.源代码 ...
- MongoDb 入门教程
MongoDb 是一个介于关系数据库和非关系数据库之间的产品,是非关系数据库当中功能最丰富,最像关系数据库的. 它是可扩展的高性能数据存储解决方案,经常被用于非关系型数据的存储,能存储海量的数据. 常 ...