java学习笔记-io流浅析与实例

Java中的流，可以从不同的角度进行分类。

按照数据流的方向不同可以分为：输入流和输出流。

按照处理数据单位不同可以分为：字节流和字符流。

按照实现功能不同可以分为：节点流和处理流。

 

输出流：

 

输入流：

因此输入和输出都是从程序的角度来说的。

字节流：一次读入或读出是8位二进制。

字符流：一次读入或读出是16位二进制。

字节流和字符流的原理是相同的，只不过处理的单位不同而已。后缀是Stream是字节流，而后缀是Reader，Writer是字符流。

 

节点流：直接与数据源相连，读入或读出。

直接使用节点流，读写不方便，为了更快的读写文件，才有了处理流。

处理流：与节点流一块使用，在节点流的基础上，再套接一层，套接在节点流上的就是处理流。

Jdk提供的流继承了四大类：InputStream(字节输入流)，OutputStream（字节输出流），Reader（字符输入流），Writer（字符输出流）。

以下是java中io中常用的流。

 

字节输入流：

字节输出流：

字符输入流：

字符输出流：

简单介绍其上图：

对文件进行操作：FileInputStream（字节输入流），FileOutputStream（字节输出流），FileReader（字符输入流），FileWriter（字符输出流）

对管道进行操作：PipedInputStream（字节输入流）,PipedOutStream（字节输出流），PipedReader（字符输入流），PipedWriter（字符输出流）

PipedInputStream的一个实例要和PipedOutputStream的一个实例共同使用，共同完成管道的读取写入操作。主要用于线程操作。

字节/字符数组：ByteArrayInputStream，ByteArrayOutputStream，CharArrayReader，CharArrayWriter是在内存中开辟了一个字节或字符数组。

Buffered缓冲流：：BufferedInputStream，BufferedOutputStream，BufferedReader,BufferedWriter,是带缓冲区的处理流，缓冲区的作用的主要目的是：避免每次和硬盘打交道，提高数据访问的效率。

转化流：InputStreamReader/OutputStreamWriter，把字节转化成字符。

数据流：DataInputStream，DataOutputStream。

因为平时若是我们输出一个8个字节的long类型或4个字节的float类型，那怎么办呢？可以一个字节一个字节输出，也可以把转换成字符串输出，但是这样转换费时间，若是直接输出该多好啊，因此这个数据流就解决了我们输出数据类型的困难。数据流可以直接输出float类型或long类型，提高了数据读写的效率。

打印流：printStream，printWriter，一般是打印到控制台，可以进行控制打印的地方。

对象流：ObjectInputStream，ObjectOutputStream，把封装的对象直接输出，而不是一个个在转换成字符串再输出。

序列化流：SequenceInputStream。

对象序列化：把对象直接转换成二进制，写入介质中。

使用对象流需要实现Serializable接口，否则会报错。而若用transient关键字修饰成员变量，不写入该成员变量，若是引用类型的成员变量为null，值类型的成员变量为0.

字节流，一般用于处理二进制数据，包括图片，视频，音频等

[java] view plain copy

1. package com.javaio.myinputstream;  
2.   
3. import java.io.BufferedInputStream;  
4. import java.io.BufferedOutputStream;  
5. import java.io.FileInputStream;  
6. import java.io.FileOutputStream;  
7. import java.io.IOException;  
8.   
9. public class MyFileStream {  
10.     public static void main(String argv[]) {  
11.         try {  
12.         FileInputStream fis = null;  
13.         FileOutputStream fos = null;  
14.         BufferedInputStream bis = null;  
15.         BufferedOutputStream bos = null;  
16.         fis = new FileInputStream("D:/me.png");  
17.         fos = new FileOutputStream("D:/me-bak.png");  
18.         if (fis != null && fos != null) {  
19.             bis = new BufferedInputStream(fis);  
20.             bos = new BufferedOutputStream(fos);  
21.         }  
22.           
23.         int tmp = -1;  
24.         while((tmp = bis.read()) != -1) {  
25.             bos.write(tmp);  
26.         }  
27.         bos.flush();  
28.           
29.         fis.close();  
30.         fos.close();  
31.           
32.         } catch (IOException e) {  
33.             e.printStackTrace();  
34.         }  
35.     }  
36. }  

字符流，一般用于处理文本，字符串等

[java] view plain copy

1. package com.javaio.myinputstream;  
2.   
3. import java.io.BufferedReader;  
4. import java.io.BufferedWriter;  
5. import java.io.FileReader;  
6. import java.io.FileWriter;  
7. import java.io.IOException;  
8.   
9. public class MyFileRW {  
10.     public static void main(String argv[]) {  
11.   
12.         try {  
13.             FileReader fr = null;  
14.             FileWriter fw = null;  
15.             BufferedReader br = null;  
16.             BufferedWriter bw = null;  
17.               
18.             fr = new FileReader("D:/server.java");  
19.             fw = new FileWriter("D:/server-bak.java");  
20.               
21.             if (fr != null && fw != null) {  
22.                 br = new BufferedReader(fr);  
23.                 bw = new BufferedWriter(fw);  
24.                   
25.                 String line = null;  
26.                 while((line = br.readLine()) != null) {  
27.                     bw.write(line);  
28.                     bw.newLine();  
29.                 }  
30.             }  
31.             bw.flush();  
32.               
33.             fr.close();  
34.             fw.close();  
35.               
36.         } catch (IOException e) {  
37.             e.printStackTrace();  
38.         }  
39.     }  
40. } 
    

IO 编程的一般流程:

    1. 创建基本流

    2. 升级基本流到高级流

    3. 使用在高级流中的方法作读写操作

    4. 关闭流并释放资源

-------------------------------------------------------------------------------

    1. Creat node stream;

    2. Upgrade node stream to processing stream if necessary

    3. Use the methods in the stream object to read or write

    4. Close the stream and release the resource

------------------------------------------------------------------------------

    1. Create InputStream/Reader

    2. Upgrade to Buffered

    3. Use readLine()

       While((str=in.readln())!=null)

    4. close()

------------------------------------------------------------------------------

    1. Create OutputStream/Writer

    2. Upgrade to PrintWriter

    3. Use println()

    4. close()

 

//1.以行为单位从一个文件读取数据
BufferedReader in =
new BufferedReader(
new FileReader("F:\\nepalon\\TestIO.java"));
String s, s2 = new String();
while((s = in.readLine()) != null)
s2 += s + "\n";
in.close();

//2. 接收键盘的输入
BufferedReader stdin =
new BufferedReader(
new InputStreamReader(System.in));
System.out.println("Enter a line:");
System.out.println(stdin.readLine());

//3. 从一个String对象中读取数据
StringReader in2 = new StringReader(s2);
int c;
while((c = in2.read()) != -1)
System.out.println((char)c);
in2.close();

 

//4. 从内存取出格式化输入
try{
DataInputStream in3 =
new DataInputStream(
new ByteArrayInputStream(s2.getBytes()));
while(true)
System.out.println((char)in3.readByte());
}
catch(EOFException e){
System.out.println("End of stream");
}

//5. 输出到文件
try{
BufferedReader in4 = new BufferedReader(new StringReader(s2));
PrintWriter out1 =
new PrintWriter(
new BufferedWriter(
new FileWriter("F:\\nepalon\\ TestIO.out")));
int lineCount = 1;
while((s = in4.readLine()) != null)
out1.println(lineCount++ + "：" + s);
out1.close();
in4.close();
}
catch(EOFException ex){
System.out.println("End of stream");
}

//6. 数据的 存储 和恢复
try{
DataOutputStream out2 =
new DataOutputStream(
new BufferedOutputStream(
new FileOutputStream("F:\\nepalon\\ Data.txt")));
out2.writeDouble(3.1415926);
out2.writeChars("\nThas was pi:writeChars\n");
out2.writeBytes("Thas was pi:writeByte\n");
out2.close();
DataInputStream in5 =
new DataInputStream(
new BufferedInputStream(
new FileInputStream("F:\\nepalon\\ Data.txt")));
BufferedReader in5br =
new BufferedReader(
new InputStreamReader(in5));
System.out.println(in5.readDouble());
System.out.println(in5br.readLine());
System.out.println(in5br.readLine());
}
catch(EOFException e){
System.out.println("End of stream");
}

//7. 通过RandomAccessFile操作文件
RandomAccessFile rf =
new RandomAccessFile("F:\\nepalon\\ rtest.dat", "rw");
for(int i=0; i<10; i++)
rf.writeDouble(i*1.414);
rf.close();

rf = new RandomAccessFile("F:\\nepalon\\ rtest.dat", "r");
for(int i=0; i<10; i++)
System.out.println("Value " + i + "：" + rf.readDouble());
rf.close();

rf = new RandomAccessFile("F:\\nepalon\\ rtest.dat", "rw");
rf.seek(5*8);
rf.writeDouble(47.0001);
rf.close();

rf = new RandomAccessFile("F:\\nepalon\\ rtest.dat", "r");
for(int i=0; i<10; i++)
System.out.println("Value " + i + "：" + rf.readDouble());
rf.close();
}
}