读硬盘txt文件用IO流中那个高效？

//用Buffered缓冲区读,是高效的,  
是这样的,因为,从硬盘直接读取到内存很慢,而从缓冲区读到内存很快.
或许你又会问,不还是要从硬盘读到缓冲区么?不也慢么?是这样的,缓冲区,一次性就从硬盘读取8192个字节,所以....
//还有一种是定义一个字节数组也是高效的,

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;

public class Demo2 {
        public static void main(String[] args) throws Exception {
                BufferedInputStream bis = new BufferedInputStream(new FileInputStream("a.txt"));                        //创建缓冲输入流对象,并与文件输入流相关联
                BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("b.txt"));                        //创建缓冲输出流对象,并与文件输出流相关联
                int b;
                while((b = bis.read()) == -1) {                                                                                                                                // read()读取一个字节时, 其实已经读取8192个字节到缓冲区了
                        bos.write(b);                                                                                                                                                        // write()写出一个字节时, 没有直接写到文件, 写到缓冲区里了
                        bis.close();                                                                                                                                                        //关闭流
                        bos.close();
                }
        }

}

看需求咯，如果纯粹是读取的话，BufferedReader，这个适用于字符流，对应的字节流也有一个缓冲区。
如果有同时读写的操作，可以使用RandomAccessFile类，可以实现文件的随机读写。

读写文本文件的话使用BufferedReader和BufferedWriter是高效的, BufferedReader可以读取一行的数据readLine(), BufferedWriter可以写入读出的全部数据并写入一个隔行newLine(), 并且还可以指定写入的编码, 参见下面的代码
import java.io.*;
public class Demo3 {
        public static void main(String[] args) throws
                        FileNotFoundException, IOException {
                try (
                // 创建输入流字符缓冲区对象
                BufferedReader br = new BufferedReader(new FileReader("test.txt"));
                                // 创建输出流字符缓冲区, 将字符编码转换为utf-8输出
                                BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(
                                                new FileOutputStream("test_copy3.txt"), "utf-8"));) {
                        String s; // 用来存储一行的字符数据
                        // 循环将字符文件拷贝到目标文件
                        while ((s = br.readLine()) != null) {
                                //写出读入的一行数据
                                bw.write(s);
                                //写出换行
                                bw.newLine();
                        }
                }
        }
}

IO流中要提高读写效率就要用到缓冲流：BufferedWriter和BufferedReader

上面说的比较全，画了个图帮助你理解。

图解很详细，顶一下

黑马云青年为您解答

感觉使用直接两个文件流进行直接对接，会比较快

public static boolean copyFile(String inName, String outName){
            FileInputStream iStream=null;
            FileOutputStream oStream=null;
            //定义两个直连的文件管道
            FileChannel in=null,out=null;
                try {
                        iStream=new FileInputStream(inName);
                        oStream=new FileOutputStream(outName);
                        in = iStream.getChannel();
                        out = oStream.getChannel();
                        //直接让流流向要拷贝的文件
                        out.transferFrom(in, 0, in.size());
                        return true;
                } catch (FileNotFoundException e) {
                        //打印错误
                        e.printStackTrace();
                } catch (IOException e) {
                        //打印错误
                        e.printStackTrace();
                }finally{
                        //关闭流
                        try {
                                if (in!=null) in.close();
                                if (out!=null)out.close();
                                if (iStream!=null)iStream.close();
                                if (oStream!=null)oStream.close();
                        } catch (IOException e) {
                                e.printStackTrace();
                        }
                }
                return false;
    }

如果问题已解决请再次编辑，改为以解决，方便大家看帖，没有就继续追问