黑马程序员——IO技术

第一讲     IO概述
概述
1、IO流：即InputOutput的缩写。
2、特点：
        1）IO流用来处理设备间的数据传输。
        2）Java对数据的操作是通过流的方式。
        3）Java用于操作流的对象都在IO包中。
        4）流按操作数据分为两种：字节流和字符流。
        5）流按流向分为：输入流和输出流。
注意：流只能操作数据，而不能操作文件。
3、IO流的常用基类：
        1）字节流的抽象基流：InputStream和OutputStream
        2）字符流的抽象基流：Reader和Writer
注：此四个类派生出来的子类名称都是以父类名作为子类名的后缀，以前缀为其功能；如InputStream子类FileInputStream；Reader子类FileReader
 
第二讲    字符流
一、简述
        1、字符流中的对象融合了编码表。使用的是默认的编码，即当前系统的编码。
        2、字符流只用于处理文字数据，而字节流可以处理媒体数据。
        3、既然IO流是用于操作数据的，那么数据的最常见体现形式是文件。查看API，找到一个专门用于操作文件的Writer子类对象：FileWriter。   后缀是父类名。前缀名是流对象的功能。该流对象一被初始化，就必须有被操作的文件存在。
 
二、字符流的读写
1、写入字符流步骤
        a、创建一个FileWriter对象，该对象一被初始化，就必须要明确被操作的文件。且该目录下如果已有同名文件，则同名文件将被覆盖。其实该步就是在明确数据要存放的目的地。
        b、调用write(String s)方法，将字符串写入到流中。
        c、调用flush()方法，刷新该流的缓冲，将数据刷新到目的地中。
        d、调用close()方法，关闭流资源。但是关闭前会刷新一次内部的缓冲数据，并将数据刷新到目的地中。
close()和flush()区别：
        flush()刷新后，流可以继续使用；
       而close()刷新后，将会关闭流，不可再写入字符流。
注意：
        1、其实java自身不能写入数据，而是调用系统内部方式完成数据的书写，使用系统资源后，一定要关闭资源。
        2、文件的数据的续写是通过构造函数 FileWriter(Strings,boolean append)，在创建对象时，传递一个true参数，代表不覆盖已有的文件。并在已有文件的末尾处进行数据续写。（windows系统中的文件内换行用\r\n两个转义字符表示，在linux系统中只用\n表示换行）
        3、由于在创建对象时，需要指定创建文件位置，如果指定的位置不存在，就会发生IOException异常，所以在整个步骤中，需要对IO异常进行try处理。
 示例：
[java] view plaincopy
import java.io.*;  
  
class FileWriterDemo   
{  
    public static void main(String[] args)   
    {  
        writerDate("abcde");//写入数据  
        writerFrom("zheshi:\r\nshenma");//续写数据，并附换行操作  
    }  
  
    //在硬盘上创建一个文件并写入指定数据  
    public static void writerDate(String s)  
    {  
        FileWriter fw=null;  
        try  
        {  
            fw=new FileWriter("demo.txt");//创建文件  
            fw.write(s);//将数据写入流  
        }  
        catch (IOException e)  
        {  
            throw new RuntimeException("写入失败");  
        }  
        finally  
        {  
            if(fw!=null)  
                try  
                {  
                    fw.close();//将写入流的数据刷到指定文件内，并关闭流资源  
                }  
                catch (IOException e)  
                {  
                }  
        }  
    }  
  
    //对已有文件的数据续写指定数据  
    public static void writerFrom(String s)  
    {  
        FileWriter fw=null;  
        try  
        {  
            fw=new FileWriter("demo.txt",true);//传递一个true参数，代表不覆盖已有的文件。  
            fw.write(s);  
        }  
        catch (IOException e)  
        {  
            throw new RuntimeException("写入失败");  
        }  
        finally  
        {  
            try  
            {  
                if(fw!=null)  
                    fw.close();  
            }  
            catch (IOException e)  
            {  
            }  
        }  
    }  
}  
2、读取字符流步骤
        1）创建一个文件读取流对象，和指定名称的文件相关联。要保证该文件已经存在，若不存在，将会发生异常FileNotFoundException。
        2）调用读取流对象的read()方法。read()：一次读一个字符，且会继续往下读。
              第一种方式：读取单个字符。第二种方式：通过字符数组进行读取。
        3）读取后要调用close方法将流资源关闭。
示例：
[java] view plaincopy
import java.io.*;  
class  FileReaderDemo  
{  
    public static void main(String[] args)   
    {  
        //第一种读取方式  
        singleCharReader();  
        //第二种读取方式  
        arrayCharReader();  
    }  
  
    //第一种读取方式，单个字符读取  
    public static void singleCharReader()  
    {  
        FileReader fr=null;  
        try  
        {  
              
            fr=new FileReader("demo.txt");//读取文件位置和文件名  
            for (int ch=0;(ch=fr.read())!=-1 ; )  
            {  
                System.out.print((char)ch);  
            }  
        }  
        catch (IOException e)  
        {  
            throw new RuntimeException("读取失败");  
        }  
        finally  
        {  
            try  
            {  
                if(fr!=null)  
                    fr.close();//关闭读取流资源  
            }  
            catch (IOException e)  
            {  
            }  
        }  
    }  
  
    //第二种读取方式，通过字符数组进行读取  
    public static void arrayCharReader()  
    {  
        FileReader fr=null;  
        char[] arr=new char[1024];//定义一个字符数组，用于临时存储读取的字符  
        try  
        {  
            //读取一个.java文件，并打印在控制台上。  
            fr=new FileReader("FileReaderDemo.java");  
            for (int len=0;(len=fr.read(arr))!=-1 ; )  
            {  
                //显示字符数组的字符个数  
                System.out.print(new String(arr,0,len));  
            }  
        }  
        catch (IOException e)  
        {  
            throw new RuntimeException("读取失败");  
        }  
        finally  
        {  
            if(fr!=null)  
                try  
                {  
                    fr.close();  
                }  
                catch (IOException e)  
                {  
                }  
        }  
    }  
}  
注意：
        1、定义文件路径时，可以用“/”或者“\\”。
        2、在创建一个文件时，如果目录下有同名文件将被覆盖。
        3、在读取文件时，必须保证该文件已存在，否则出异常。
小练习：文本文件的拷贝
[java] view plaincopy
/* 
需求： 
将c盘一个文本文件复制到e盘、 
复制的原理： 
其实就是将c盘下的文件数据存储到e盘的一个文件中。 
步骤： 
1、在e盘创建一个文件。用于存储c盘文件中的数据。 
2、定义读取流和c盘文件关联。 
3、通过不断的读写完成数据存储。 
4、关闭资源。 
*/  
import java.io.*;  
   
class ReaderWriterTest  
{  
       publicstatic void main(String[] args)   
       {  
              //调用复制方法  
              //copy_1();  
              copy_2();  
       }  
       //用第一种读取方式进行复制  
       publicstatic void copy_1()  
       {  
              FileWriterfw=null;  
              FileReaderfr=null;  
              try  
              {  
                     //关联读取和写入的文件  
                     fw=newFileWriter("E:\\HelloWorld.java");  
                     fr=newFileReader("C:\\HelloWorld.java");  
                     for(int ch=0;(ch=fr.read())!=-1 ; )  
                     {  
                            fw.write(ch);//一个字符一个字符写入  
                     }  
              }  
              catch(IOException e)  
              {  
                     thrownew RuntimeException("读写失败");  
              }  
              finally  
              {  
                     if(fr!=null)  
                            try  
                            {  
                                   fr.close();//对读取流和写入流分别关闭  
                            }  
                            catch(IOException e)  
                            {  
                            }  
                     if(fw!=null)  
                            try  
                            {  
                                   fw.close();  
                            }  
                            catch(IOException e)  
                            {  
                            }  
              }  
       }  
   
       //第二种读取方式进行复制  
       publicstatic void copy_2()  
       {  
              FileWriterfw=null;  
              FileReaderfr=null;  
              try  
              {  
                     //关联读取和写入的文件  
                     fw=newFileWriter("E:\\HelloWorld.java");  
                     fr=newFileReader("C:\\HelloWorld.java");  
                     char[]arr=new char[1024];  
                     for(int len=0;(len=fr.read(arr))!=-1 ; )  
                     {  
                            fw.write(arr,0,len);//利用数组一次存入数组中的字符  
                     }  
              }  
              catch(IOException e)  
              {  
                     thrownew RuntimeException("读写失败");  
              }  
              finally  
              {  
                            try  
                            {  
                                   if(fr!=null)  
                                          fr.close();  
                            }  
                            catch(IOException e)  
                            {  
                            }  
                            finally  
                            {  
                                   if(fw!=null)  
                                          try  
                                          {  
                                                 fw.close();  
                                          }  
                                          catch(IOException e)  
                                          {  
                                          }  
                            }       
              }  
       }  
}  


三、字符流的缓冲区——BufferedReader和BufferedWriter
1、缓冲区的出现：提高了流的读写效率，所以在缓冲区创建前，要先创建流对象。即先将流对象初始化到构造函数中。 
2、缓冲技术原理：此对象中封装了数组，将数据存入，再一次性取出。
3、写入流缓冲区BufferedWriter的步骤：
        1）创建一个字符写入流对象。
         如：FileWriter fw=newFileWriter("buf.txt");
         2）为了提高字符写入流效率。加入缓冲技术。只要将需要被提高效率的流对象作为参数传递给缓冲区的构造函数即可。
         如： BufferedWriter bufw =new BufferedWriter(fw);
         3）调用write方法写入数据到指定文件
         如：bufw.write("adfg");
         记住，只要用到缓冲区，就要记得刷新。（关闭流同样会刷新，但为了排除意外事故，保证数据存在，建议写入一次就刷新一次）
         如：bufw.flush();
         4）其实关闭缓冲区，就是在关闭缓冲区中的流对象。
        如： bufw.close();
小知识：BufferedWriter缓冲区中提供了一个跨平台的换行符：newLine();可以在不同操作系统上调用，用作数据换行。
        如：bufw.newLine();
4、读取流缓冲区BufferedReader
        该缓冲区提供了一个一次读一行的方法readLine，方便于堆文本数据的获取，当返回null时表示读到文件末尾。readLine方法返回的时候，只返回回车符之前的数据内容。并不返回回车符。
readLine方法原理：
        无论是读一行。或者读取多个字符。其实最终都是在在硬盘上一个一个读取。所以最终使用的还是read方法一次读一个的方法。
步骤：
        1）创建一个读取流对象和文件相关联
        如： FileReader fr=newFileReader("buf.txt");
        2）为了提高效率。加入缓冲技术。将字符读取流对象作为参数传递给缓冲区对象的构造函数。
        如： BufferedReader bufr=new BufferedReader(fr);
        3）调用该缓冲区提供的readLine方法一行一行读取,如果到达文件末尾，则返回null
        如： String s=bufr.readLine();
        4）关闭流资源
        如： bufr.close();、
示例：通过缓冲区复制一个文本文件。
[java] view plaincopy
/* 
需求：使用缓冲技术copy一个文本文件 
*/  
import java.io.*;  
  
class BufferedCopyDemo   
{  
    public static void main(String[] args)   
    {  
          
        BufferedWriter bfw=null;  
        BufferedReader bfr=null;  
        try  
        {  
            //创建写缓冲对象  
            bfw=new BufferedWriter(new FileWriter("ReaderWriterTest_copy.txt"));  
            //创建读缓冲对象  
            bfr=new BufferedReader(new FileReader("ReaderWriterTest.java"));  
            //利用BufferedReader提供的readLine方法获取整行的有效字符。直到全部获取  
            for (String line=null; (line=bfr.readLine())!=null; )  
            {  
                bfw.write(line);//写入指定文件中  
                bfw.newLine();//换行  
                bfw.flush();//将缓冲区数据刷到指定文件中  
            }  
              
        }  
        catch (IOException e)  
        {  
            throw new RuntimeException("文件copy失败");  
        }  
        finally  
        {  
            if(bfw!=null)  
                try  
                {  
                    bfw.close();//关闭写入流  
                }  
                catch (IOException e)  
                {  
                    throw new RuntimeException("写入流关闭失败");  
                }  
            if(bfr!=null)  
                try  
                {  
                    bfr.close();//关闭读取流  
                }  
                catch (IOException e)  
                {  
                    throw new RuntimeException("读取流关闭失败");  
                }  
        }  
    }  
}  
5、自定义BufferedReader：
原理：
        可根据BufferedReader类中特有一行一行读取方法readLine()的原理，自定义一个类中包含相同功能的方法
步骤：
        a、初始化自定义的类，加入流对象。
        b、定义一个临时容器，原BufferedReader封装的是字符数组，此类中可定义一个StringBuilder的容器，最终可实现字符串的提取。
代码：
[java] view plaincopy
/* 
需求：根据readLine方法原理，模拟BufferedReader写一个自己的MyBufferedReader 
*/  
import java.io.*;  
//自定义缓冲类  
class MyBufferedReader extends Reader  
{  
    private Reader r;//定义接收的流对象  
    MyBufferedReader(Reader r)  
    {  
        this.r=r;  
    }  
    //自定义整行读取  
    public String myReadLine()throws IOException  
    {  
        //创建一个容器，用来存储一行的字符  
        StringBuilder sb =new StringBuilder();  
        //一个字符一个字符读取  
        for (int ch=0;(ch=r.read())!=-1 ; )  
        {  
            if(ch=='\r')//如果遇到换行符，则继续  
                continue;  
            if(ch=='\n')//如果遇到回车符，表示该行读取完毕  
                return sb.toString();  
            else  
                sb.append((char)ch);//将该行的字符添加到容器  
        }  
        if(sb.length()!=0)//如果读取结束，容器中还有字符，则返回元素  
            return sb.toString();  
        return null;  
    }  
  
    //复写父类中的抽象方法  
    public int read(char[] cbuf, int off, int len) throws IOException  
    {  
        return r.read(cbuf,off,len);  
    }  
  
    //复写父类的close方法  
    public void close()throws IOException  
    {  
        r.close();  
    }  
}  
//测试MyBufferedReader  
class  MyBufferedReaderDemo  
{  
    public static void main(String[] args)   
    {  
        MyBufferedReader mbr=null;  
        try  
        {  
            mbr=new MyBufferedReader(new FileReader("BufferedCopyDemo.java"));  
            for (String line=null;(line=mbr.myReadLine())!=null ; )  
            {  
                System.out.println(line);//显示效果  
            }  
        }  
        catch (IOException e)  
        {  
            throw new RuntimeException("读取数据失败");  
        }  
        finally  
        {  
            try  
            {  
                if(mbr!=null)  
                    mbr.close();  
            }  
            catch (IOException e)  
            {  
                throw new RuntimeException("读取流关闭失败");  
            }  
        }     
    }  
}  
6、LineNumberReader
        在BufferedReader中有个直接的子类LineNumberReader，其中有特有的方法获取和设置行号：
         setLineNumber();//设置初始行号
         getLineNumber();//获取行号
示例：
[java] view plaincopy
/* 
需求：利用LineNumberReader的特有方法去设置和获取文件中数据的行号 
*/  
class  LineNumberReaderDemo  
{  
    public static void main(String[] args)   
    {  
        LineNumberReader lnr=null;  
        try  
        {  
            //将读取流对象传入  
            lnr=new LineNumberReader(new FileReader("LineNumberReaderDemo.java"));  
            lnr.setLineNumber(100);//设置开始行号  
  
            for (String line=null;(line=lnr.readLine())!=null ; )  
            {  
                System.out.println(lnr.getLineNumber()+":"+line);//打印每行行号和字符  
            }  
        }  
        catch (IOException e)  
        {  
            throw new RuntimeException("读取数据失败");  
        }  
        finally  
        {  
            try  
            {  
                if(lnr!=null)  
                    lnr.close();  
            }  
            catch (IOException e)  
            {  
                throw new RuntimeException("读取流关闭失败");  
            }  
        }     
    }  
}  


四、装饰设计模式
1、简述
        当想对已有对象进行功能增强时，可定义类：将已有对象传入，基于已有对象的功能，并提供加强功能，那么自定义的该类称之为装饰类。
2、特点
        装饰类通常都会通过构造方法接收被装饰的对象，并基于被装饰的对象的功能，提供更强的功能。
3、装饰和继承的区别：
        1）装饰模式比继承要灵活。避免了继承体系的臃肿，且降低了类与类之间的关系。
        2）装饰类因为增强已有对象，具备的功能和已有的是相同的，只不过提供了更强的功能，所以装饰类和被装饰的类通常都是属于一个体系。
        3）从继承结构转为组合结构。
注：在定义类的时候，不要以继承为主；可通过装饰设计模式进行增强类功能。灵活性较强，当装饰类中的功能不适合，可再使用被装饰类的功能。
示例：上面讲到的MyBufferedReader的例子就是最好的装饰设计模式的例子。
 
第三讲     字节流
一、概述
1、字节流和字符流的基本操作是相同的，但字节流还可以操作其他媒体文件。
2、由于媒体文件数据中都是以字节存储的，所以，字节流对象可直接对媒体文件的数据写入到文件中，而可以不用再进行刷流动作。
3、读写字节流：InputStream   输入流（读）
                             OutputStream  输出流（写）
4、为何不用进行刷流动作：
        因为字节流操作的是字节，即数据的最小单位，不需要像字符流一样要进行转换为字节。所以可直接将字节数据写入到指定文件中。
5、InputStream特有方法：
        int available();//返回文件中的字节个数
注：可以利用此方法来指定读取方式中传入数组的长度，从而省去循环判断。但是如果文件较大，而虚拟机启动分配的默认内存一般为64M。当文件过大时，此数组长度所占内存空间就会溢出。所以，此方法慎用，当文件不大时，可以使用。
[java] view plaincopy
/* 
练习： 
复制一个图片 
思路： 
1、用字节读取流对象和图片关联。 
2、用字节写入流对象创建一个图片文件。用于存储获取到的图片数据。 
3、通过循环读写，完成数据的存储。 
4、关闭资源。 
*/  
import java.io.*;  
class  CopyPic  
{  
    public static void main(String[] args)   
    {  
        //常用方法复制  
        byteArrayCopy();  
        //利用输入流的available方法进行复制  
        availableCopy();  
        //利用available方法对复制文件大小有限制，慎用      
    }  
  
    //使用available方法进行复制  
    public static void availableCopy()  
    {  
        FileInputStream fis=null;  
        FileOutputStream fos=null;  
        try  
        {  
            //关联要复制的文件  
            fis=new FileInputStream("C:/Users/asus/Desktop/1.jpg");  
            //指定复制的路径  
            fos=new FileOutputStream("C:/Users/asus/Desktop/3.jpg");  
            //利用available方法指定数组长度  
            byte[] b=new byte[fis.available()];  
  
            fis.read(b);//复制关联文件数据  
  
            fos.write(b);//粘贴到指定路径  
  
        }  
        catch (IOException e)  
        {  
            throw new RuntimeException("图片复制失败");  
        }  
        finally  
        {  
            try  
            {  
                if(fis!=null)  
                    fis.close();//关闭输入字节流  
            }  
            catch (IOException e)  
            {  
                throw new RuntimeException("读取字节流关闭失败");  
            }  
            try  
            {  
                if(fos!=null)  
                    fos.close();//关闭输出字节流  
            }  
            catch (IOException e)  
            {  
                throw new RuntimeException("写入字节流关闭失败");  
            }  
        }  
    }  
    //使用读数组方式进行复制  
    public static void byteArrayCopy()  
    {  
        FileInputStream fis=null;  
        FileOutputStream fos=null;  
        try  
        {  
            //关联要复制的文件  
            fis=new FileInputStream("C:/Users/asus/Desktop/1.jpg");  
            //指定复制的路径  
            fos=new FileOutputStream("C:/Users/asus/Desktop/2.jpg");  
            //利用数组的读取方式  
            byte[] b=new byte[1024];  
            int len=0;  
            while ((len=fis.read(b))!=-1)//复制文件的全部数据  
            {  
                fos.write(b,0,len);//粘贴到指定路径  
            }  
        }  
        catch (IOException e)  
        {  
            throw new RuntimeException("图片复制失败");  
        }  
        finally  
        {  
            try  
            {  
                if(fis!=null)  
                    fis.close();//关闭输入字节流  
            }  
            catch (IOException e)  
            {  
                throw new RuntimeException("读取字节流关闭失败");  
            }  
            try  
            {  
                if(fos!=null)  
                    fos.close();//关闭输出字节流  
            }  
            catch (IOException e)  
            {  
                throw new RuntimeException("写入字节流关闭失败");  
            }  
        }  
    }  
}  
 
二、字节流缓冲区
        同样是提高了字节流的读写效率。
1、读写特点：
        read()：会将字节byte型值提升为int型值
        write()：会将int型强转为byte型，即保留二进制数的最后八位。
2、原理：将数据拷贝一部分，读取一部分，循环，直到数据全部读取完毕。
        1）先从数据中抓取固定数组长度的字节，存入定义的数组中，再通过然后再通过read()方法读取数组中的元素，存入缓冲区。
        2）循环这个动作，直到最后取出一组数据存入数组，可能数组并未填满，同样也取出包含的元素。
        3）每次取出的时候，都有一个指针在移动，取到数组结尾就自动回到数组头部，这样指针在自增。
        4）取出的时候，数组中的元素在减少，取出一个，就减少一个，直到减到0即元素取完。
        5）当文件中的全部数据都被读取出时，read()方法就返回-1。
3、自定义读取字节流缓冲区
        需求：根据字节流缓冲区的原理，自定义一个字节流缓冲区。
注意：
        1、字节流的读一个字节的read方法为什么返回值类型不是byte，而是int。
       因为有可能会读到连续8个二进制1的情况，8个二进制1对应的十进制是-1.那么就会数据还没有读完，就结束的情况。因为我们判断读取结束是通过结尾标记-1来确定的。
       所以，为了避免这种情况将读到的字节进行int类型的提升。并在保留原字节数据的情况前面了补了24个0，变成了int类型的数值。而在写入数据时，只写该int类型数据的最低8位。
        2、byte类型的-1提升为int类型时还是-1。原因：因为在bit8个1前面补的全是1导致的。如果在bit8个1前面补0，即可以保留原字节数据不变，又可以避免-1的出现。这时将byte型数据&0xff即255即可。
代码：
[java] view plaincopy
/* 
自定义字节流读取缓冲区 
思路： 
1、定义一个固定长度的数组 
2、定义一个指针和计数器用于读取数组长度，和计数数组元素是否取完为0 
3、每次将字节数据存入元素要先将数组中的元素取完 
  
*/  
import java.io.*;  
class MyBufferedInputStream  
{  
       privateInputStream in;  
       privatebyte[] by=new byte[1024];  
       privateint count=0,pos=0;  
       MyBufferedInputStream(InputStreamin)  
       {  
              this.in=in;  
       }  
  
   
       //自定义读方法，一次读一个字节  
       publicint myRead()throws IOException  
       {  
              //通过in对象读取硬盘上数据，并存储by中。  
              //存储在数组中的数据被读取完，再通过in对象从硬盘上读取数据  
              if(count==0)  
              {  
                     count=in.read(by);  
                     if(count<0)//文件数据全部被读取出来了  
                            return-1;  
  
   
                     pos=0;//初始化指针  
                     byteb=by[pos];  
  
                     count--;//每被读一个字节，表示数组中的字节数少一个  
                     pos++;//指针加1  
                     returnb&255;//返回的byte类型提升为int类型，字节数增加，且高24位被补1，原字节数据改变。  
                                          //通过与上255，主动将byte类型提升为int类型，将高24位补0，原字节数据不变。  
                                          //而在输出字节流写入数据时，只写该int类型数据的最低8位。  
              }  
              elseif(count>0)//如果数组中的数据没被读取完，则继续读取  
              {  
                     byteb=by[pos];  
   
                     count--;  
                     pos++;  
                     returnb&0xff;  
              }  
              return-1;  
       }  
         
       //自定义关闭资源方法  
       publicvoid close()throws IOException  
       {  
              in.close();  
       }  
}  
  
   
//测试自定义输入字节流缓冲区  
class MyBufferedCopyMp3  
{  
       publicstatic void main(String[] args)   
       {  
              longstart=System.currentTimeMillis();  
              //利用字节流的缓冲区进行复制  
              copy_2();  
              longend=System.currentTimeMillis();  
              System.out.println("复制共用时："+(end-start)+"毫秒");  
       }  
       //使用字节流的缓冲区进行复制  
       publicstatic void copy_2()  
       {  
              BufferedOutputStreambout=null;  
              MyBufferedInputStreambin=null;  
              try  
              {  
                     //关联复制文件输入流对象到缓冲区  
                     bin=newMyBufferedInputStream(new FileInputStream("C:/Users/asus/Desktop/一样的月光.mp3"));  
                     //指定文件粘贴位置的输出流对象到缓冲区  
                     bout=newBufferedOutputStream(new FileOutputStream("C:/Users/asus/Desktop/一样的月光2.mp3"));  
                     intby=0;  
   
  
                     while((by=bin.myRead())!=-1)  
                     {  
                            bout.write(by);//将缓冲区中的数据写入指定文件中  
                     }  
              }  
              catch(IOException e)  
              {  
                     thrownew RuntimeException("MP3复制失败");  
              }  
              finally  
              {  
                     try  
                     {  
                            if(bin!=null)  
                                   bin.close();//关闭输入字节流  
                     }  
                     catch(IOException e)  
                     {  
                            thrownew RuntimeException("读取字节流关闭失败");  
                     }  
                     try  
                     {  
                            if(bout!=null)  
                                   bout.close();//关闭输出字节流  
                     }  
                     catch(IOException e)  
                     {  
                            thrownew RuntimeException("写入字节流关闭失败");  
                     }  
              }  
       }  
}