java IO

 Java 流在处理上分为字符流和字节流。字符流处理的单元为 2 个字节的 Unicode 字符，分别操作字符、字符数组或字符串，而字节流处理单元为 1 个字节，操作字节和字节数组。

Java 内用 Unicode 编码存储字符，字符流处理类负责将外部的其他编码的字符流和 java 内 Unicode 字符流之间的转换。而类 InputStreamReader 和 OutputStreamWriter 处理字符流和字节流的转换。字符流（一次可以处理一个缓冲区）一次操作比字节流（一次一个字节）效率高。 

 

( 一 )以字节为导向的 stream------InputStream/OutputStream

InputStream 和 OutputStream 是两个 abstact 类，对于字节为导向的 stream 都扩展这两个鸡肋（基类 ^_^ ） ;

1、 InputStream

 

 

1.1

ByteArrayInputStream -- 把内存中的一个缓冲区作为 InputStream 使用 .

construct---

(A)ByteArrayInputStream(byte[]) 创建一个新字节数组输入流（ ByteArrayInputStream ），它从指定字节数组中读取数据（ 使用 byte 作为其缓冲区数组）

(B)---ByteArrayInputStream(byte[], int, int) 创建一个新字节数组输入流，它从指定字节数组中读取数据。

---mark:: 该字节数组未被复制。

1.2

StringBufferInputStream -- 把一个 String 对象作为 InputStream .

construct---  

StringBufferInputStream(String) 据指定串创建一个读取数据的输入流串。

 

注释：不推荐使用 StringBufferInputStream 方法。 此类不能将字符正确的转换为字节。

同 JDK 1.1 版中的类似，从一个串创建一个流的最佳方法是采用 StringReader 类。

1.3

FileInputStream -- 把一个文件作为 InputStream ，实现对文件的读取操作

construct---

(A)FileInputStream(File name) 创建一个输入文件流，从指定的 File 对象读取数据。

(B)FileInputStream(FileDescriptor) 创建一个输入文件流，从指定的文件描述器读取数据。

(C)-FileInputStream(String  name) 创建一个输入文件流，从指定名称的文件读取数据。

method ---- read() 从当前输入流中读取一字节数据。

read(byte[]) 将当前输入流中 b.length 个字节数据读到一个字节数组中。

read(byte[], int, int) 将输入流中 len 个字节数据读入一个字节数组中。

1.4

PipedInputStream ：实现了 pipe 的概念，主要在线程中使用 . 管道输入流是指一个通讯管道的接收端。

一个线程通过管道输出流发送数据，而另一个线程通过管道输入流读取数据，这样可实现两个线程间的通讯。

construct---

PipedInputStream() 创建一个管道输入流，它还未与一个管道输出流连接。

PipedInputStream(PipedOutputStream) 创建一个管道输入流 , 它已连接到一个管道输出流。

1.5

SequenceInputStream ：把多个 InputStream 合并为一个 InputStream . “序列输入流”类允许应用程序把几个输入流连续地合并起来，

并且使它们像单个输入流一样出现。每个输入流依次被读取，直到到达该流的末尾。

然后“序列输入流”类关闭这个流并自动地切换到下一个输入流。

construct---

SequenceInputStream(Enumeration) 创建一个新的序列输入流，并用指定的输入流的枚举值初始化它。

SequenceInputStream(InputStream, InputStream) 创建一个新的序列输入流，初始化为首先 读输入流 s1, 然后读输入流 s2 。

 

2、 OutputSteam

 

 
2.1

ByteArrayOutputStream ： 把信息存入内存中的一个缓冲区中 . 该类实现一个以字节数组形式写入数据的输出流。

当数据写入缓冲区时，它自动扩大。用 toByteArray() 和 toString() 能检索数据。

constructor

(A)--- ByteArrayOutputStream() 创建一个新的字节数组输出流。

(B)--- ByteArrayOutputStream() 创建一个新的字节数组输出流。

(C)--- ByteArrayOutputStream(int) 创建一个新的字节数组输出流，并带有指定大小字节的缓冲区容量。

toString(String) 根据指定字符编码将缓冲区内容转换为字符串，并将字节转换为字符。

write(byte[], int, int) 将指定字节数组中从偏移量 off 开始的 len 个字节写入该字节数组输出流。

write(int) 将指定字节写入该字节数组输出流。

writeTo(OutputStream) 用 out.write(buf, 0, count) 调用输出流的写方法将该字节数组输出流的全部内容写入指定的输出流参数。

2.2  

FileOutputStream: 文件输出流是向 File 或 FileDescriptor 输出数据的一个输出流。

constructor

(A)FileOutputStream(File  name) 创建一个文件输出流，向指定的 File 对象输出数据。

(B)FileOutputStream(FileDescriptor) 创建一个文件输出流，向指定的文件描述器输出数据。

(C)FileOutputStream(String  name) 创建一个文件输出流，向指定名称的文件输出数据。

(D)FileOutputStream(String, boolean) 用指定系统的文件名，创建一个输出文件。

2.3

PipedOutputStream: 管道输出流是指一个通讯管道的发送端。 一个线程通过管道输出流发送数据，

而另一个线程通过管道输入流读取数据，这样可实现两个线程间的通讯。

constructor

(A)PipedOutputStream() 创建一个管道输出流，它还未与一个管道输入流连接。

(B)PipedOutputStream(PipedInputStream) 创建一个管道输出流，它已连接到一个管道输入流。

 

( 二 )以字符为导向的 stream Reader/Writer

以 Unicode 字符为导向的 stream ，表示以 Unicode 字符为单位从 stream 中读取或往 stream 中写入信息。

Reader/Writer 为 abstact 类

以 Unicode 字符为导向的 stream 包括下面几种类型：

1. Reader

 

 

1.1

  CharArrayReader ：与 ByteArrayInputStream 对应此类实现一个可用作字符输入流的字符缓冲区

constructor

CharArrayReader(char[]) 用指定字符数组创建一个 CharArrayReader 。

CharArrayReader(char[], int, int) 用指定字符数组创建一个 CharArrayReader

1.2

StringReader ： 与 StringBufferInputStream 对应其源为一个字符串的字符流。

StringReader(String) 创建一新的串读取者。

1.3

FileReader ： 与 FileInputStream 对应

1.4

PipedReader ：与 PipedInputStream 对应

 

2.  Writer

 

2.1    CharArrayWrite ： 与 ByteArrayOutputStream 对应

2.2   StringWrite ：无与之对应的以字节为导向的 stream

2.3  FileWrite ： 与 FileOutputStream 对应

2.4  PipedWrite ：与 PipedOutputStream 对应

 

3、两种不同导向的 stream 之间的转换  

3.1

InputStreamReader 和 OutputStreamReader ：

把一个以字节为导向的 stream 转换成一个以字符为导向的 stream 。

InputStreamReader 类是从字节流到字符流的桥梁：它读入字节，并根据指定的编码方式，将之转换为字符流。

使用的编码方式可能由名称指定，或平台可接受的缺省编码方式。

InputStreamReader 的 read() 方法之一的每次调用，可能促使从基本字节输入流中读取一个或多个字节。

为了达到更高效率，考虑用 BufferedReader 封装 InputStreamReader ，

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

例如： // 实现从键盘输入一个整数

1. String s = null;             
2. InputStreamReader re = new InputStreamReader(System.in);  
3.               BufferedReader br = new BufferedReader(re);  
4.               try {  
5.               s = br.readLine();  
6.               System.out.println("s= " + Integer.parseInt(s));  
7.               br.close();  
8.               }  
9.               catch (IOException e)  
10.               {  
11.               e.printStackTrace();  
12.               }  
13.               catch (NumberFormatException e)// 当应用程序试图将字符串转换成一种数值类型，但该字符串不能转换为适当格式时，抛出该异常。  
14.               {  
15.               System.out.println(" 输入的不是数字 ");  
16.               }  

InputStreamReader(InputStream) 用缺省的字符编码方式，创建一个 InputStreamReader 。

InputStreamReader(InputStream, String) 用已命名的字符编码方式，创建一个 InputStreamReader 。

 

OutputStreamWriter 将多个字符写入到一个输出流，根据指定的字符编码将多个字符转换为字节。

每个 OutputStreamWriter 合并它自己的 CharToByteConverter, 因而是从字符流到字节流的桥梁。

 

（三）Java IO 的一般使用原则 ：  

一、按数据来源（去向）分类：

1 、是文件： FileInputStream, FileOutputStream, ( 字节流 )FileReader, FileWriter( 字符 )

2 、是 byte[] ： ByteArrayInputStream, ByteArrayOutputStream( 字节流 )

3 、是 Char[]: CharArrayReader, CharArrayWriter( 字符流 )

4 、是 String: StringBufferInputStream, StringBufferOuputStream ( 字节流 )StringReader, StringWriter( 字符流 )

5 、网络数据流： InputStream, OutputStream,( 字节流 ) Reader, Writer( 字符流 )

二、按是否格式化输出分：

1 、要格式化输出： PrintStream, PrintWriter

三、按是否要缓冲分：

1 、要缓冲： BufferedInputStream, BufferedOutputStream,( 字节流 ) BufferedReader, BufferedWriter( 字符流 )

四、按数据格式分：

1 、二进制格式（只要不能确定是纯文本的） : InputStream, OutputStream 及其所有带 Stream 结束的子类

2 、纯文本格式（含纯英文与汉字或其他编码方式）； Reader, Writer 及其所有带 Reader, Writer 的子类

五、按输入输出分：

1 、输入： Reader, InputStream 类型的子类

2 、输出： Writer, OutputStream 类型的子类

六、特殊需要：

1 、从 Stream 到 Reader,Writer 的转换类： InputStreamReader, OutputStreamWriter

2 、对象输入输出： ObjectInputStream, ObjectOutputStream

3 、进程间通信： PipeInputStream, PipeOutputStream, PipeReader, PipeWriter

4 、合并输入： SequenceInputStream

5 、更特殊的需要： PushbackInputStream, PushbackReader, LineNumberInputStream, LineNumberReader

决定使用哪个类以及它的构造进程的一般准则如下（不考虑特殊需要）：

首先，考虑最原始的数据格式是什么： 原则四

第二，是输入还是输出：原则五

第三，是否需要转换流：原则六第 1 点

第四，数据来源（去向）是什么：原则一

第五，是否要缓冲：原则三 （特别注明：一定要注意的是 readLine() 是否有定义，有什么比 read, write 更特殊的输入或输出方法）

第六，是否要格式化输出：原则二

转载http://blog.csdn.net/ilibaba/article/details/3955799

一、IO流的三种分类方式

    1.按流的方向分为：输入流和输出流

    2.按流的数据单位不同分为：字节流和字符流

    3.按流的功能不同分为：节点流和处理流

    二、IO流的四大抽象类：

    字符流：Reader Writer

    字节流：InputStream（读数据）OutputStream（写数据）

    总结：带Stream的就是字节流

    三、InputStream的基本方法

    int read（） throws IOException 读取一个字节以整数形式返回，如果返回-1已到输入流的末尾

   所以一般我们读取的方式为如下两种：

  （1）循环读取每个字节并显示

    FileInputStream fis=new FileInputSteam("xxx文件名");

    int i=0;

    while((i=fis.read())!=-1)

     {

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

     }

     fis.close();

   （2）将读取的内容放入一内存区内

     FileInputStream fis=new FileInputSteam("xxx文件名");

     char[] c=new char[100];

     fis.read(c);

     System.out.println(c);

     fis.close();

    void close（） throws IOException 关闭流释放内存资源

    long skip（long n） throws IOException 跳过n个字节不读

    四、OutputStream的基本方法

    void write（int b） throws IOException 向输出流写入一个字节数据

    为了能够一次让文件中写入字符串，一般采用如下方法：

    FileOutputStream fos=new FileOutputStream("xxx文件名");

    fos.write("hello world!".getBytes());

    fos.flush();

    fos.close();

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

    五、Writer的基本方法

    void write（int c） throws IOException 向输出流写入一个字符数据

    void write（String str） throws IOException将一个字符串中的字符写入到输出流

    void write（String str，int offset，int length）

    将一个字符串从offset开始的length个字符写入到输出流

    void flush（） throws IOException

    将输出流中缓冲的数据全部写出到目的地

    六、Reader的基本方法

    int read（） throws IOException 读取一个字符以整数形式返回，如果返回-1已到输入流的末尾

    七、节点流类型

    八、访问文件之FileInputStream和FileOutputStream继承基类用于向文件中输入输出字节

    九、访问文件之FileReader和FileWriter继承基类用于向文件中输入输出字符

十、缓冲流：缓冲流要套接在相应的节点流之上，提高了读写的效率。

    此处理流的构造方法都得传相对应的基类类型

    BufferedReader：提供了readLine方法用于高校读取一行字符串

    BufferedWriter：提供了newLine用于写入一个行分隔符也就是换行

    其他方法提供的读取是read，而BufferedReader提供的读取方法时readLine。

    BufferedInputStream 没多大用处

    BufferedOutputStream 没多大用处

    十一、转换流：主要作用将字节流转换成字符流。用处较大！

    转换流在构造时可以指定其编码集合

    InputStreamReader需要和InputStream套接

    OutputStreamWriter需要和OutputStream套接

    例：OutputStreamWriter osw = new OutputStreamWriter （new FileOutputStream（文件路径）；

    方法例：osw.getEncoding（）； 获得流的编码方式

    十二、数据流与字节数组流：

    数据流主要为实现可以存取Java原始数据类型如long，boolean

    DataInputStream和DataOutputStream主要是完成对基本数据类型的操作。

    数据流是字节流

    DataInputStream需要和InputStream套接

    DataOutputStream需要和OutputStream套接

    DataInputStream方法：readBoolean（） readInt（） read……（）……

    readUTF（）：网络传输常用方法 读一个Unicode字符串

    DataOutputStream方法与DataInputStream基本对应为写的方法

    //此构造函数等于已可以往一个字节数组里输入内容

    ByteArrayOutputStream baos = new ByteArrayOutputStream （）；

    //此方法为获取一个字节数组方法返回字节数组

    baos.toByteArray（）；

    //此方法获取字节数组占了多少字节

    new ByteArrayInputStream（一个字节数组）。available（）

 1ByteArrayOutputStream baos =
 2                        new ByteArrayOutputStream();
 3    DataOutputStream dos =
 4                        new DataOutputStream(baos);
 5    try {
 6      dos.writeDouble(Math.random());
 7      dos.writeBoolean(true);
 8      ByteArrayInputStream bais =
 9          new ByteArrayInputStream(baos.toByteArray());
10      System.out.println(bais.available());
11      DataInputStream dis = new DataInputStream(bais);
12      System.out.println(dis.readDouble());
13      System.out.println(dis.readBoolean());
14      dos.close();  dis.close();
15    } catch (IOException e) {
16      e.printStackTrace();
17    }

    十二、Print流

    Print流只有输出流无输入流，PrintWriter和PrintStream分别针对字符字节

    两个类提供了重载的Print和Println方法用于多种数据类型的输出

    PrintWriter和PrintStream的输出操作不会抛出异常

    PrintWriter和PrintStream有自动flush功能

    ----System.setOut(接收OutputStream类):用于设置系统默认输出流

    十二、Object流

    等同于c#序列化，用直接将Object写入或读出

    transient关键字为不序列化此成员变量

    需要序列化的类必须实现Serializable接口

    主要方法：writeObject（Object）； readObject（）；

    读出为Object类型需要强转数据类型

 1 import java.io.*;
 2
 3 public class TestObjectIO {
 4     public static void main(String args[]) throws Exception {
 5         T t = new T();
 6         t.k = 8;
 7         FileOutputStream fos = new FileOutputStream("d:/share/java/io/testobjectio.dat");
 8         ObjectOutputStream oos = new ObjectOutputStream(fos);
 9         oos.writeObject(t);
10         oos.flush();
11         oos.close();
12        
13         FileInputStream fis = new FileInputStream("d:/share/java/io/testobjectio.dat");
14         ObjectInputStream ois = new ObjectInputStream(fis);
15         T tReaded = (T)ois.readObject();
16         System.out.println(tReaded.i + " " + tReaded.j + " " + tReaded.d + " " + tReaded.k);
17        
18     }
19 }
20
21 class T
22     implements Serializable
23 {
24     int i = 10;
25     int j = 9;
26     double d = 2.3;
27     transient int k = 15;
28 }

 

 

下面给出几个实例，可以加深对流操作的理解。

一、读取文件内容并显示：(InputStream)

FileInputStream fis=new FileInputStream("d:\\test\\xh.txt");

byte[] bt=new byte[130];

fis.read(bt);

System.out.println(new String(bt).trim());

fis.close();

二、 往文件中写入内容(OutputSteam)

FileOutputStream fos=new FileOutputStream("d:\\test\\xh.txt");

fos.write("我爱南昌".getBytes());

fos.flush();

fos.close();

三、读取文件内容并显示：(FileReader)

FileReader fr=new FileReader("d:\\test\\xh.txt");

char[] c=new char[100];

fr.read(c);

System.out.println(new String(c).trim());

fr.close();

四、 往文件中写入内容(FileWriter)

FileWriter fw=new FileWriter("d:\\test\\xh.txt");

fw.write("我爱南昌大学！");

fw.close();

五、 使用BufferedReader读取文件内容(FileReader)

BufferedReader br=new BufferedReader(new FileReader("d:\\test\\xh.txt"));

String str=null;

while((str=br.readLine())!=null)

{

    System.out.println(str);

}

br.close();

六、 使用BufferedWriter往文件中写入内容(FileWriter)

BufferedWriter bw=new BufferedWriter(new FileWriter("d:\\test\\xh.txt"));

bw.write("我爱南昌大学的 美女 ！");

bw.write("美女啊 ".toCharArray());

bw.flush();

bw.close();

七、 使用InputStreamReader读取文件内容

InputStreamReader isr=new InputStreamReader(new FileInputStream("d:\\test\\xh.txt"));

char[] c=new char[100];

isr.read(c);

System.out.println(new String(c).trim());

isr.close();

八、 使用OutputStreamWriter往文件中写入内容

OutputStreamWriter osr=new OutputStreamWriter(new FileOutputStream("d:\\test\\xh.txt"));

osr.write("南昌大学");

osr.flush();

osr.close();

九、 使用PrintWriter往文件中写入内容

PrintWriter pw=new PrintWriter("d:\\test\\xh.txt");

pw.write("你好");

pw.close();

十、使用StringReader读取字符串的内容

BufferedReader br=new BufferedReader(new StringReader("我是中国人！"));

System.out.println(br.readLine());

br.close();

转载 http://blog.sina.com.cn/s/blog_628cc2b70100ryi2.html