1.Reader && Writer
Reader
java.lang.Object
|-- java.io.Reader//常用方法
|-- int read() //读取单个字符
|-- int read(char[] cbuf) //将字符读入数组中
|-- abstract int read(char[] cbuf, int off, int len) //将字符读入数组中的某一部分。
|--abstract void close() //关流
|-- java.io.BufferedReader//其方法大致和Reader相同不在列举，注意BufferedReader有ReadLine()方法
|-- java.io.LineNumberReader //以下为其常用方法
|-- LineNumberReader(Reader in) //构造方法
|-- int getLineNumber() //获取当前行号
|-- int read() //读取单个字符
|-- int read(char[] cbuf, int off, int len) //将字符读入数组中的某一部分。
|-- String readLine() //读取文本行。
|-- void close() //关流
|-- java.io.InputStreamReader//继承自Reader，常用方法与Reader基本相同，注意构造方法参数，此类将字节流转换为字符流，是字节流通向字符流的桥梁
|-- InputStreamReader(InputStream in) //构造方法
|-- InputStreamReader(InputStream in, Charset cs)//构造方法，创建使用给定字符集的 InputStreamReader。
|-- java.io.FileReader//常用方法
|-- FileReader(File file)//构造方法
|-- FileReader(String fileName) //构造方法
|-- java.io.CharArrayReader//此类实现一个可用作字符输入流的字符缓冲区。
|-- CharArrayReader(char[] buf) //构造方法，根据指定的 char 数组创建一个 CharArrayReader。
|-- CharArrayReader(char[] buf, int offset, int length) //构造方法，根据指定的 char 数组创建一个 CharArrayReader。
|-- java.io.PipedReader//传送的字符输入流。
|-- PipedReader() //构造方法，创建尚未连接的 PipedReader。
|-- PipedReader(int pipeSize) //创建一个尚未连接的 PipedReader，并对管道缓冲区使用指定的管道大小。
|-- PipedReader(PipedWriter src) //创建连接到传送 writer src 的 PipedReader。
|-- PipedReader(PipedWriter src, int pipeSize) // 创建一个 PipedReader，使其连接到管道 writer src，并对管道缓冲区使用指定的管道大小。
|-- void connect(PipedWriter src) //使此传送 reader 连接到传送 writer src。
|-- java.io.FilterReader
|-- protected FilterReader(Reader in) //创建一个新的 filtered reader，其余方法和Reader相似
|-- java.io.StringReader //其源为一个字符串的字符流。与CharArrayReader相似
|-- StringReader(String s) //创建一个新字符串 reader。
$$ 此例为复制文件：通过File创建一个空文件，并把之前已存在的文件进行读取，将内容复制到空文件中，实现复制文件，
package com.IO;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class BufferedReaderTest02 {
public static void main(String[] args) throws IOException {
// TODO Auto-generated method stub
File file = new File("E:\\Blog\\test.txt");
BufferedReader br = new BufferedReader(new FileReader("E:\\Blog\\Copy01.txt"));
BufferedWriter bw = new BufferedWriter(new FileWriter(file));//使用 FileReader(String fileName) 构造方法
String line = null;
while((line = br.readLine()) != null) {
bw.write(line);
bw.newLine();
bw.flush();
}
bw.close();
br.close();
}
}
$$ 此例仍以复制文件为例：InputStreamReader 和 OutputStreamWriter方法的具体演示，注释掉的是另一种实现方法，并不是错误，得到的结果都是相同的，都会复制到指定文件中，注意：一旦操作文本涉及到具体的指定编码表时，必须使用转换流 。
本例解析：读取一个文件，将其转换为字符流进行操作，可以进行整行读取比较方便
package com.IO;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
public class InputStreamReaderTest01 {
@SuppressWarnings("unused")
public static void main(String[] args) throws IOException {
// TODO Auto-generated method stub
// InputStreamReader in = new InputStreamReader(new FileInputStream("E:\\Blog\\Copy01.txt"));
// OutputStreamWriter out = new OutputStreamWriter(new FileOutputStream("E:\\Blog\\Copy04.txt"));
BufferedReader in = new BufferedReader(new
InputStreamReader(new FileInputStream("E:\\Blog\\Copy01.txt")));
BufferedWriter out = new BufferedWriter(new
OutputStreamWriter(new FileOutputStream("E:\\Blog\\Copy06.txt")));
// int len;
// char[] ch = new char[1024];
//
// while((len = in.read(ch)) != -1) {
// out.write(ch,0,len);
// out.flush();
// }
String line = null;
while((line = in.readLine()) != null) {
out.write(line);
out.newLine();
out.flush();
}
out.close();
in.close();
}
}
$$ 此例为CharArrayReader 的基本操作，此类用的相对较少对应字节流中的 ByteArrayInputStream
package com.IO;
import java.io.CharArrayReader;
import java.io.IOException;
public class CharArrayReaderTest01 {
public static void main(String[] args) throws IOException {
// TODO Auto-generated method stub
char[] ch = {'a','c','e','r','v','t','s','q','p','b'};
CharArrayReader cr = new CharArrayReader(ch);
System.out.println((char)cr.read());
cr.skip(1);//跳过下标为 1 之前的元素
char[] ch1 = new char[5];
cr.read(ch1, 0, 4);//相当于复制0~4的元素ch1中
System.out.println(new String(ch1));
}
}
/**结果为
* a
* ervt
*/
Writer
与Reader相似，二者大多数都是对应存在的，相当于有输入必有输出
java.lang.Object
|-- java.io.Writer //常用方法
|-- Writer append(char c) //将指定字符添加到此 writer。
|-- abstract void flush() //刷新该流的缓冲。
|-- void write(char[] cbuf) //写入字符数组。
|-- abstract void write(char[] cbuf, int off, int len) //写入字符数组的某一部分
|-- void write(int c) //写入单个字符。
|-- void write(String str) //写入字符串。
|-- void write(String str, int off, int len) // 写入字符串的某一部分。
|-- java.io.BufferedWriter //缓冲流，提高效率，方法看父类，注意构造函数要传进来一个 Writer out，存在 newLine方法写入一个行分隔符
|-- java.io.OutputStreamWriter //字符流通向字节流的桥梁,将输出的字符流变为字节流
|-- OutputStreamWriter(OutputStream out) //构造函数
|-- String getEncoding() //返回此流使用的字符编码的名称。其余方法参看父类
|-- java.io.CharArrayWriter//使用较少，不再列举其具体方法
|-- java.io.StringWriter//不做实例，不列举方法
|-- java.io.FilterWriter
|-- protected FilterWriter(Writer out)// 创建一个新的 filtered writer，其余方法参看父类
|-- java.io.PipedWriter 传送的字符输出流。
|-- PipedWriter() //创建一个尚未连接到传送 reader 的传送 writer。
|-- PipedWriter(PipedReader snk) //创建传送 writer，使其连接到指定的传送 reader。
|-- void connect(PipedReader snk) //将此传送 writer 连接到接收方。
|-- java.io.PrintWriter//向文本输出流打印对象的格式化表示形式
|-- PrintWriter(File file) //使用指定文件创建不具有自动行刷新的新 PrintWriter。
|-- PrintWriter(OutputStream out)// 根据现有的 OutputStream 创建不带自动行刷新的新 PrintWriter。
|-- PrintWriter(OutputStream out, boolean autoFlush)// 通过现有的 OutputStream 创建新的 PrintWriter。
|-- PrintWriter(String fileName)//创建具有指定文件名称且不带自动行刷新的新 PrintWriter
|-- PrintWriter(Writer out) //创建不带自动行刷新的新 PrintWriter。
|-- PrintWriter(Writer out, boolean autoFlush)// 创建新 PrintWriter。
|-- void println(int x) // 打印整数，然后终止该行。
|-- void print(int i) //打印整数。
$$ CharArrayWriter 简单示例
package com.IO;
import java.io.CharArrayWriter;
public class CharArrayWriterTest01 {
public static void main(String[] args) {
// TODO Auto-generated method stub
char[] ch = {'a','c','e','r','v','t','s','q','p','b'};
CharArrayWriter cw = new CharArrayWriter();
cw.write(ch, 0, 6);
System.out.println(cw.size());
System.out.println(cw.toString());
char[] ch1 = cw.toCharArray();
for(char c : ch1)
System.out.print(c + " ");
}
}
/**
*
* 结果为
* 6
* acervt
* a c e r v t
*
* */
$$PrintWriter 示例
package com.IO;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.PrintWriter;
public class PrintWriterTest01 {
public static void main(String[] args) {
// TODO Auto-generated method stub
char[] ch = {'a','c','e','r','v','t','s','q','p','b'};
PrintWriter po;
String s = "abe";
String ss = "kl阿斯顿发";
try {
po = new PrintWriter(new FileOutputStream("E:\\Blog\\test02.txt"));
po.write(ch);
po.println(s);//打印到E:\\Blog\\test02.txt中
po.print(ss);
po.flush();
po.close();
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
2.InputStream与OutputStream
InputStream
这里只介绍几种比较常用的类
java.lang.Object
|-- java.io.InputStream
|-- int available() // 返回此输入流下一个方法调用可以不受阻塞地从此输入流读取（或跳过）的估计字节数。
|-- void close() //关流
|-- abstract int read() //从输入流中读取数据的下一个字节。
|-- int read(byte[] b) //从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中
|-- int read(byte[] b, int off, int len) //将输入流中最多 len 个数据字节读入 byte 数组。
|-- java.io.FileInputStream
|-- FileInputStream(File file)
|-- FileInputStream(String name)
|-- protected void finalize() //确保在不再引用文件输入流时调用其 close 方法。
|-- java.io.ByteArrayInputStream //与CharArrayReader相似
|-- ByteArrayInputStream(byte[] buf)
|-- ByteArrayInputStream(byte[] buf, int offset, int length)
|-- java.io.FilterInputStream
|-- java.io.BufferedInputStream//缓冲区，提高效率
|-- BufferedInputStream(InputStream in) //构造函数
|-- java.io.DataInputStream
|-- DataInputStream(InputStream in)
|-- java.io.ObjectInputStream
|-- Object readObject() //从 ObjectInputStream 读取对象。
|-- java.io.PipedInputStream //管道输入流应该连接到管道输出流；管道输入流提供要写入管道输出流的所有数据字节
|-- PipedInputStream() //创建尚未连接的 PipedInputStream。
|-- PipedInputStream(int pipeSize) //创建一个尚未连接的 PipedInputStream，并对管道缓冲区使用指定的管道大小。
|-- PipedInputStream(PipedOutputStream src) //创建 PipedInputStream，使其连接到管道输出流 src。
|-- PipedInputStream(PipedOutputStream src, int pipeSize) //创建一个 PipedInputStream，使其连接到管道输出流 src，并对管道缓冲区使用指定的管道大小。
|-- void connect(PipedOutputStream src) //使此管道输入流连接到管道输出流 src。
$$ ObjectInputStream与ObjectOutputStream用法简单示例，注意：ObjectInputStream writerObject对象的时候，不能直接添加，需要将此类实现序列化serializable。
package com.IO;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.HashSet;
import java.util.Set;
public class ObjectStreamTest01 {
public static void main(String[] args) throws IOException, ClassNotFoundException {
// TODO Auto-generated method stub
Set<Worker> list = new HashSet<Worker>();
list.add(new Worker("lisi01",10000));
list.add(new Worker("lisi02",10000));
list.add(new Worker("lisi02",15000));
list.add(new Worker("lisi01",10000));
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("E:\\Blog\\test03.txt"));
out.writeObject(list);
ObjectInputStream in = new ObjectInputStream(new FileInputStream("E:\\Blog\\test03.txt"));
@SuppressWarnings("unchecked")
Set<Worker> ww = (Set<Worker>)in.readObject();
for(Worker w : ww)
System.out.println(w.getId() + " :: " + w.getSalary());
out.close();
in.close();
}
}
class Worker implements Serializable{
String id;
int salary;
public Worker(String id, int salary) {
this.id = id;
this.salary = salary;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public int getSalary() {
return salary;
}
public void setSalary(int salary) {
this.salary = salary;
}
public int hashCode() {
return this.id.hashCode() + salary*37;
}
public boolean equals(Object obj) {
if(obj instanceof Worker) {
Worker w = (Worker)obj;
return this.id.equals(w.id) && this.salary == w.salary;
}
return false;
}
}
OutputStream
java.lang.Object
|-- java.io.OutputStream
|-- void write(byte[] b) // 将 b.length 个字节从指定的 byte 数组写入此输出流
|-- void write(byte[] b, int off, int len) //将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流。
|-- abstract void write(int b) //将指定的字节写入此输出流。
|-- java.io.ByteArrayOutputStream //此类实现了一个输出流，其中的数据被写入一个 byte 数组,和CharArrayWriter 相似
|-- java.io.FileOutputStream
|-- FileOutputStream(File file)
|-- FileOutputStream(String name)
|-- FileOutputStream(String name, boolean append)
|-- FileOutputStream(File file, boolean append)
|-- java.io.FilterOutputStream
|-- FilterOutputStream(OutputStream out) //构造方法
|-- java.io.BufferedOutputStream
|-- BufferedOutputStream(OutputStream out) //构造方法
|-- java.io.DataOutputStream//数据输出流允许应用程序以适当方式将基本 Java 数据类型写入输出流中。然后，应用程序可以使用数据输入流将数据读入。
|-- DataOutputStream(OutputStream out) //构造方法
|-- java.io.PrintStream
|-- PrintStream(File file) //创建具有指定文件且不带自动行刷新的新打印流。
|-- PrintStream(File file, String csn) //创建具有指定文件名称和字符集且不带自动行刷新的新打印流。
|-- PrintStream(OutputStream out) //创建新的打印流。
|-- PrintStream(OutputStream out, boolean autoFlush, String encoding)
|-- PrintStream(String fileName) // 创建具有指定文件名称且不带自动行刷新的新打印流。
|-- PrintStream(String fileName, String csn) //创建具有指定文件名称和字符集且不带自动行刷新的新打印流
|-- java.io.ObjectOutputStream
|-- ObjectOutputStream() //构造方法
|-- ObjectOutputStream(OutputStream out) //构造方法
|-- void writeObject(Object obj) //将指定的对象写入 ObjectOutputStream。
|-- java.io.PipedOutputStream //可以将管道输出流连接到管道输入流来创建通信管道。管道输出流是管道的发送端
|-- void connect(PipedInputStream snk) //将此管道输出流连接到接收者。
$$ 最后实现图片的复制
扫描二维码关注公众号，回复：
3951766 查看本文章
package com.IO;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class PicCopyTest01 {
public static void main(String[] args) throws IOException {
// TODO Auto-generated method stub
BufferedInputStream in = new BufferedInputStream(new FileInputStream("G:\\图片\\bg.jpg"));
BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream("E:\\Blog\\Pic02.jpg"));
@SuppressWarnings("unused")
int len = 0;
byte[] bt = new byte[1024];
while((len = in.read(bt)) !=- 1) {
out.write(bt);
out.flush();
}
in.close();
out.close();
}
}
**PS：**PipedInputStream、PipedOutputStream、PipedReader、PipedWriter、ObjectInputStream、ObjectOutputStream先不做解释