八、流

1. Java流式输入/输出原理：在Java程序中，对于数据的输入/输出操作以“流” (stream) 方式进行；J2SDK提供了各种各样的“流”类，用以获取不同种类的数据；程序中通过标准的方法输入或输出数据。
2. 输入/输出流的分类
java.io 包中定义了多个流类型(类或抽象类)来实现输入/输出功能；可以从不同的角度对其进行分类：
按数据流的方向不同可以分为输入流和输出流。(以程序的角度来考虑)
按处理数据单位不同可以分为字节流和字符流。
按照功能不同可以分为节点流和处理流。
J2SDK 所提供的所有流类型位于包java.io内都分别继承自以下四种抽象流类型：
[table]
|| ||字节流 ||字符流
||输入流 ||InputStream ||Reader
||输出流 ||OutputStream ||Writer
[/table]
3. InputStream
继承自InputSteam的流都是用于向程序中输入数据，且数据的单位为字节（8 bit）
基本方法：

//读取一个字节并以整数的形式返回(0~255),
//如果返回-1已到输入流的末尾。
int read() throws IOException

//读取一系列字节并存储到一个数组buffer，
//返回实际读取的字节数，如果读取前已到输入流的末尾返回-1
int read(byte[] buffer) throws IOException

//读取length个字节
//并存储到一个字节数组buffer，从off位置开始存,最多len
//返回实际读取的字节数，如果读取前以到输入流的末尾返回-1
int read(byte[] buffer, int off, int len)
                      throws IOException
//关闭流释放内存资源
void close() throws IOException

4. OutputStream
继承自OutputSteam的流是用于程序中输入数据，且数据的单位为字节（8 bit）
基本方法：

//向输出流中写入一个字节数据,该字节数据为参数b的低8位
void write(int b) throws IOException

//将一个字节类型的数组中的数据写入输出流
void write(byte[] b) throws IOException

//将一个字节类型的数组中的从指定位置（off）开始的
//len个字节写入到输出流
void write(byte[] b, int off, int len)
                      throws IOException
//关闭流释放内存资源
void close() throws IOException 

//将输出流中缓冲的数据全部写出到目的地
void flush() throws IOException

5. Reader
继承自Reader的流都是用于向程序中输入数据，且数据的单位为字符（16 bit）
基本方法：

//读取一个字符并以整数的形式返回(0~255),
//如果返回-1已到输入流的末尾。
int read() throws IOException

//读取一系列字符并存储到一个数组buffer，
//返回实际读取的字符数，如果读取前已到输入流的末尾返回-1
int read(char[] cbuf) throws IOException

//读取length个字符
//并存储到一个数组buffer，从off位置开始存,最多读取len
//返回实际读取的字符数，如果读取前以到输入流的末尾返回-1
int read(char[] cbuf, int off, int len)
                      throws IOException
//关闭流释放内存资源
void close() throws IOException

6. Writer
继承自Writer的流都是用于程序中输入数据，且数据的单位为字符（16 bit）
基本方法：

//向输出流中写入一个字符数据,该字节数据为参数b的低16位
void write(int c) throws IOException
//将一个字符类型的数组中的数据写入输出流，
void write(char[] cbuf) throws IOException
//将一个字符类型的数组中的从指定位置（offset）开始的
//length个字符写入到输出流
void write(char[] cbuf, int offset, int length)
                      throws IOException
//将一个字符串中的字符写入到输出流
void write(String string) throws IOException
//将一个字符串从offset开始的length个字符写入到输出流
void write(String string, int offset, int length)
                      throws IOException
//关闭流释放内存资源
void close() throws IOException 
//将输出流中缓冲的数据全部写出到目的地
void flush() throws IOException

7. 节点流类型
[table]
||类 型 ||字 符 流 ||字 节 流
||File（文件） ||FileReader
FileWriter ||FileInputStream
FileOutputStream
||Memory Array ||CharArrayReader
CharArrayWriter ||ByteArrayInputStream
ByteArrayOutputStream
||Memory String ||StringReader
StringWriter ||－
||Pipe（管道） ||PipedReader
PipedWriter ||PipedInputStream
PipedOutputStream
[/table]
8. 处理流类型
[table]
||处理类型 ||字 符 流 ||字 节 流
||Buffering ||BufferedReader
BufferedWriter ||BufferedInputStream
BufferedOutputStream
||Filtering ||FilterReader
FilterWriter ||FilterInputStream
FilterOutputStream
||Converting between bytes and character ||InputStreamReader
OutputStreamWriter ||
||Object Serialization ||－ ||ObjectInputStream
ObjectOutputStream
||Data conversion ||－ ||DataInputStream
DataOutputStream
||Counting ||LineNumberReader ||LineNumberInputStream
||Peeking ahead ||PusbackReader ||PushbackInputStream
||Printing ||PrintWriter ||PrintStream
[/table]

9. 缓冲流
缓冲流要“套接”在相应的节点流之上，对读写的数据提供了缓冲的功能，提高了读写的效率，同时增加了一些新的方法。
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)

BufferedReader提供了readLine方法用于读取一行字符串（以\r或\n分隔）。
BufferedWriter提供了newLine用于写入一个行分隔符。
对于输出的缓冲流，写出的数据会先在内存中缓存，使用flush方法将会使内存中的数据立刻写出。

import java.io.*;
class Test {
  public static void main(String[] args) {
  	BufferedInputStream bis = null;
    try {
      FileInputStream fis = 
              new FileInputStream("D:\\java\\08\\TestFileInputStream.java");
      bis = 
              new BufferedInputStream(fis);
      int c = 0;
      System.out.println((char)bis.read());
      System.out.println((char)bis.read());

      for(int i=0;i<=10 && (c=bis.read())!=-1;i++){
        System.out.print((char)c+" ");
      }
      System.out.println(); 

    } catch (IOException e) {
    	e.printStackTrace();
    } finally {
    	 try {
    	 	if(bis != null) {
    	 		bis.close();
    	 		bis = null;
    	 	}
    	} catch (IOException e) {
    		e.printStackTrace();
    	}
    }
  }
}

10. 转换流
InputStreamReader和OutputStreamWriter用与字节数据到字符数据之间的转换。
InputStreamReader 需要和 InputStream “套接” 。
OutpStreamWriter 需要和 OutputStream “套接” 。
转换流在构造时可以指定其编码集合，例如：

InputStream isr = new InputStreamReader
                         (System.in, “ISO8859_1”)

import java.io.*;
class Test {
  public static void main(String[] args) {
    try {
      //OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("D:\\java\\08\\char.txt"));
      //osw.write("mircosoftibmsunapplehp我们");
      //osw.write("\r\n");
      //源文件-->gbk(ced2)-->字节码文件-->uft8编码(e68891)-->程序运行-->0x6211-->按照gbk编码-->ced2-->硬盘-->ultraedit-->按照gbk解码-->我
      //System.out.println(osw.getEncoding());
      ///osw.close();

      OutputStreamWriter osw = new OutputStreamWriter(
      								new FileOutputStream("D:\\java\\08\\char.txt", true),
      								"ISO8859_1"); // latin1 ascii
      //源文件-->gbk(ced2)-->字节码文件-->uft8编码(e68891)-->程序运行-->0x6211-->按照ISO8859_1编码-->3f-->ultraedit-->按照gbk解码-->?
      osw.write("mircosoftibmsunapplehp我们是共产主义接班人");
      System.out.println(osw.getEncoding());
      osw.close();
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
}

11. 数据流&ByteArrayInputStream&ByteArrayOutputStream
DataInputStream 和 DataOutputStream 分别继承自InputSteam 和 OutputStream，它属于处理流，需要分别“套接”在InputStream 和OutputStream类型的节点流上。
DataInputStream和DataOutputStream提供了可以存取与机器无关的Java原始类型数据（如：int，double 等）的方法。
DataInputStream和DataOutputStream的构造方法为：
DataInputStream ( InputStream in )
DataOutputStream ( OutputStream out )

import java.io.*;
class Test {
  public static void main(String[] args) {
    ByteArrayOutputStream baos = new ByteArrayOutputStream(); 
    DataOutputStream dos = new DataOutputStream(baos);
	try {
		dos.writeDouble(Math.random());
		dos.writeBoolean(true);
		ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
		System.out.println(bais.available());
		DataInputStream dis = new DataInputStream(bais);
		System.out.println(dis.readDouble());
		System.out.println(dis.readBoolean());
		dos.close();  
		dis.close();
	} catch (IOException e) {
		e.printStackTrace();
    }
  }
}

//double d = 2.312421421421;
//double d1 = 23424323423.234345343465;

12. Print 流
PrintWriter和PrintStream 都属于输出流，分别针对与字符和字节。
PrintWriter和PrintStream提供了重载的print
Println方法用于多种数据类型的输出。
PrintWriter和PrintStream的输出操作不会抛出异常，用户通过检测错误状态获取错误信息。
PrintWriter和PrintStream有自动flush功能。

PrintWriter(Writer out)
PrintWriter(Writer out,boolean autoFlush)
PrintWriter(OutputStream out)
PrintWriter(OutputStream out,boolean autoFlush)
PrintStream(OutputStream out)
PrintStream(OutputStream out,booleanautoFlush)

//PrintWriter和PrintStream 都属于输出流，分别针对与字符和字节。
//PrintWriter和PrintStream提供了重载的Println方法用于多种数据类型的输出。
//PrintWriter和PrintStream的输出操作不会抛出异常，用户通过检测错误状态获取错误信息。
//PrintWriter和PrintStream有自动flush功能。

//标准输出可以知道别的输出流去。
import java.io.*;
class Test { 
  public static void main(String[] args) {
    PrintStream ps = null;
    try {
      FileOutputStream fos = 
              new FileOutputStream("D:\\java\\08\\log.dat");
      ps = new PrintStream(fos);
    } catch (IOException e) {
      e.printStackTrace();
    }

    if(ps != null){
      System.setOut(ps);
    }

     System.out.print('中');

  }
}

13. Object流
直接将Object写入或读出
transient关键字
serializable接口
Externalizable 接口
void writeExternal(ObjectOutput out) throws IOException
void readExternal(ObjectInput in) throws IOException, ClassNotFoundException

//Serializable,是一个标记性接口，是给编译器看的
//------------------------------------------------------------------------------
//serialVersionUID为了让该类向后兼容。即在版本升级时反序列化仍保持对象的唯一性。
//你可以随便写一个，在Eclipse中它替你生成一个，有两种生成方式：
//一个是默认的1L，比如：private static final long serialVersionUID = 1L;
//一个是根据类名、接口名、成员方法及属性等来生成一个64位的哈希字段，比如：private static final long serialVersionUID = -8940196742313994740L;之类的。
//------------------------------------------------------------------------------
//transient修饰的成员变量在序列化的时候，不予考虑
//------------------------------------------------------------------------------
//Externalizable 接口：如果想精确控制序列化的过程，应用此接口
//void writeExternal(ObjectOutput?out) throws IOException 
//void readExternal(ObjectInput?in) throws IOException, ClassNotFoundException 
//------------------------------------------------------------------------------
//Serializable虽然没规定具体的方法。但是api里面提到的4个特殊的方法，依然有机会让你控序列化的过程。
//private void writeObject(java.io.ObjectOutputStream out)throws IOException
//private void readObject(java.io.ObjectInputStream in)throws IOException, ClassNotFoundException;
//ANY-ACCESS-MODIFIER Object writeReplace() throws ObjectStreamException;
//ANY-ACCESS-MODIFIER Object readResolve() throws ObjectStreamException;

import java.io.*;

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

		T t = new T();
		t.k = 8;
		FileOutputStream fos = new FileOutputStream("D:\\java\\08\\testobjectio.dat");
		ObjectOutputStream oos = new ObjectOutputStream(fos);
		oos.writeObject(t);
		oos.flush();
		oos.close();

		FileInputStream fis = new FileInputStream("D:\\java\\08\\testobjectio.dat");
		ObjectInputStream ois = new ObjectInputStream(fis);
		T tReaded = (T)ois.readObject();
		//System.out.println(tReaded.i + " " + tReaded.j + " " + tReaded.d + " " + tReaded.k);
		System.out.println(tReaded.i + " " + tReaded.j + " " + tReaded.d + " " + tReaded.k + " " + tReaded.n);

	}
}

class T implements Serializable{

	static final long serialVersionUID = 1L;

	int i = 10;
	int j = 9;
	double d = 2.3;

	int n=15;

	transient int k = 15;
}

14. 访问文件
FileInputStream和FileOutputStream分别继承自InputStream和OutputStream用于向文件中输入和输出字节。
FileInputStream和FileOutputStream的常用构造方法：

FileInputStream(String name) throws FileNotFoundException
FileInputStream(File file)   throws FileNotFoundException
FileOutputStream(String name)throws FileNotFoundException
FileOutputStream(File file)  throws FileNotFoundException
FileOutputStream(File file, boolean append)
                throws FileNotFoundException

FileInputSteam 和 FileOutputStream 类支持其父类InputStream 和OutputStream 所提供的数据读写方法。
注意：
在实例化FileInputStream和FileOutputSteam流时要用try－catch语句以处理其可能抛出的FileNotFoundException。
在读写数据时也要用try－catch语句以处理可能抛出的 IOException。
FileNotFoundException是IOException的子类

FileReader 和 FileWriter 分别继承自Reader和Writer，FileInputSteam与FileOutputStream类似，所不同的时FileReader和FileWriter向文件输入和输出的数据单位为字符。
FileReader和FileWriter的常用构造方法：

public FileWriter(File file) throws IOException
public FileWriter(File file, boolean append) 
                        throws IOException
public FileWriter(String fileName)throws IOException
public FileWriter(String fileName,boolean append)
                        throws IOException
public FileReader(String fileName)
                        throws FileNotFoundException
public FileReader(File file) 
                        throws FileNotFoundException

15. 字符集&编码
字符(Character)：是文字与符号的总称，包括文字、图形符号、数学符号等。
字符集(Charset)：就是一组抽象字符的集合。
字符集常常和一种具体的语言文字对应起来，该文字中的所有字符或者大部分常用字符就构成了该文字的字符集，比如英文字符集。
一组有共同特征的字符也可以组成字符集，比如繁体汉字字符集、日文汉字字符集。
编码(Encoding)：制定编码首先要确定字符集，并将字符集内的字符排序，然后和二进制数字对应起来。根据字符集内字符的多少，会确定用几个字节来编码。
16. 常用字符集
[quote]ASCII American Standard Code for Information Interchange，美国信息交换标准码。在计算机的存储单元中，一个ASCII码值占一个字节(8个二进制位)
ISO/IEC 8859，是国际标准化组织(ISO)及国际电工委员会(IEC)联合制定的一系列8位字符集的标准 . ，iso8859-1编码表示的字符范围很窄，无法表示中文字符
UCS：通用字符集(Universal Character Set，UCS)是由ISO制定的ISO 10646(或称ISO/IEC 10646)标准所定义的字符编码方式，采用4字节编码。
UCS-2： 与unicode的2byte编码基本一样。
UCS-4： 4byte编码, 目前是在UCS-2前加上2个全零的byte。
Unicode：Unicode的编码方式与ISO 10646的通用字符集(Universal Character Set，UCS)概念相对应，目前的用于实用的Unicode版本对应于UCS-2，使用16位的编码空间。也就是每个字符占用2个字节，共可以表示65536个字符。基本满足各种语言的使用。 Unicode字符集有多种编码形式
标准的Unicode称为UTF-16
后来为了双字节的Unicode能够在现存的处理单字节的系统上正确传输，出现了UTF-8，使用类似MBCS的方式对Unicode进行编码。
UTF： Unicode 的实现方式不同于编码方式。一个字符的Unicode编码是确定的，但是在实际传输过程中，由于不同系统平台的设计不一定一致，以及出于节省空间的目的，对Unicode编码的实现方式有所不同。 Unicode的实现方式称为Unicode转换格式(Unicode Translation Format，简称为 UTF)。
UTF-8： 8bit变长编码，对于大多数常用字符集(ASCII中0~127字符)它只使用单字节，而对其它常用字符(特别是朝鲜和汉语会意文字)，它使用3字节。
UTF-16： 16bit编码，大致相当于20位编码，
[/quote]
17. 汉字编码
[quote]GB2312字集是简体字集，全称为GB2312(80)字集，共包括国标简体汉字6763个。
GB2312，正式的名称为MBCS（Multi-Byte Chactacter System，多字节字符系统），通常也称为ANSI字符集。
BIG5字集是台湾繁体字集，共包括国标繁体汉字13053个。
GBK字集是简繁字集，包括了GB字集、BIG5字集和一些符号，共包括21003个字符。
GB18030是国家制定的一个强制性大字集标准，全称为GB18030-2000，它的推出使汉字集有了一个“大一统”的标准。
[/quote]
18. ISO/IEC 8859
[quote]ISO/IEC 8859
 ISO 8859-1 (Latin-1) - 西欧语言 Unicode字符集中覆盖了ISO8859_1
 ISO 8859-2 (Latin-2) - 中欧语言
 ISO 8859-3 (Latin-3) - 南欧语言。世界语也可用此字符集显示。
 ISO 8859-4 (Latin-4) - 北欧语言
 ISO 8859-5 (Cyrillic) - 斯拉夫语言
 ISO 8859-6 (Arabic) - 阿拉伯语
 ISO 8859-7 (Greek) - 希腊语
 ISO 8859-8 (Hebrew) - 希伯来语(视觉顺序)
 ISO 8859-8-I - 希伯来语(逻辑顺序)
 ISO 8859-9 (Latin-5 或 Turkish) - 它把Latin-1的冰岛语字母换走，加入土耳其语字母。
 ISO 8859-10 (Latin-6 或 Nordic) - 北日耳曼语支，用来代替Latin-4。
 ISO 8859-11 (Thai) - 泰语，从泰国的 TIS620 标准字集演化而来。
 ISO 8859-13 (Latin-7 或 Baltic Rim) - 波罗的语族
 ISO 8859-14 (Latin-8 或 Celtic) - 凯尔特语族
 ISO 8859-15 (Latin-9) - 西欧语言，加入Latin-1欠缺的法语及芬兰语重音字母，以及欧元符号。
 ISO 8859-16 (Latin-10) - 东南欧语言。主要供罗马尼亚语使用，并加入欧元符号。

[/quote]
19. 读取utf-8的文件

import java.io.*;
public class TestInputStreamReader {
	public static void main(String[] args) throws Exception{
		FileInputStream   fin=new   FileInputStream("d:\\chartest\\utf-8.txt");   
		InputStreamReader   fileIn=new   InputStreamReader(fin,"UTF-8");   
		BufferedReader   infm=   new   BufferedReader(fileIn);   
		String s = "";
		while(true){  
			s=infm.readLine();
			if(s==null)break;
			System.out.println(s);
		}
	}
}