序言-
第一次写博客，虽然工作1年了，一直没想起来去分享什么，后来听同事说，没事喜欢去写写博客，我觉得，作为一个程序员，应该具备分享精神，所以觉得从基础开始，给刚接触Java的同学，一点点小小i的帮助，也算给自己温故而知新的机会。
下面开始我们的Java学习之旅吧。
IO流
·Java流式输入/输出原理
·Java流类的分类
·输入/输出流类
·常见的节点流和处理流
·文件流
·缓冲流
·转换流
·数据流
·Print流
·Object流
①Java流式输入/输出原理
00101...-->
文件 ------------------ 程序
<-- ...00101
00101...-->
网络连接 ------------------ 程序
程序 ------------------ 程序
00101...--> “Hello”
文件 -----------============== 程序 （从0101等转换为字符，一层包一层）
②流的分类
java.io包中
·按数据流的方向不同可以分为输入流、输出流
·按处理数据单位不同可以分为字节流、字符流
·按照功能不同可以分为节点流、处理流
所有流类型位于包java.io内都分别继承以下四种抽象流类型
字节流 字符流
------------------------------------------
输入流 InputStream Reader
输出流 OutputSteam Writer
字节流（8bit）
|----FileInputStream(节点流)
|
|----PipedInputStream(节点流) |---LineNumberInputStream(处理流)
| |
|----FilterInputStream(处理流)-------|---DataInputStream(处理流)
| |
InputStream -|----ByteArrayInputStream(节点流) |---BufferedInputStream(处理流)
| |---PushbackInputStream(处理流)
|----SequenceInputStream(处理流)
|----StringBufferInputStream(节点流)
|----ObjectInputStream(处理流)
InputStream的基本方法
//读取一个字节并以整数的形式返回（0-255）
//如果返回-1已到输入流的末尾
·int read() throws IOExcetion
//读取一系列字节并存储到一个数组buffer
//返回实际读取的字节数，如果读取器前已到输入流的末尾返回-1
·int read(byre[] buffer) throws IOExcetion
//读取length个字节
//并存储到一个字节数组buffer，从length位置开始
//返回实际读取的字节数，如果读取前已到输入流的末尾返回-1
//buffer - 读入数据的缓冲区。
//offset - 数组 buffer 中将写入数据的初始偏移量。
//length - 要读取的最大字节数。
·int read(byte[] buffer, int offset, int length) throws IOExcetion
//关闭流释放内存资源
·void close() throws IOExcetion
//跳过n个字节不读，返回实际跳过的字节数
·long skip(long n) throws IOExcetion
|----FileOutputStream(节点流)
|----PipedOutputStream(节点流)
|----FilterOutputStream(处理流)-----|---DataOutputStream(处理流)
OutputStream -|----ByteArrayOutputStream(节点流) |---BufferedOutputStream(处理流)
| |---PrintStream(处理流)
|----ObjectOutputStream(处理流)
OutputStream的基本方法
//向输出流中写入一个字节数据，该字节数据为参数b的低8位
·void write(int b) throws IOException
//将一个字节类型的数组中的数据写入输出流
·void write(byre[] b) throws IOException
//将一个字节类型的数组中的从指定位置（off）开始的len个字节写入到输出流
·void write(byre[] b, int off, int len) throws IOException
·void close() throws IOException
//将输出流中缓冲的数据全部写出到目的地
·void flush() throws IOException
注意：先flush，在close
字符流（16bit）
|----BufferedReader(节点流)----LineNumberReader(处理流)
|----CharArrayReader(处理流)
|
|----InputStreamReader(处理流)-----FileReader(节点流)
|
Reader -|----FilterReader(处理流)----PushbackReader(处理流)
|
|----PipedReader(节点流)
|----StringReader(节点流)
Reader的基本方法
//读取一个字符并以整数的形式返回（0-255）
//读取一系列字符并存储到一个数组buffer
//返回实际读取的字符数，如果读取器前已到输入流的末尾返回-1
//读取length个字符
//并存储到一个字符数组buffer，从length位置开始
//返回实际读取的字符数，如果读取前已到输入流的末尾返回-1
//length - 要读取的最大字符数。
//跳过n个字符不读，返回实际跳过的字节数
|----BufferedWriter(处理流)
|----CharArrayWriter(节点流)
|----OutputStreamReader(处理流)-----FileWriter(节点流)
Writer -|----FilterWriter(处理流)
|----PipedWriter(节点流)
|----StringWriter(节点流)
Writer的基本方法
//向输出流中写入一个字符数据，该字节数据为参数b的低8位
//将一个字符类型的数组中的数据写入输出流
·void write(char[] cbuf) throws IOException
//将一个字符类型的数组中的从指定位置（off）开始的len个字符写入到输出流
·void write(char[] cbuf, int off, int len) throws IOException
//将一个字符串中的字符写入到输出流
·void write(String string) throws IOException
//将一个字符串从offset开始的length个字符写入到输出流
·coid write(String string, int offset, int length) throws IOException
③输入/输出流
1、输出流跟输入流
一切以程序为中心
·从文件到程序为输入流
·从程序到文件为输出流
2、字节流和字符流
·字节（8bit）
·字符（16bit）
·一个字符等于2个字节
3、节点流和处理流
·处理流是包在节点流的一层“管道”
④常见的节点流和处理流
·节点流为可以从一个特定的数据源（节点）读写数据（如：文件，内存）
节点流
数据源 -------------------- 程序
·处理流是连接在已存在的流（节点流或处理流）之上，通过对数据的处理为程序提供更为强大的读写功能
-->
数据源 -------======== 程序
<--
程序 ============-------- 数据源
⑤节点流----文件流
字符流 字节流
---------------------------------------
输入流 FileReader FileInputStream
输出流 FileWriter FileOutputStream
访问文件
从文件到程序，输入流
·使用FileInputStream
public class Login{
public static void main(String[] args){
int b = 0;
FileInputStream fis = null;
try {
//连接管道
fis = new FileInputStream("G://Java2014Project//JavaDemo1//src//Demo01/Login.java");
} catch (FileNotFoundException e) {
System.out.println("error");
}
//读取数据
try {
while((b = fis.read())!= -1){
System.out.print((char)(b));
}
fis.close();
} catch (IOException e) {
System.out.println("error");
}
}
}
显示结果
package Demo01;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
public class Login{
//????????
//????????
int num = 0;
发现出现？？？？？，问题是汉字是一个字符（两个字节），用的是字节流，一个字节一个字节读取，
所有中文翻译不出来，改为Reader可以
从程序到文件
·使用FileOutputStream
import java.io.FileOutputStream;
FileOutputStream fot = null;
fot = new FileOutputStream("C://Users//woshishabi//Desktop//test.txt");
fot.write(b);
fot.close();
桌面上多了一个Test.txt文本，
·使用FileReader：字符输入流，从文件到程序
......
·使用FileWriter：字符输出流，从程序到文件
⑥处理流----缓冲流
·缓冲流要“套接”在相应的节点流之上，对读写的数据提供了缓冲的功能，提高了读写的效率，
同时增加了一些新的方法
·J2SDK提供了四种缓存流，其常用的构造方法为：
//字符输入缓冲流
BufferedReader(Reader in)
BufferedReader(Reader in, int sz) //sz为自定义缓存区的大小
//字符输出缓冲流
BufferedWriter(Writer out)
BufferedWriter(Writer out,int sz)
//字节输入缓冲流
BufferedInputStream(InputStream in)
BufferedInputStream(InputStream in, int size)
//字节输出缓冲流
BufferedOutputStream(OutputStream out)
BufferedOutputStream(OutputStream out, int size)
·缓冲输入流支持其父类的mark和reset方法 mark：直接从多少个字符开始读取 reset：回到刚才标记的点
·bufferedReader提供了readline方法用于读取一行字符串（以\r或\n分隔）
·bufferedWriter提供了newLine用于写入一个行分隔符
·对于输出的缓冲流，写出的数据会现在内存中缓存，使用flush方法将会使内存中的数据立刻写出
bufferedReader和bufferedWriter使用
package Demo01;
import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
//从文件写入数据
BufferedReader br = new BufferedReader(new FileReader("G://Java2014Project//JavaDemo1//src//Demo01//Login.java"));
BufferedWriter bw = new BufferedWriter(new FileWriter("C://Users//woshishabi//Desktop//Test.txt"));
//从文件读取数据
String s = null;
while((s = br.readLine()) != null){
System.out.println(s);
bw.write(s);
bw.newLine();
bw.flush();
br.close();
bw.close();
catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
⑦处理流----转换流
·InputStreamReader和OutputStreamWriter用与字节数据到字符数据之间的转换
·InputStreamReader需要和InputStream“套接”
·OutputStream需要和OutputStream“套接”
·转换流在构造时可以指定其编码集合，例如
InputStream isr = new InputStreamReader(System.in, "ISO8859_1");
范例：OutputStreamWriter
import java.io.OutputStreamWriter;
//将输出字节流转换为字符流
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("C://Users//woshishabi//Desktop//Test.txt"));
//向文件中输入字符串
osw.write("sdfjaksldjflskdjflaskdjfsakjdf");
//读取字符编码
System.out.println(osw.getEncoding());
osw.close();
//在文本后面添加字符串，不覆盖，则true，否则写false， 后面可以自定义编码
osw = new OutputStreamWriter(new FileOutputStream("C://Users//woshishabi//Desktop//Test.txt", true), "UTF-8");
osw.write("qwqeqweqweqeq");
// TODO Auto-generated catch block
e.printStackTrace();
范例：InputStreamReader
import java.io.InputStreamReader;
//从键盘读取数据
InputStreamReader isr = new InputStreamReader(System.in);
//字符输入缓冲流
BufferedReader br = new BufferedReader(isr);
String s = null;
//读取一行字符
s = br.readLine();
while(s != null){
if(s.equalsIgnoreCase("exit")){ //将一个字符串与另一个字符串比较，不考虑大小写
break;
//将小写转换为大写
System.out.println(s.toUpperCase());
s = br.readLine();
catch (IOException e) {
⑧数据流----DataInputStream...
·DataInputStream 和 DataOutputStream 分别继承了InputStream 和 OutputStream，属于处理流，
需要分别套接在InputStream 和 OutputStream类型的节点流觞
·DataInputStream 和 DataOutputStream 提供了可以存取与机器无关的Java原始数据类型（int、double等）
的方法
·DataInputStream 和 DataOutputStream 的构造方法为：
·DataInputStream（InputStream in）
·DataOutputStream（OutputStream out）
范例：使用DataInputStream 和 DataOutputStream
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
//一个字节数组输出流
ByteArrayOutputStream baos = new ByteArrayOutputStream();
//在字节数组输出流上套接一个数据流，能传递基本数据类型
DataOutputStream dos = new DataOutputStream(baos);
//向字节数组写入一个随机数
dos.writeDouble(Math.random());
dos.writeBoolean(true);
//创建一个字节数组输入流
ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
//输出字节数组中有多少个字节
System.out.println(bais.available());
//将处理流包在字节数组输入流上，输出基本数据
DataInputStream dis = new DataInputStream(bais);
//输出double，先输入的先输出
System.out.println(dis.readDouble());
//输出boolean
System.out.println(dis.readBoolean());
dos.close();
dis.close();
} catch (IOException e) {
⑨print流 PrintStream主要操作byte流，而PrintWriter用来操作字符流
·PrintWriter 和 PrintStream都属于输出流，分别针对与字符和字节
·PrintWriter 和 PrintStream提供了重载的print
·Println方法用于多种数据类型的输出
·PrintWriter 和 PrintStream的输出操作不会抛出异常，用户通过检测错误状态获取错误信息
·PrintWriter 和 PrintStream有自动flush功能
构造方法：
·PrintWriter(Writer out)
·PrintWriter(Writer out，boolean autoFlush)
·PrintWriter(OutputStream out， boolean autoFlush)
·PrintStream(OutputStream out)
·PrintStream(OutputStream out， boolean autoFlush)
范例：PrintStream
import java.io.PrintStream;
PrintStream ps = null;
//文件字节输出流
FileOutputStream fos = new FileOutputStream("C://Users//woshishabi//Desktop//Test.txt");
//输出流
ps = new PrintStream(fos);
if(ps != null){
//使system.out指向了文件Test.txt
System.setOut(ps);
for (int i = 0; i < 100; i++) {
System.out.print(i + ",");
范例：PrintWriter
import java.io.PrintWriter;
import java.util.Date;
//从键盘输入，字节转字符的转换流上套接缓冲流
BufferedReader bis = new BufferedReader(new InputStreamReader(System.in));
//输出流，输出到文件，不覆盖
FileWriter fw = new FileWriter("C://Users//woshishabi//Desktop//Test.txt",true);
//输出流，套接在文件输出流上
PrintWriter pw = new PrintWriter(fw);
//接收键盘输入的一行数据，
while((s = bis.readLine()) != null){
//判断是否为exit，是则结束while
if(s.equalsIgnoreCase("exit"))break;
//小写转大写，在dos中输出
//在目标文件里面输出数据
pw.println("------");
pw.println(s.toLowerCase());
pw.flush();
//在目标文件中输出日期
pw.println("-----"+ new Date() + "------");
pw.flush();
pw.close();
⑩Object流
·直接将Object写入或读出
·transient关键字（透明的）：修饰属性， transient int k = 15; 输出结果k = 0；在序列化的时候不考虑，不写入硬盘
·serializable接口：（标记性接口，里面什么都没有）
·extemalizable接口：
注意：如果需要使用对象流，必须实现serializable接口
范例：
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
T t = new T();
t.k = 40;
//文件输出流，
//在文件输出流上套接一个对象输出流，从程序传递一个对象到目标文件中
ObjectOutputStream oos = new ObjectOutputStream(fos);
//写入对象
oos.writeObject(t);
//文件输入流，锁定目标文件
FileInputStream fis = new FileInputStream("C://Users//woshishabi//Desktop//Test.txt");
//在文件输入流上套接一个对象输入流，从目标文件中取出对象的通道
ObjectInputStream ois = new ObjectInputStream(fis);
//取出对象
T t1 = (T) ois.readObject();
//打印到屏幕上
System.out.println(t1.i + " " + t1.j + " " + t1.k + " " + t1.z);
} catch (ClassNotFoundException e) {
catch (IOException e) {
class T implements Serializable{
int i = 1;
int j = 2;
double z = 9.0;
int k = 14;
总结：
·InputStream/OutputStream
·Reader/Writer
·FileInputStream/FileoutputStream
·FileReader/FileWriter
·BufferedInputStream/BufferedOutoutStream
·BufferedTeader/BufferedWriter
·ByteArrayInputStream/ByteArrayOutputStream
·InputStreamReader/OutputStreamWriter
·DataInputStream/DataOutputStream
·PrintStream/PrintWriter
·ObjectInputStream/ObjectOutputStream