36.InputStream OutputStream

时间：2018-01-23 20:47:11 阅读：256 评论：0 收藏：0 [点我收藏+]

字符流：
FileReader
FileWriter

BufferedReader
BufferedWriter

字节流：
InputStream 读
OutputStream 写

public class FileStream_08 {

    public static void main(String[] args) throws IOException {
        // TODO Auto-generated method stub
        
        //writeFile();
        
        //readFile_1();
        
        //readFile_2();
        
        readFile_3();
    }
    
    //一个一个读
    public static void readFile_1() throws IOException{
        FileInputStream fis=new FileInputStream("d:\\demo.txt");
        
        int ch=0;
        
        while((ch=fis.read())!=-1){
            System.out.println((char)ch);
        }
        
        fis.close();
    }
    
    //数组读
    public static void readFile_2() throws IOException{
        FileInputStream fis=new FileInputStream("d:\\demo.txt");
        
        byte [] buf=new byte[3];
        
        int len=0; 
        
        while((len=fis.read(buf))!=-1){
            System.out.println(new String(buf,0,len));
        }
    }
    
    //inputStream特有的读法
    public static void readFile_3() throws IOException{
        FileInputStream fis=new FileInputStream("d:\\demo.txt");
        
        int num=fis.available();
        
        byte [] buf=new byte[num]; //一个刚刚好的缓冲区，不用循环了
        
        fis.read(buf);
        
        System.out.println("num="+num);
        System.out.println(new String(buf));
    }
    
    
    public static void writeFile() throws IOException{
        FileOutputStream fos=new FileOutputStream("d:\\fos.txt");
        
        fos.write("abcde".getBytes());
        
        fos.close();
    }

}

复制一张图片

思路：
1.用字节读取流和图片关联
2.用字节写入流对象创建一个图片文件，用于存储获取到的图片数据
3.通过循环读写，完成数据的存储
4.关闭你资源

public class CopyPic_09 {

    public static void main(String[] args) throws IOException  {
        // TODO Auto-generated method stub

        FileOutputStream fos=null; //输出流  写入
        FileInputStream fis=null;  //输入流 读取
        
        try {
            
            fis=new FileInputStream("e:\\myphoto.jpg");
            
            fos=new FileOutputStream("d:\\copy.jpg");
            
            byte [] buf=new byte[1024];
            
            int num=0;
            
            while((num=fis.read(buf))!=-1){
                fos.write(buf);
            }
            
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            throw new RuntimeException("复制文件失败");
        }finally{
            if(fos!=null){
                try {
                    fos.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    throw new RuntimeException("写入关闭失败");
                }
            }
            if(fis!=null){
                try {
                    fis.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    throw new RuntimeException("读取关闭失败");
                }
            }
        }
    }

}

字节流的缓冲区：
mp3的复制，通过缓冲区

public class Copy_10 {

    public static void main(String[] args) throws IOException {
        // TODO Auto-generated method stub
        long start=System.currentTimeMillis();
        copy_1();
        long end=System.currentTimeMillis();
        System.out.println((end-start));
    }

    //通过字节流的缓冲区完成复制
    public static void copy_1() throws IOException{
        
        BufferedInputStream bis=new BufferedInputStream(new FileInputStream("e:\\Trouble Is A Friend.mp3"));
        
        BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream("d:\\copy.mp3"));
        
        int by=0;
        while((by=bis.read())!=-1){
            bos.write(by);
        }
        
        bis.close();
        bos.close();
    }
}

读取键盘录入
System.out:对应的是标准输出设备，控制台
System.in:对应的标准输入设备，键盘

需求:通过键盘录入数据。
当录入一行数据后，就将该行数据进行打印。
如果录入的数据是over,那么停止录入。

通过键盘录入一行数据并打印其大写，发现其实就是读一行数据的原理。readLine

能不能直接使用readLine方法来完成键盘录入一行数据的读写？

readLine方法是字符流BufferedReader类中的方法，
而键盘录入的read方法是字节流InputStream的方法。

那么能不能将字节流转成字符流再使用字符流缓冲区的方法呢？

public class ReadIn_12 {

    public static void main(String[] args) throws IOException {
        // TODO Auto-generated method stub

            InputStream in=System.in;
            
            /*int by=in.read();  //只读第一个
            
            System.out.println(by);*/
            
            StringBuffer sb=new StringBuffer();
            
            while(true){
                int ch=in.read(); 
                
                if(ch==‘\r‘){
                    continue;
                }
                
                if(ch==‘\n‘){
                    String s=sb.toString();  //缓冲区变成字符串
                    
                    if("over".equals(s)){
                        break;
                    }
                    
                    System.out.println(s.toUpperCase());
                    
                    sb.delete(0,sb.length()); //打印完后对缓存区清空一次
                }else{
                    sb.append((char)ch);
                }
            }
    }

}

InputStreamReader 是字节流通向字符流的桥梁

public class InputStreamReader_13 {

    public static void main(String[] args) throws IOException {
        // TODO Auto-generated method stub

        //获取键盘录入对象
        InputStream in=System.in;
        
        //将字节流对象转成字符流对象，使用转换流，InputStreamReader
        InputStreamReader isr=new InputStreamReader(in);
        
        //为了提高效率，将字符串进行缓冲区技术高效操作，使用BufferedReader
        BufferedReader bufr=new BufferedReader(isr);
        
        String line=null;
        
        while((line=bufr.readLine())!=null){
            if("over".equals(line)){
                break;
            }
            System.out.println(line.toUpperCase());
        }

    }

}

OutputStreamWriter 是字符流通向字节流的桥梁

public class OutputStreamWriter_14 {

    public static void main(String[] args) throws IOException {
        // TODO Auto-generated method stub

        OutputStream out=System.out; //返回 PrintStream，是OutputStream子类
        
        OutputStreamWriter osw=new OutputStreamWriter(out);
        
        BufferedWriter bufw=new BufferedWriter(osw);
        
        InputStream in=System.in;
        InputStreamReader isr=new InputStreamReader(in);
        BufferedReader bufr=new BufferedReader(isr);
        
        String line=null;
        
        while((line=bufr.readLine())!=null){
            if("over".equals(line)){
                break;
            }
            bufw.write(line.toUpperCase());
            bufw.newLine();
            bufw.flush(); //字符输出流内部有缓冲区
        }
    }
}

1.
源：键盘录入
目的：控制台

2.需求：把键盘录入的数据存储到一个文件中
源：键盘录入
目的：文件

3.需求：想要将一个文件的数据打印在控制台上
源:文件
目的：控制台

流操作的基本规律：
最痛苦的就是流对象有很多，不知道该用哪个。
通过三个明确来完成。
1.明确源和目的
源：输入流
目的：输出流
2.明确操作的数据是否是纯文本
是：字符流
不是：字节流
3.当体系明确后，再明确要使用哪个具体的对象。通过设备来进行区分。
源设备：内存硬盘键盘
目的设备：内存硬盘控制台

public class TransStreamDemo1_15 {

    public static void main(String[] args) throws IOException {
        // TODO Auto-generated method stub
        
        //method_1();
        
        //method_2();
        
        method_3();

    }

    //键盘录入--控制台
    public static void method_1() throws IOException{
        InputStream in=System.in;
        InputStreamReader isr=new InputStreamReader(in);
        BufferedReader bufr=new BufferedReader(isr);
        
        OutputStream out=System.out;
        OutputStreamWriter osw=new OutputStreamWriter(out);
        BufferedWriter bufw=new BufferedWriter(osw);
        
        String line=null;
        while((line=bufr.readLine())!=null){
            if("over".equals(line)){
                break;
            }
            
            bufw.write(line.toUpperCase());
            bufw.newLine();
            bufw.flush();
        }
        
        bufr.close();
        bufw.close();
    }
    
    //键盘--文件
    public static void method_2() throws IOException{
        InputStream in=System.in;
        InputStreamReader isr=new InputStreamReader(in);
        BufferedReader bufr=new BufferedReader(isr);
        
        OutputStream out=new FileOutputStream("d:\\newCopy.txt");
        OutputStreamWriter osw=new OutputStreamWriter(out);
        BufferedWriter bufw=new BufferedWriter(osw);
        
        String line=null;
        while((line=bufr.readLine())!=null){
            if("over".equals(line)){
                break;
            }
            
            bufw.write(line.toUpperCase());
            bufw.flush();
            bufw.newLine();
        }
        
        bufr.close();
        bufw.close();
    }

    //文件--控制台
    public static void method_3() throws IOException{
        
        OutputStream out=System.out;
        OutputStreamWriter osw=new OutputStreamWriter(out);
        BufferedWriter bufw=new BufferedWriter(osw);
        
        FileInputStream fis=new FileInputStream("d:\\buf.txt");
        InputStreamReader isr=new InputStreamReader(fis);
        BufferedReader bufr=new BufferedReader(isr);
        
        String line=null;
        while((line=bufr.readLine())!=null){
            bufw.write(line.toUpperCase());
            bufw.flush();
            bufw.newLine();
        }
        
        bufr.close();
        bufw.close();
    }
}

36.InputStream OutputStream

标签：缓冲设备通过 == nal cep 高效创建缓存

原文地址：https://www.cnblogs.com/syj1993/p/8337167.html

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)

周排行