黑马程序员——java基础 io 转换流的应用（InputStreamReader，OutputStreamWriter）

        ------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ ------

黑马训练营

---

快速copymp3文件——高级版

自定义一个包装类，用来快速copyMp3文件~~~
自定义缓冲字节流，用来copy文件
`package com.itheima.luo;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;

/**
* 自定义字节缓冲流 copyMp3
*
* @author MyLuo
*
*徒手模拟一个字节缓冲流
*
*/
public class CopyMp3MyBufferedOutputStream {

       public static void main(String[] args) {
           long start=System.currentTimeMillis();
          myBufferedMethod();
          long end=System.currentTimeMillis();
          System.out.println("copymp3用了"+(end-start)+"毫秒");
    }

    private static void myBufferedMethod() {
        //用自定义的缓冲流来测试一下 
           MyBufferedInputStream mbis=null;

           BufferedOutputStream  bos=null;

           try {

            mbis=new MyBufferedInputStream(new FileInputStream("E:\\星星点灯—Myluo.mp3"));

            bos=new BufferedOutputStream(new FileOutputStream("luo.mp3"));

            int len=-1;

            try {
                while((len=mbis.myRead())!=-1){
                       bos.write(len);
                }
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }


        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally{
            if(mbis!=null)
                try {
                    mbis.myClose();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                if(bos!=null)
                    try {
                        bos.close();
                    } catch (IOException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
        }
    }

}

//定义一个包装类
class MyBufferedInputStream{
//传进来的被装饰的对象
private InputStream is;
//从硬盘上读取的字节数组
private byte [] bt=new byte[1024];
//读取数组的数量（也就是BufferedInputStream,的read方法）pos，
//读进数组的数量FileInputStream ，int count=read（bt）；
private int count=0,pos=0;
//传进来的对象作用本类
public MyBufferedInputStream(InputStream is) {
super();
this.is = is;
}

public int myRead() throws IOException{
    //当数组读完了，才开始有装数据
    if (count==0) {
        //底层流开始读取硬盘，放到bt字节数组里面
         count = is.read(bt);
         //当底层流，没有读到字节时，返回-1
         if(count==-1)
             return -1;
        //每一次重新读得时候，指针又归零。。。
         pos=0;
         //从数组一个一个读取的，返回
         byte zj = bt[pos];
        //指针指向下一个，也就是字节数组下标自增
        pos++;
        //返回一个，数组元素减少一个
        count--;
        //读一个返回一个
        return zj&255;
        //当数组里面还没有读完，所以只拿数据，不装数据。。。。
    }else if(count>0){
        byte zj=bt[pos];
        pos++;
        count--;
        return zj&255;
    }
    return -1;
}
//关闭的方法
public void myClose() throws IOException{
    is.close();
}

}
`

---

原始版

这是原始的缓冲字节流copyMP3文件，BufferedReader，BufferedWrietr
`package com.itheima.luo;

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

/**
* 缓冲 字节流 MyBufferedInputStream,MyBufferedOutputStream
*
* copy Mp3
*
* @author Myluo
*
*/
public class MyBufferedInputStreamOne {
public static void main(String[] args) {

            long  start=System.currentTimeMillis();
            bufferedMethod();
            long end=System.currentTimeMillis();
            System.out.println("copyMp3用了"+(end-start)+"毫秒");

        }

        private static void bufferedMethod() {
            BufferedInputStream  bif=null;

            BufferedOutputStream bos=null;

            try {
                //开始读取文件
                bif=new BufferedInputStream(new FileInputStream("E:\\星星点灯—Myluo.mp3"));
                //开始写入目的地
                bos=new BufferedOutputStream(new FileOutputStream("Myluo.mp3"));

                int len=-1;

                try {
                    while((len=bif.read())!=-1){
                        bos.write(len);
                    }
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }

            } catch (FileNotFoundException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }finally{
                if(bif!=null)
                    try {
                        bif.close();
                    } catch (IOException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    if(bos!=null)
                        try {
                            bos.close();
                        } catch (IOException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
            }
        }

}
`
流的转换

package com.itheima.luo;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;

/**
 *
 * 用转换流来来完成键盘录入
 * 
 * @author Myluo
 *
 *InputStreamReader 把（传进来的）字节读取流转换成成字符读取流
 *
 *OutputStreamWriter  把（传进来）字节写入流装换成字符写入流
 *
 *应为BufferedReader  对象又readLine()方法
 *
 *因为BufferedWriter  的对象有newLine();方法
 *
 */
public class InputStreamReaderTest {
         public static void main(String[] args) {
            //获得键盘录入的字节流
             InputStream in = System.in;
            //转换成字符流，
             InputStreamReader  isr=new InputStreamReader(in);
             //开始把字符流加粗水管
             BufferedReader br=new BufferedReader(isr);
             //开始循环打印
             String str=null;
             //标准的输出流（字节流）
             OutputStream out=System.out;
             //转换成字符流
             OutputStreamWriter osw=new OutputStreamWriter(out);
             //字符缓冲流
             BufferedWriter bw=new BufferedWriter(osw);

             try {
                while((str=br.readLine())!=null){
                    if("over".equals(str)){
                      break;
                 }else{
                     //写进内存
                     bw.write(str.toUpperCase());
                    //写入换行
                     bw.newLine();
                     //刷进去
                     bw.flush();
                 }
                }
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }finally{
                if(in!=null)
                    try {
                        in.close();
                    } catch (IOException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
            }
        }
}

---

键盘录入打印的底层写法

package com.itheima.luo;

import java.io.IOException;
import java.io.InputStream;

/**
 * 获得键盘输入打印
 * 
 * @author Administrator
 *
 */
public class InputStreamScanner {
       public static void main(String[] args) {
         // prilntMethod();
           System.out.println("请输入：");
          InputStream in = System.in; 
          StringBuilder sb=new StringBuilder();
          while(true){

              try {
                int len=in.read();
                if(len=='\r')
                    continue;
                if(len=='\n'){
                    String str=sb.toString();
                    if("over".equals(str)){
                        //System.out.println("=======");
                        break;
                    }else{
                    System.out.println(str.toUpperCase());
                    //清空StringBuilder
                    sb.delete(0, sb.length());
                }
                }else{
                //拼接                                
                sb.append((char)len);
                }
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
          }


    }


    //第一种获得键盘录入输出的方法
    private static void prilntMethod() {
        System.out.println("请输入：");
           //标准的键盘输入流,是字节流
           InputStream in = System.in;

           int  len=-1;
           try {
            while((len=in.read())!=-1){
                //一个一个的打印
                System.out.println((char)len);
               }
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

生活的窘迫是我坚持不懈的理由~~~~~~~~