java i= 0001_I/O复习(一)——Java I/O

File

特定文件

FileDemo.java：

import java.io.File;

public class FileDemo {

static void p(String s) {

System.out.println(s);

}

public static void main(String[] args) {

File f1 = new File("./src/main/java/com/yangyun/javae/chapter20/FileDemo.java");

// 文件名

p("File Name:" + f1.getName());

// 文件路径

p("Path:" + f1.getPath());

// 绝对路径

p("Abs Path:" + f1.getAbsolutePath());

// 父级

p("Parent:" + f1.getParent());

// 文件是否存在

p(f1.exists() ? "exists" : "does not exist");

// 文件是否可写

p(f1.canWrite() ? "is writeable" : "is not writeable");

// 文件是否可读

p(f1.canRead() ? "is readable" : "is not readable");

// 是文件还是文件夹

p("is " + (f1.isDirectory() ? " a directory" : "not a directory"));

// 是否是常规文件，设备驱动和命名管道返回false

p(f1.isFile() ? "is normal file" : "might be a named pipe");

// 文件是否具有绝对路径

p(f1.isAbsolute() ? "is absolute" : "is not absolute");

// 文件上次修改时间

p("File last modified:" + f1.lastModified());

// 文件大小

p("File size:" + f1.length() + " Bytes");

}

}

一个目录下的一组文件的名称

DirList.java：

import java.io.File;

import java.io.FilenameFilter;

import java.util.Arrays;

import java.util.regex.Pattern;

public class DirList {

/**

* 传向filter()的参数必须是final的。这在匿名内部类中是必须的，这样才能使用来自该类范围之外的对象。

* @param regex

* @return

*/

public static FilenameFilter filter(final String regex) {

// 创建匿名内部类

return new FilenameFilter() {

private Pattern pattern = Pattern.compile(regex);

@Override

public boolean accept(File dir, String name) {

return pattern.matcher(name).matches();

}

};

}

public static void main(String[] args) {

// 获取当前项目下的文件名称

File path = new File(".");

String[] list;

if (args.length == 0) {

list = path.list();

} else {

list = path.list(filter(args[0]));

}

// 对结果进行排序

Arrays.sort(list, String.CASE_INSENSITIVE_ORDER);

for (String dirItem : list) {

System.out.println(dirItem);

}

}

}

DirListOnly.java：

import java.io.File;

import java.io.FilenameFilter;

class OnlyExt implements FilenameFilter {

String ext;

public OnlyExt(String ext) {

this.ext = "." + ext;

}

@Override

public boolean accept(File dir, String name) {

return name.endsWith(ext);

}

}

public class DirListOnly {

public static void main(String[] args) {

String dirname = "/Users/yangyun/Documents/personal_project/thinking-in-java/src/main/java/com/yangyun/javaee/chapte1";

File f1 = new File(dirname);

FilenameFilter only = new OnlyExt("java");

String[] s = f1.list(only);

for (int i = 0; i < s.length; i++) {

System.out.println(s[i]);

}

}

}

创建目录

MakeDirDemo.java：

import java.io.File;

public class MakeDirDemo {

public static void main(String[] args) {

String dirname = "/Users/yangyun/Documents/personal_project/thinking-in-java/src/main/java/com/yangyun/javae/chapter40";

File f1 = new File(dirname);

if (f1.mkdir()) {

System.out.println("mkdir success");

} else {

System.out.println("mkdir fail");

}

}

}

MakeDirsDemo.java：

import java.io.File;

public class MakeDirsDemo {

public static void main(String[] args) {

String dirname = "/Users/yangyun/Documents/personal_project/thinking-in-java/src/main/java/com/yangyun/javae/yy/chapter40";

File f1 = new File(dirname);

if (f1.mkdirs()) {

System.out.println("mkdirs success");

} else {

System.out.println("mkdirs fail");

}

}

}

字节流

InputStream(输入流)

表1-1 InputStream类型

类功能构造器/如何使用ByteArrayInputStream允许将内存的缓冲区当作InputStream使用缓冲区，字节将从中取出作为一种数据源：将其与FilterInputStream对象相连使用以提供有用的接口FileInputStream用于从文件中读取信息字符串，表示文件名、文件或FileDescriptor对象作为一种数据源：将其与FilterInputStream对象相连以提供有用的接口SequenceInputStream将两个或多个InputStream对象转换成单一InputStream两个InputStream对象或一个容纳InputStream对象的容器Enumeration作为一种数据源：将其与FilterInputStream对象相连以提供有用的接口PipedInputStream产生用于写入相关PipedOutputStream的数据。实现“管道化”概念PipedOutputStream作为多线程中数据源：将其与FilterInputStream对象相连以提供有用的接口FilterInputStream抽象类，作为装饰器的接口，其中，装饰器为其他的InputStream类提供有用的功能见表1-3

ByteArrayInputStrea

ByteArrayInputStreamDemo.java：

import java.io.ByteArrayInputStream;

public class ByteArrayInputStreamDemo {

public static void main(String[] args) {

String tmp = "abcdefghijklmnopqrstuvwzyz";

byte[] b = tmp.getBytes();

ByteArrayInputStream input1 = new ByteArrayInputStream(b);

ByteArrayInputStream input2 = new ByteArrayInputStream(b, 0, 3);

}

}

ByteArrayInputStreamReset.java：

import java.io.ByteArrayInputStream;

public class ByteArrayInputStreamReset {

public static void main(String[] args) {

String tmp = "abcdefg";

byte[] b = tmp.getBytes();

ByteArrayInputStream in = new ByteArrayInputStream(b);

for (int i = 0; i < 2; i++) {

int c;

while ((c = in.read()) != -1) {

if (i == 0) {

char val = (char) c;

System.out.print(val);

if (val == 'a') {

// 设置流中当前标记的位置

in.mark(1);

}

} else {

System.out.print(Character.toUpperCase((char) c));

}

}

System.out.println();

// 如果没有调用mark( )方法，reset( )方法会将指针设置为流的开头，否则回到上次mark( )的地方

in.reset();

}

}

}

FileInputStream

FileInputStreamDemo.java：

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.IOException;

public class FileInputStreamDemo {

public static void main(String[] args) {

int size;

try (FileInputStream f = new FileInputStream("./src/main/java/com/yangyun/javae/chapter20/FileInputStreamDemo.java")) {

System.out.println("Total Available Bytes:" + (size = f.available()));

int n = size / 40;

System.out.println("First " + n + " bytes of the file one read() at a time");

for (int i = 0; i < n; i++) {

System.out.print((char) f.read());

}

System.out.println("\nStill Available:" + f.available());

System.out.println("------------------------------------");

System.out.println("Reading the next " + n + " with one read(b[])");

byte[] b = new byte[n];

if (f.read(b) != n) {

System.err.println("couldn't read " + n + " bytes.");

}

System.out.println(new String(b, 0, n));

System.out.println("\nStill Available:" + (size = f.available()));

System.out.println("Skipping half of remaining bytes with skip()");

f.skip(size / 2);

System.out.println("Still Available:" + f.available());

System.out.println("------------------------------------");

System.out.println("Reading " + n / 2 + " into the end of array");

// 返回成功读取的字节数

if (f.read(b, n / 2, n / 2) != n / 2) {

System.out.println("couldn't read " + n / 2 + " bytes.");

}

System.out.println(new String(b, 0, b.length));

System.out.println("\nStill Available:" + f.available());

} catch (FileNotFoundException e) {

e.printStackTrace();

} catch (IOException e) {

e.printStackTrace();

}

}

}

BufferedInputStream

BufferInputStreamDemo.java：

import java.io.BufferedInputStream;

import java.io.ByteArrayInputStream;

import java.io.IOException;

public class BufferedInputStreamDemo {

public static void main(String[] args) {

String s = "This is a © copyright symbol but this is &copy not.\n";

byte[] buf = s.getBytes();

ByteArrayInputStream in = new ByteArrayInputStream(buf);

int c;

boolean marked = false;

try (BufferedInputStream f = new BufferedInputStream(in)) {

while ((c = f.read()) != -1) {

switch (c) {

case '&':

if (!marked) {

f.mark(32);

marked = true;

} else {

marked = false;

}

break;

case ';':

if (marked) {

marked = false;

System.out.print("(c)");

} else {

System.out.print((char) c);

}

break;

case ' ':

if (marked) {

marked = false;

f.reset();

System.out.print("&");

} else {

System.out.print((char) c);

}

break;

default:

if (!marked) {

System.out.print((char) c);

}

break;

}

}

} catch (IOException e) {

e.printStackTrace();

}

}

}

SequenceInputStream

SequenceInputStreamDemo.java：

import java.io.IOException;

import java.io.InputStream;

import java.io.SequenceInputStream;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.util.Enumeration;

import java.util.Vector;

class InputStreamEnumerator implements Enumeration {

private Enumeration files;

public InputStreamEnumerator(Vector files) {

this.files = files.elements();

}

@Override

public boolean hasMoreElements() {

return files.hasMoreElements();

}

@Override

public FileInputStream nextElement() {

try {

return new FileInputStream(files.nextElement().toString());

} catch (FileNotFoundException e) {

return null;

}

}

}

public class SequenceInputStreamDemo {

public static void main(String[] args) {

int c;

Vector files = new Vector<>();

files.addElement("file1.txt");

files.addElement("file2.txt");

files.addElement("file3.txt");

InputStreamEnumerator ise = new InputStreamEnumerator(files);

try (InputStream input = new SequenceInputStream(ise)) {

while ((c = input.read()) != -1) {

System.out.print((char) c);

}

} catch (IOException e) {

e.printStackTrace();

}

}

}

OutputStream(输出流)

表1-2 OutputStream类型

类功能构造器/如何使用ByteArrayOutputStream在内存中创建缓冲区。所有送往流的数据都要放置在此缓冲区缓冲区初始化尺寸(可选的)用于指定数据的目的地：将其与FilterOutputStream对象相连以提供有用的接口FileOutputStream用于将信息写至文件字符串，表示文件名、文件或FileDescriptor对象。指定数据的目的地：将其与FilterOutputStream对象相连以提供有用的接口PipedOutputStream任何写入其中的信息都会自动作为相关PipedOutputStream的输出。实现管道化概念。PipedInputStream指定用于多线程的数据的目的地：将其与FilterOutputStream对象相连以提供有用的接口FilterOutputStream抽象类，作为装饰器的接口。其中，装饰器为其他OutputStream提供有用功能见表1-4

ByteArrayOutputStream

ByteArrayOutputStreamDemo.java：

import java.io.ByteArrayOutputStream;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.IOException;

public class ByteArrayOutputStreamDemo {

public static void main(String[] args) {

ByteArrayOutputStream f = new ByteArrayOutputStream();

String s = "This should end up in the array";

byte[] buf = s.getBytes();

try {

f.write(buf);

} catch (IOException e) {

e.printStackTrace();

}

System.out.println("Buffer as a String");

System.out.println(f.toString());

System.out.println("Into array");

byte[] b = f.toByteArray();

for (int i = 0; i < b.length; i++) {

System.out.print((char) b[i]);

}

System.out.println("\nTo an OutputStream()");

try (FileOutputStream f2 = new FileOutputStream("test.txt")) {

// 将f的内容写入test.txt文件中

f.writeTo(f2);

} catch (FileNotFoundException e) {

e.printStackTrace();

} catch (IOException e) {

e.printStackTrace();

}

System.out.println("Doing a reset");

f.reset();

for (int i = 0; i < 3; i++) {

f.write('X');

}

System.out.println(f.toString());

}

}

FileOutputStream

FileOutputStreamDemo.java：

import java.io.FileOutputStream;

import java.io.IOException;

public class FileOutputStreamDemo {

public static void main(String[] args) {

String source = "Now is the time for all good men\n"

+ " to come to the aid of their country\n"

+ " and pay their due taxes.";

byte[] buf = source.getBytes();

try ( FileOutputStream f0 = new FileOutputStream("file1.txt");

FileOutputStream f1 = new FileOutputStream("file2.txt");

FileOutputStream f2 = new FileOutputStream("file3.txt")){

// 写第一个文件

for (int i = 0; i < buf.length; i += 2) {

f0.write(buf[i]);

}

// 写第二个文件

f1.write(buf);

// 写第三个文件

f2.write(buf, buf.length - buf.length / 4, buf.length / 4);

} catch(IOException e){

System.out.println("An I/O Error Occurred");

}

}

}

FilterInputStream

表1-3 FilterInputStream类型

类功能构造器/如何使用DataInputStream与DataOutputStream搭配使用，因此我们可以按照移植方式从流读取基本数据类型InputStream包含用于读取基本类型数据的全部接口BufferedInputStream使用它可以防止每次读取时都进行实际写操作。代表“使用缓冲区”InputStream,可以指定缓冲区大小；本质上不提供接口，只不过是向进程中添加缓冲区所必需的。与接口对象搭配LineNumberInputStream跟踪输入流中的行号；可调用getLineNumber()和setLineNumber(int)IntputStream仅增加了行号，因此可能要与接口对象搭配使用PushbackInputStream具有“能弹出一个字节的缓冲区”。因此可以将读到的最后一个字符回退InputStream通常作为编译器的扫描器，之所以包含在内是因为Java编译器的需要，我们可能永远不会用到

DataInputStream

DataIODemo.java：

import java.io.*;

public class DataIODemo {

public static void main(String[] args) {

// 写数据

try (DataOutputStream dout = new DataOutputStream(new FileOutputStream("Test.txt"))) {

dout.writeDouble(98.6);

dout.writeInt(1000);

dout.writeBoolean(true);

} catch (FileNotFoundException e) {

e.printStackTrace();

} catch (IOException e) {

e.printStackTrace();

}

try (DataInputStream din = new DataInputStream(new FileInputStream("Test.txt"))) {

double d = din.readDouble();

int i = din.readInt();

boolean b = din.readBoolean();

System.out.println("Here are the values:" + d + " " + i + " " + b);

} catch (FileNotFoundException e) {

e.printStackTrace();

} catch (IOException e) {

e.printStackTrace();

}

}

}

PushbackInputStream

PushInputStreamDemo.java：

import java.io.ByteArrayInputStream;

import java.io.PushbackInputStream;

public class PushInputStreamDemo {

public static void main(String args[]) throws Exception {

// 定义字符串

String str = "www.baidu.com";

// 定义回退流对象

PushbackInputStream push = null;

// 定义内存输入流

ByteArrayInputStream bai = null;

// 实例化内存输入流

bai = new ByteArrayInputStream(str.getBytes());

// 从内存中读取数据

push = new PushbackInputStream(bai);

System.out.print("读取之后的数据为：");

int temp = 0;

// 读取内容

while ((temp = push.read()) != -1) {

// 判断是否读取到了“.”

if (temp == '.') {

// 放回到缓冲区之中

push.unread(temp);

// 再读一遍

temp = push.read();

System.out.print("(退回" + (char) temp + ")");

} else {

// 输出内容

System.out.print((char) temp);

}

}

}

}

PushbackInputStreamDemo.java：

import java.io.ByteArrayInputStream;

import java.io.IOException;

import java.io.PushbackInputStream;

public class PushbackInputStreamDemo {

public static void main(String[] args) {

String s = "if (a == 4) a = 0;\n";

byte[] buf = s.getBytes();

ByteArrayInputStream in = new ByteArrayInputStream(buf);

int c;

try (PushbackInputStream f = new PushbackInputStream(in)) {

while ((c = f.read()) != -1) {

switch (c) {

case '=':

if ((c = f.read()) == '=') {

System.out.print(".eq.");

} else {

System.out.print("

f.unread(c);

}

break;

default:

System.out.print((char) c);

break;

}

}

} catch (IOException e) {

e.printStackTrace();

}

}

}

注意事项：PushbackInputStream对象会使得InputStream对象的mark( )或reset( )方法无效。所以对于准备使用mark( )或reset( )方法的任何流来说，都应该先使用markSupport( )方法进行检查。

FilterOutputStream

表1-4 FilterOutputStream类型

类功能构造器/如何使用DataOutputStream与DataInputStream搭配使用，因此可以按照可移植方式向流中写入基本类型数据OutputStream包含用于读取基本类型数据的全部接口PrintStream用于产生格式化输出。其中DataOutputStream处理数据的存储，PrintStream处理显示OutputStream，可以用boolean值指示是否在每次换行时清空缓冲区(可选的)应该是对OutputStream对象的“final”封装。可能会经常使用到它BufferedOutputStream使用它以避免每次发送数据时都要进行实际的鞋操作。代表“使用缓冲区”。可以调用flush()清空缓冲区OutputStream，可以指定缓冲区大小(可选的)

DataOutputStream

见DataIODemo：

RandomAccessFile

UsingRandomAccessFile.java：

import java.io.IOException;

import java.io.RandomAccessFile;

public class UsingRandomAccessFile {

static String file = "/Users/yangyun/Documents/linux/shell/exam1/test1";

static void display() throws IOException {

RandomAccessFile rf = new RandomAccessFile(file, "r");

for (int i = 0; i < 7; i++) {

System.out.println("Value " + i + ":" + rf.readDouble());

}

System.out.println(rf.readUTF());

rf.close();

}

public static void main(String[] args) throws IOException {

RandomAccessFile rf = new RandomAccessFile(file, "rw");

for (int i = 0; i < 7; i++) {

rf.writeDouble(i * 1.414);

}

rf.writeUTF("The end of the file");

rf.close();

display();

rf = new RandomAccessFile(file, "rw");

rf.seek(5 * 8);

rf.writeDouble(47.0001);

rf.close();

display();

}

}

字符流

InputStream和OutputStream在以面向字节形式的I/O中仍可以提供极有价值的功能，Reader和Writer则提供兼容Unicode与面向字符的I/O功能。 一般我们把来自于“字节”层次结构中的类和“字符”层次结构中的类结合起来使用。为了实现这个目的，要用到“适配器”(adapter)类：InputStreamReader可以把InputStream转换为Reader，而OutputStreamWriter可以把OutputStream转换为Writer。设计Reader和Writer继承层次结构主要是为了国际化。老的I/O流继承层次结构仅支持8位字节流，并且不能很好地处理16位的Unicode字符。由于Unicode用于字符国际化，所以添加Reader和Writer继承层次结构就是为了在所有的I/O操作中都支持Unicode。

Reader

FileReader

FileReaderDemo.java：

mport java.io.FileNotFoundException;

import java.io.FileReader;

import java.io.IOException;

public class FileReaderDemo {

public static void main(String[] args) {

try (FileReader fr = new FileReader("/Users/yangyun/Documents/personal_project/thinking-in-java/src/main/java/com/yangyun/javae/chapter20/FileReaderDemo.java")) {

int c;

while ((c = fr.read()) != -1) {

System.out.print((char) c);

}

} catch (FileNotFoundException e) {

e.printStackTrace();

} catch (IOException e) {

e.printStackTrace();

}

}

}

CharArrayReader

CharArrayReaderDemo.java：

import java.io.CharArrayReader;

import java.io.IOException;

public class CharArrayReaderDemo {

public static void main(String[] args) {

String tmp = "abcdefghijklmnopqrstuvwxyz";

int length = tmp.length();

char[] c = new char[length];

tmp.getChars(0, length, c, 0);

int i;

try (CharArrayReader input1 = new CharArrayReader(c)) {

System.out.println("input1 is:");

while ((i = input1.read()) != -1) {

System.out.print((char) i);

}

System.out.println();

} catch (IOException e) {

System.out.println("I/O Error:" + e);

}

try (CharArrayReader input2 = new CharArrayReader(c,0,5)) {

System.out.println("input2 is:");

while ((i = input2.read()) != -1) {

System.out.print((char) i);

}

System.out.println();

} catch (IOException e) {

System.out.println("I/O Error:" + e);

}

}

}

BufferedReader

BufferedReaderDemo.java：

import java.io.*;

public class BufferedReaderDemo {

public static void main(String[] args) {

String s = "This is a © copyright symbol but this is &copy not.\n";

char[] buf = new char[s.length()];

s.getChars(0, s.length(), buf, 0);

CharArrayReader in = new CharArrayReader(buf);

int c;

boolean marked = false;

try (BufferedReader f = new BufferedReader(in)) {

while ((c = f.read()) != -1) {

switch (c) {

case '&':

if (!marked) {

f.mark(32);

marked = true;

} else {

marked = false;

}

break;

case ';':

if (marked) {

marked = false;

System.out.print("(c)");

} else {

System.out.print((char) c);

}

break;

case ' ':

if (marked) {

marked = false;

f.reset();

System.out.print("&");

} else {

System.out.print((char) c);

}

break;

default:

if (!marked) {

System.out.print((char) c);

}

break;

}

}

} catch (IOException e) {

e.printStackTrace();

}

}

}

PushbackReader

PushbackReaderDemo.java：

import java.io.*;

public class PushbackReaderDemo {

public static void main(String[] args) {

String s = "if (a == 4) a = 0;\n";

char[] buf = new char[s.length()];

s.getChars(0,s.length(),buf,0);

CharArrayReader in = new CharArrayReader(buf);

int c;

try (PushbackReader f = new PushbackReader(in)) {

while ((c = f.read()) != -1) {

switch (c) {

case '=':

if ((c = f.read()) == '=') {

System.out.print(".eq.");

} else {

System.out.print("

f.unread(c);

}

break;

default:

System.out.print((char) c);

break;

}

}

} catch (IOException e) {

e.printStackTrace();

}

}

}

Writer

FileWriter

FileWriterDemo.java：

import java.io.FileWriter;

import java.io.IOException;

public class FileWriterDemo {

public static void main(String[] args) {

String source = "Now is the time for all good men\n"

+ " to come to the aid of their country\n"

+ " and pay their due taxes.";

char[] buffer = new char[source.length()];

source.getChars(0, source.length(), buffer, 0);

try (FileWriter f0 = new FileWriter("file1.txt");

FileWriter f1 = new FileWriter("file2.txt");

FileWriter f2 = new FileWriter("file3.txt")) {

for (int i = 0; i < buffer.length; i += 2) {

f0.write(buffer[i]);

}

f1.write(buffer);

f2.write(buffer, buffer.length - buffer.length / 4, buffer.length / 4);

} catch (IOException e) {

e.printStackTrace();

}

}

}

CharArrayWriter

CharArrayWriterDemo.java：

import java.io.CharArrayWriter;

import java.io.FileWriter;

import java.io.IOException;

public class CharArrayWriterDemo {

public static void main(String[] args) {

CharArrayWriter f = new CharArrayWriter();

String s = "This should end up in the array";

char[] buf = new char[s.length()];

s.getChars(0, s.length(), buf, 0);

try {

f.write(buf);

} catch (IOException e) {

e.printStackTrace();

}

System.out.println("Buffer as a String");

System.out.println(f.toString());

System.out.println("Into array");

char[] c = f.toCharArray();

for (int i = 0; i < c.length; i++) {

System.out.print(c[i]);

}

System.out.println("\nTo a FileWriter()");

try (FileWriter f2 = new FileWriter("test.txt")) {

f.writeTo(f2);

} catch (IOException e) {

e.printStackTrace();

}

System.out.println("Doing a reset");

f.reset();

for (int i = 0; i < 3; i++) {

f.write('X');

}

System.out.println(f.toString());

}

}

PrintWriter

BasicFileOutput.java：

import java.io.*;

public class BasicFileOutput {

static String file = "BasicFileOutput.out";

public static String read(String filename) throws IOException {

// 按行读取

BufferedReader in = new BufferedReader(new FileReader(filename));

String s;

StringBuilder sb = new StringBuilder();

while ((s = in.readLine()) != null) {

sb.append(s + "\n");

}

// 关闭流

in.close();

return sb.toString();

}

public static void main(String[] args) throws IOException {

BufferedReader in = new BufferedReader(new StringReader(BufferedInputFile.read(

"/Users/yangyun/Documents/linux/shell/exam1/test3")));

PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter(file)));

int lineCount = 1;

String s;

while ((s = in.readLine()) != null) {

out.println(lineCount++ + ":" + s);

}

out.close();

// 展示保存的文件

System.out.println(BufferedInputFile.read(file));

}

}

ChangeSystemOut.java：

import java.io.PrintWriter;

// PrintWriter有一个可以接受OutputStream作为参数的构造器

public class ChangeSystemOut {

public static void main(String[] args) {

PrintWriter out = new PrintWriter(System.out, true);

out.println("Hello,world");

}

}

标准I/O重定向

Redirecting.java：

import java.io.*;

public class Redirecting {

public static void main(String[] args) throws IOException {

PrintStream console = System.out;

BufferedInputStream in = new BufferedInputStream(new FileInputStream("/Users/yangyun/Documents/linux/shell/exam1/test2"));

PrintStream out = new PrintStream(new BufferedOutputStream(new FileOutputStream("test.out")));

System.setIn(in);

System.setOut(out);

System.setErr(out);

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

String s;

while ((s = br.readLine()) != null) {

System.out.println(s);

}

System.out.println("hello");

out.close();

System.setOut(console);

System.out.println("hello");

}

}

串行化

SerializationDemo.java：

import java.io.*;

class MyClass implements Serializable {

//transient String s;

String s;

private int i;

private double d;

public MyClass(String s, int i, double d) {

this.s = s;

this.i = i;

this.d = d;

}

@Override

public String toString() {

return "s=" + s + ";i=" + i + ";d=" + d;

}

}

public class SerializationDemo {

public static void main(String[] args) throws IOException {

try (ObjectOutputStream objOStrm = new ObjectOutputStream(new FileOutputStream("serial"))) {

MyClass object1 = new MyClass("Hello", -7, 2.7e10);

System.out.println("object1:" + object1);

objOStrm.writeObject(object1);

} catch (FileNotFoundException e) {

e.printStackTrace();

} catch (IOException e) {

e.printStackTrace();

}

try (ObjectInputStream objIStrm = new ObjectInputStream(new FileInputStream("serial"))) {

MyClass object2 = (MyClass) objIStrm.readObject();

System.out.println("object2:" + object2);

} catch (FileNotFoundException e) {

e.printStackTrace();

} catch (IOException e) {

e.printStackTrace();

} catch (ClassNotFoundException e) {

e.printStackTrace();

}

}

}

字节流与字符流的对应关系

表1-5 字节流与字符流的对应关系

字节流字符流InputStreamReader(适配器：InputStreamReader)OutputStreamWriter(适配器：OutputStreamWriter)FileInputStreamFileReaderFileOutputStreamFileWriterStringBufferInputStream(Deprecated)StringReaderStringWriterByteArrayInputStreamCharArrayReaderByteArrayOutputStreamCharArrayWriterPipedInputStreamPipedReaderPipedOutputStreamPipedWriterFilterInputStreamFilterReaderFilterOutputStreamFilterWriterBufferedInputStreamBufferedReaderBufferedOutputStreamPrintStreamPrintWriterLineNumberInputStream(Deprecated)LineNumberReaderStreamTokenizerStreamTokenizer(使用接受Reader的构造器)PushbackInputStreamPushbackReader