BufferedReader、DataInputStream



BufferedReader的用法(分享)

public class BufferdReader extends Reader
从字符输入流中读取文本，缓冲各个字符，从而提供字符、数组和行的高效读取。

通常，Reader 所作的每个读取请求都会导致对基础字符或字节流进行相应的读取请求。因此，建议用 BufferedReader 包装所有其 read() 操作可能开销很高的 Reader（如 FileReader 和 InputStreamReader）。例如，

BufferedReader in= new BufferedReader(new FileReader("foo.in"));
将缓冲指定文件的输入。如果没有缓冲，则每次调用 read() 或 readLine() 都会导致从文件中读取字节，并将其转换为字符后返回，而这是极其低效的。

可以对使用 DataInputStream 进行按原文输入的程序进行本地化，方法是用合适的 BufferedReader 替换每个 DataInputStream。

import java.io.InputStreamReader;
import java.io.BufferedReader;
public class BufferedReaderDemo
{
      public static void main(String[] args) throws java.io.IOException{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        System.out.println("请输入一段文字，可包含空白：");
        String text = br.readLine();
        System.out.println("您输入的文字："+text);
}

DataInputStream是InputStream的子类，专门负责读取使用DataOutputStream输出的数据，此类的定义如下：

public class DataInputStream extends FilterInputStream implements DataInput

此类继承自FilterInputStream类（FilterInputStream是InputStream的子类），同时实现DataInput接口，在DataInput接口中定义了一系列读入各种数据的方法。

U提示：DataInput接口的作用。

DataInput接口是读取数据的操作接口，与DataOutput接口提供的各种writerXxx()方法对应，在此接口中定义了一系列的readXxx()方法，这些方法在DataInputStream类中都有实现。一般在操作时不会直接使用到此接口，而主要使用DataInputStream类完成读取功能，只有在对象序列化时才有可能直接利用此接口读取数据，这一点在讲解Externalizable接口时再为读者介绍

DataInputStream和DataOutputStream都是Java中输入输出流的装饰类，用起来很方便。今天就来讨论一下使用该类时候遇到的编码问题。

[java] view plaincopyprint?

1. package com.vincent.example;  
2.   
3. import java.io.DataInputStream;  
4. import java.io.DataOutputStream;  
5. import java.io.FileInputStream;  
6. import java.io.FileOutputStream;  
7. import java.io.IOException;  
8.   
9. public class TestDataStream {  
10.     public static void main(String[] args) {  
11.         // 使用DataInputStream,DataOutputStream写入文件且从文件中读取数据。  
12.         try {  
13.             // Data Stream写到输入流中  
14.             DataOutputStream dos = new DataOutputStream(new FileOutputStream(  
15.                     "datasteam.txt"));  
16.             dos.writeBytes("世界"); //按2字节写入，都是写入的低位  
17.             dos.writeChars("世界"); // 按照Unicode写入  
18.             // 按照UTF-8写入(UTF8变长，开头2字节是由writeUTF函数写入的长度信息，方便readUTF函数读取)  
19.             dos.writeUTF("世界");   
20.             dos.flush();  
21.             dos.close();  
22.   
23.             // Data Stream 读取  
24.             DataInputStream dis = new DataInputStream(new FileInputStream(  
25.                     "datasteam.txt"));  
26.             // 读取字节  
27.             byte[] b = new byte[2];  
28.             dis.read(b);  
29.             System.out.println(new String(b, 0, 2));  
30.   
31.             // 读取字符  
32.             char[] c = new char[2];  
33.             for (int i = 0; i < 2; i++) {  
34.                 c[i] = dis.readChar();  
35.             }  
36.             System.out.println(new String(c, 0, 2));  
37.   
38.             // 读取UTF  
39.             System.out.println(dis.readUTF());  
40.   
41.             dis.close();  
42.         } catch (IOException e) {  
43.             e.printStackTrace();  
44.         }  
45.     }  
46. }  

package com.vincent.example;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class TestDataStream {
        public static void main(String[] args) {
                // 使用DataInputStream,DataOutputStream写入文件且从文件中读取数据。
                try {
                        // Data Stream写到输入流中
                        DataOutputStream dos = new DataOutputStream(new FileOutputStream(
                                        "datasteam.txt"));
                        dos.writeBytes("世界"); //按2字节写入，都是写入的低位
                        dos.writeChars("世界"); // 按照Unicode写入
                        // 按照UTF-8写入(UTF8变长，开头2字节是由writeUTF函数写入的长度信息，方便readUTF函数读取)
                        dos.writeUTF("世界"); 
                        dos.flush();
                        dos.close();

                        // Data Stream 读取
                        DataInputStream dis = new DataInputStream(new FileInputStream(
                                        "datasteam.txt"));
                        // 读取字节
                        byte[] b = new byte[2];
                        dis.read(b);
                        System.out.println(new String(b, 0, 2));

                        // 读取字符
                        char[] c = new char[2];
                        for (int i = 0; i < 2; i++) {
                                c[i] = dis.readChar();
                        }
                        System.out.println(new String(c, 0, 2));

                        // 读取UTF
                        System.out.println(dis.readUTF());

                        dis.close();
                } catch (IOException e) {
                        e.printStackTrace();
                }
        }
}

使用16进制方式打开文件如下：

可以看出，第一个“世界”已经被截断，两个汉字都只被写入了低位，因此肯定乱码。

[java] view plaincopyprint?

1. package com.vincent.example;  
2.   
3. import java.io.DataInputStream;  
4. import java.io.DataOutputStream;  
5. import java.io.FileInputStream;  
6. import java.io.FileOutputStream;  
7. import java.io.IOException;  
8.   
9. public class TestDataStream {  
10.     public static void main(String[] args) {  
11.         // 使用DataInputStream,DataOutputStream写入文件且从文件中读取数据。  
12.         try {  
13.             // Data Stream写到输入流中  
14.             DataOutputStream dos = new DataOutputStream(new FileOutputStream(  
15.                     "datasteam.txt"));  
16.             dos.write("世界".getBytes()); // 按UTF8编码(我的系统默认编码方式)写入  
17.             //dos.write("世界".getBytes("GBK"));  //指定其他编码方式  
18.             dos.writeChars("世界"); // 按照Unicode写入  
19.             // 按照UTF-8写入(UTF8编码长度可变，开头2字节是由writeUTF函数写入的长度信息，方便readUTF函数读取)  
20.             dos.writeUTF("世界");   
21.             dos.flush();  
22.             dos.close();  
23.   
24.             // Data Stream 读取  
25.             DataInputStream dis = new DataInputStream(new FileInputStream(  
26.                     "datasteam.txt"));  
27.             // 读取字节  
28.             byte[] b = new byte[6];  
29.             dis.read(b);  
30.             System.out.println(new String(b, 0, 6));  
31.   
32.             // 读取字符  
33.             char[] c = new char[2];  
34.             for (int i = 0; i < 2; i++) {  
35.                 c[i] = dis.readChar();  
36.             }  
37.             System.out.println(new String(c, 0, 2));  
38.   
39.             // 读取UTF  
40.             System.out.println(dis.readUTF());  
41.   
42.             dis.close();  
43.         } catch (IOException e) {  
44.             e.printStackTrace();  
45.         }  
46.     }  
47. }  

package com.vincent.example;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class TestDataStream {
        public static void main(String[] args) {
                // 使用DataInputStream,DataOutputStream写入文件且从文件中读取数据。
                try {
                        // Data Stream写到输入流中
                        DataOutputStream dos = new DataOutputStream(new FileOutputStream(
                                        "datasteam.txt"));
                        dos.write("世界".getBytes()); // 按UTF8编码(我的系统默认编码方式)写入
                        //dos.write("世界".getBytes("GBK"));  //指定其他编码方式
                        dos.writeChars("世界"); // 按照Unicode写入
                        // 按照UTF-8写入(UTF8编码长度可变，开头2字节是由writeUTF函数写入的长度信息，方便readUTF函数读取)
                        dos.writeUTF("世界"); 
                        dos.flush();
                        dos.close();

                        // Data Stream 读取
                        DataInputStream dis = new DataInputStream(new FileInputStream(
                                        "datasteam.txt"));
                        // 读取字节
                        byte[] b = new byte[6];
                        dis.read(b);
                        System.out.println(new String(b, 0, 6));

                        // 读取字符
                        char[] c = new char[2];
                        for (int i = 0; i < 2; i++) {
                                c[i] = dis.readChar();
                        }
                        System.out.println(new String(c, 0, 2));

                        // 读取UTF
                        System.out.println(dis.readUTF());

                        dis.close();
                } catch (IOException e) {
                        e.printStackTrace();
                }
        }
}

文件打开如下：

可以看出，读取前6字节并按照UTF-8解码就可以避免乱码。值得注意的是，String构造函数也可以指定对byte数组作其他编码方式的解码。例如：new String(b,0,6,"GBK")。同时使用writeUTF和readUTF可以免去程序猿对于长度的考虑，因为这两个函数为我们解决了长度问题，写入了文件，因此我们无需关心。但这样就使用了额外的空间去记录长度信息。

DataInput 接口用于从二进制流中读取字节，并根据所有 Java 基本类型数据进行重构。

对于此接口中的所有数据读取例程来说，如果在读取所需字节数之前已经到达文件末尾 (end of file)，则将抛出 EOFException（IOException 的一种）。如果因为到达文件末尾以外的其他原因无法读取字节，则将抛出 IOException 而不是 EOFException。尤其是，在输入流已关闭的情况下，将抛出 IOException。

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

在什么时候用datainputstream 在什么时候用bufferedreader？

DataInputStream 可以从基础输入流中读取基本 Java 数据类型比如 dataInputStream.readDouble();
dataInputStream.readInteger();dataInputStream.readLong();
bufferedreader从字符输入流中读取文本，缓冲各个字符，从而提供字符、数组和行的高效读取。

ByteArrayOutputStream 缓存流 和磁盘无关，不需要关闭

BufferedReader从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。注意是从字符输入流中读取，所以常用BufferedReader br=new BufferedReader(new InputStreamReader(in));

BufferedReader(Reader in)
          创建一个使用默认大小输入缓冲区的缓冲字符输入流。

context.getFilesDir().getPath()获取路径 getFilesDir()获取该应用程序数据文件夹的绝对路径