对于缓冲字节流的疑问：虽然进行了缓冲但是如果像上面的这样取，不是还是很慢吗，虽然是从缓冲里面取还是一个一个的取，效率还是很慢，然后做了个实验我使用一次取1024个，结果效率提高20倍，那么我就想，不用缓冲直接就用字节数组去读写，是不是也比缓冲要快呢，求解？
下面是我做的实验代码：

import java.io.*;
class CopyMp3
{
public static void main(String[] args)
{
  long start = System.currentTimeMillis();
  copy();
  long end = System.currentTimeMillis();
  System.out.println("time="+ (end-start)+"毫秒");

  
  
  

  
}

public static void copy()
{
  BufferedInputStream bis = null;
  BufferedOutputStream bos = null;
  try
  {
   bis = new BufferedInputStream(new FileInputStream("F:\\duqing.mp3"));
      bos = new BufferedOutputStream(new FileOutputStream("F:\\渡情.mp3"));
   byte[] bt = new byte[1024];
   int buf = 0;
   while((buf = bis.read(bt))!= -1)
   {
    bos.write(bt, 0, buf);
   }
  }
  catch (IOException e)
  {
   throw new RuntimeException("复制失败！");
  }
  finally
  {
   try
   {
    if(bis!=null)
     bis.close();
   }
   catch (IOException e)
   {
    throw new RuntimeException("读文件关闭失败");
   }
   try
   {
    if(bos!=null)
     bos.close();
   }
   catch (IOException e)
   {
    throw new RuntimeException("写文件关闭失败");
   }
   
  }
}
}

  直接用数组去读是可以的，速度是是没有数组缓冲区快。但是你自定义的1024应该乘以一个数，这样把缓冲区增大一次就可读取更过的数据，你直接用数组去读取数组默认的缓冲区要是1024和你自定义的缓冲区空间一样，那么读取速度就是一样的。
byte[] buf = new byte[fis.available()];
       fis.read(buf);
       fos.write(buf);
               
     fos.close();
     fis.close();

字节流读取有四种方式，我把代码给你，你自己去试一下就知道了

package cn.itcast.g.io.bytestream.test;

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

public class CopyMediaFileTest {

        /**
         * @param args
         * @throws IOException
         */
        public static void main(String[] args) throws IOException {
                long start = System.currentTimeMillis();
                copy_4();
                long end = System.currentTimeMillis();
               
                System.out.println((end-start)+"毫秒");
               
        }

        private static void copy_4() throws IOException {
                FileInputStream fis = new FileInputStream("c:\\0.mp3");               
                FileOutputStream fos = new FileOutputStream("c:\\4.mp3");
               
               
                int ch = 0;
               
                while((ch=fis.read())!=-1){
                        fos.write(ch);
                }
               
                fos.close();
                fis.close();
        }

        private static void copy_3() throws IOException {
               
                FileInputStream fis = new FileInputStream("c:\\0.mp3");               
                FileOutputStream fos = new FileOutputStream("c:\\3.mp3");
                BufferedInputStream bufis = new BufferedInputStream(fis);
                BufferedOutputStream bufos = new BufferedOutputStream(fos);
               
                int ch = 0;
               
                while((ch=bufis.read())!=-1){
                        bufos.write(ch);
                }
                bufos.close();
                bufis.close();
               
        }

        private static void copy_2() throws IOException {
                FileInputStream fis = new FileInputStream("c:\\0.mp3");               
                FileOutputStream fos = new FileOutputStream("c:\\2.mp3");
               
                byte[] buf = new byte[fis.available()];
                fis.read(buf);
                fos.write(buf);
               
                fos.close();
                fis.close();
        }

        private static void copy_1() throws IOException {
                FileInputStream fis = new FileInputStream("c:\\0.mp3");               
                FileOutputStream fos = new FileOutputStream("c:\\1.mp3");
               
                byte[] buf = new byte[1024*4];
               
                int len = 0;
               
                while((len=fis.read(buf))!=-1){
                        fos.write(buf,0,len);
                }
               
                fos.close();
                fis.close();
        }

}

楼上很给力，我稍微补充点：byte[] buf = new byte[fis.available()]; 可以内存自动分配空间，但是要慎用，不宜读取相对于内存过大的内容，那样内存会爆掉