zoukankan      html  css  js  c++  java
  • java 流

    按照处理数据单位不同可以分为:字节流和字符流。

    字节流和字符流的原理是相同的,只不过处理的单位不同而已,字节流、字符流,两类都分为输入和输出操作。

    字符输入流、字符输出流、字节输入流、字节输出流是java中io中常用的流。

    1.在字节流中输出数据主要是使用OutputStream完成,输入流使用的是InputStream。

    输出流OutputStream

    复制代码
            String a = "d:\bbb.txt";
            File f = new File(a);
            FileOutputStream b = new FileOutputStream(f,true);//可以不加true,但是会覆盖原来的内容,加上true之后会在原来内容的后边插入
            String c = "这是要输出到文本的内容";
            byte[] bbb = c.getBytes();  //字符串转类型换为byte[]数组类型
            b.write(bbb);
            b.close();      
    复制代码

    输入流InputStream

    复制代码
            String a = "d:\bbb.txt";
            File f = new File(a);
            FileInputStream b =  new FileInputStream(f);
            byte[] bbb = new byte[(int)(f.length())];//直接截取文件的长度
            b.read(bbb);
            b.close();
            String str = new String(bbb);//转换成字符串
            System.out.println(str);
    复制代码

    2.在字符流中输出主要是使用Writer类完成,输入流主要使用Reader类完成。(这四个都是抽象类)。

    输出流Writer

            String a = "d://bbb.txt";
            File f = new File(a);
            FileWriter c = new FileWriter(f,true);//不加true会覆盖之前内容,加上后会在后面写
            c.write("这是要输入的内容");//可以直接用字符串,不用转换(写文本类型推荐使用)
            c.close();   

    输入流Reader

    复制代码
            String aa ="d:\bbb.txt";
            File bb =new File(aa);
            FileReader cc = new FileReader(bb);
            char[] dd  = new char[100];//长度不容易把握
            cc.read(dd);
            cc.close();
            String str = new String(dd);//转换为字符串
            System.out.println(str) 
    复制代码

    既然Reader去长度不好用,我们还可以用Scanner(推荐)

    复制代码
            String a = "d:\bbb.txt";
            File b = new File(a);
            Scanner sc = new Scanner(b);

    //Scanner每次只能取一行,所以全部取出要用while循环 while(sc.hasNext()){ //当还有下个值的时候循环 System.out.println(sc.nextLine()); } sc.close();
    java缓冲流本身不具IO功能,只是在别的流上加上缓冲提高效率,像是为别的流装上一种包装。当对文件或其他目标频繁读写或操作效率低,效能差。这时使用缓冲流能够更高效的读写信息。因为缓冲流先将数据缓存起来,然后一起写入或读取出来。所以说,缓冲流还是很重要的,在IO操作时记得加上缓冲流提升性能。
           缓冲流分为字节和字符缓冲流
    字节缓冲流为:
    BufferedInputStream—字节输入缓冲流
    BufferedOutputStream—字节输出缓冲流
    字符缓冲流为:
    BufferedReader—字符输入缓冲流
    BufferedWriter—字符输出缓冲流
    下面主要介绍这四种缓冲流的使用。
    一.字节缓冲流
    1.BufferedOutputStream—字节输出缓冲流
          BufferedOutputStream类实现缓冲的输出了,通过设置这种输出流,应用程序就可以将各个字节写入底层输出流中,而不必每一个字节写入都调用底层系统。
     
    示例代码:

    public static void main(String[] args) {         

          try {  

        //创建字节输出流实例  

        OutputStream out=new FileOutputStream("L:\test.txt");  

        //根据字节输出流构建字节缓冲流  

        BufferedOutputStream buf=new BufferedOutputStream(out);  

        String data="好好学习,天天向上";  

        buf.write(data.getBytes());//写入缓冲区  

        buf.flush();//刷新缓冲区,即把内容写入  

        //关闭流  

        buf.close();//关闭缓冲流时,也会刷新一次缓冲区  

        out.close();  

    } catch (IOException e) {  

        e.printStackTrace();  

    }  

       }   2.BufferedInputStream—字节输入缓冲流

           BufferedInputStream为别的输入流添加缓冲功能,在创建BufferedInputStream时会创建一个内部缓冲数组,用于缓冲数据,提高性能。
     
    示例代码:

    public static void main(String[] args) {         

           try {  

            //创建字节输入流实例  

            InputStream in=new FileInputStream("L:\test.txt");  

            //根据字节输入流构建字节缓冲流  

            BufferedInputStream buf=new BufferedInputStream(in);  

            byte[]bytes=new byte[1024];  

            //数据读取  

            int len=-1;  

            StringBuffer  sb=new StringBuffer();  

            while((len=buf.read(bytes))!=-1)  

            {  

                sb.append(new String(bytes,0,len));  

            }  

            System.out.println("内容为:"+sb);  

            //关闭流  

            buf.close();  

            in.close();  

        } catch (IOException e) {  

            e.printStackTrace();  

        }  

        }   

    二.字符缓冲流
     
    1.BufferedWriter—字符输出缓冲流
        将文本写入字符输出流,缓冲各个字符,从而提供高效的写入。可以指定缓冲区的大小,一般情况下,默认的缓冲区大小就足够了。
     
    示例代码:

    public static void main(String[] args) {  

        try {  

            Writer w=new FileWriter("L:\test.txt");  

            //根据字符输出流创建字符缓冲流  

            BufferedWriter buf=new BufferedWriter(w);  

            //写入数据  

            buf.write("只要功夫深铁杵磨成针");  

            //刷新流  

            buf.flush();  

            //关闭流  

            buf.close();  

            w.close();  

        } catch (IOException e) {  

            e.printStackTrace();  

        }  

       }  

    2.BufferedReader—字符输入缓冲流
             从字符输入流中读取信息,缓冲各个字符,从而实现高效读取。可以指定缓冲区的大小,一般情况下,默认的缓冲区大小就足够了。默认大小为8192.
    示例代码:

    public static void main(String[] args) {  

            try {  

                Reader r=new FileReader("L:\test.txt");  

                //根据字符输入流创建字符缓冲流  

                BufferedReader buf=new BufferedReader(r);  

                char [] data=new char[512];  

                //数据读取  

                int len=-1;  

                StringBuilder sb=new StringBuilder();  

                while((len=buf.read(data))!=-1)  

                {  

                    sb.append(new String(data,0,len));  

                }  

                System.out.println("内容是: "+sb);  

                //关闭流  

                buf.close();  

                r.close();  

            } catch (IOException e) {  

                e.printStackTrace();  

            }  

        }   

    java缓冲流本身不具IO功能,只是在别的流上加上缓冲提高效率,像是为别的流装上一种包装。当对文件或其他目标频繁读写或操作效率低,效能差。这时使用缓冲流能够更高效的读写信息。因为缓冲流先将数据缓存起来,然后一起写入或读取出来。所以说,缓冲流还是很重要的,在IO操作时记得加上缓冲流提升性能。
           缓冲流分为字节和字符缓冲流
    字节缓冲流为:
    BufferedInputStream—字节输入缓冲流
    BufferedOutputStream—字节输出缓冲流
    字符缓冲流为:
    BufferedReader—字符输入缓冲流
    BufferedWriter—字符输出缓冲流
    下面主要介绍这四种缓冲流的使用。
    一.字节缓冲流
    1.BufferedOutputStream—字节输出缓冲流
          BufferedOutputStream类实现缓冲的输出了,通过设置这种输出流,应用程序就可以将各个字节写入底层输出流中,而不必每一个字节写入都调用底层系统。
     
    示例代码:
    1. public static void main(String[] args) {         
    2.       try {  
    3.     //创建字节输出流实例  
    4.     OutputStream out=new FileOutputStream("L:\test.txt");  
    5.     //根据字节输出流构建字节缓冲流  
    6.     BufferedOutputStream buf=new BufferedOutputStream(out);  
    7.       
    8.     String data="好好学习,天天向上";  
    9.     buf.write(data.getBytes());//写入缓冲区  
    10.     buf.flush();//刷新缓冲区,即把内容写入  
    11.     //关闭流  
    12.     buf.close();//关闭缓冲流时,也会刷新一次缓冲区  
    13.     out.close();  
    14.       
    15. } catch (IOException e) {  
    16.     e.printStackTrace();  
    17. }  
    18.     
    19.    }   
    2.BufferedInputStream—字节输入缓冲流
           BufferedInputStream为别的输入流添加缓冲功能,在创建BufferedInputStream时会创建一个内部缓冲数组,用于缓冲数据,提高性能。
     
    示例代码:
    1. public static void main(String[] args) {         
    2.        try {  
    3.         //创建字节输入流实例  
    4.         InputStream in=new FileInputStream("L:\test.txt");  
    5.         //根据字节输入流构建字节缓冲流  
    6.         BufferedInputStream buf=new BufferedInputStream(in);  
    7.           
    8.         byte[]bytes=new byte[1024];  
    9.         //数据读取  
    10.         int len=-1;  
    11.         StringBuffer  sb=new StringBuffer();  
    12.         while((len=buf.read(bytes))!=-1)  
    13.         {  
    14.             sb.append(new String(bytes,0,len));  
    15.         }  
    16.         System.out.println("内容为:"+sb);  
    17.         //关闭流  
    18.         buf.close();  
    19.         in.close();  
    20.           
    21.           
    22.     } catch (IOException e) {  
    23.         e.printStackTrace();  
    24.     }  
    25.      
    26.     }  
    二.字符缓冲流
     
    1.BufferedWriter—字符输出缓冲流
        将文本写入字符输出流,缓冲各个字符,从而提供高效的写入。可以指定缓冲区的大小,一般情况下,默认的缓冲区大小就足够了。
     
    示例代码:
    1. public static void main(String[] args) {  
    2.       
    3.     try {  
    4.         Writer w=new FileWriter("L:\test.txt");  
    5.         //根据字符输出流创建字符缓冲流  
    6.         BufferedWriter buf=new BufferedWriter(w);  
    7.         //写入数据  
    8.         buf.write("只要功夫深铁杵磨成针");  
    9.         //刷新流  
    10.         buf.flush();  
    11.         //关闭流  
    12.         buf.close();  
    13.         w.close();  
    14.     } catch (IOException e) {  
    15.         e.printStackTrace();  
    16.     }  
    17.       
    18.     
    19.    }  
    2.BufferedReader—字符输入缓冲流
             从字符输入流中读取信息,缓冲各个字符,从而实现高效读取。可以指定缓冲区的大小,一般情况下,默认的缓冲区大小就足够了。默认大小为8192.
    示例代码:
    1. public static void main(String[] args) {  
    2.           
    3.         try {  
    4.             Reader r=new FileReader("L:\test.txt");  
    5.             //根据字符输入流创建字符缓冲流  
    6.             BufferedReader buf=new BufferedReader(r);  
    7.               
    8.             char [] data=new char[512];  
    9.             //数据读取  
    10.             int len=-1;  
    11.             StringBuilder sb=new StringBuilder();  
    12.             while((len=buf.read(data))!=-1)  
    13.             {  
    14.                 sb.append(new String(data,0,len));  
    15.             }  
    16.             System.out.println("内容是: "+sb);  
    17.             //关闭流  
    18.             buf.close();  
    19.             r.close();  
    20.         } catch (IOException e) {  
    21.             e.printStackTrace();  
    22.         }  
    23.           
    24.      
    25.     }   
  • 相关阅读:
    VC 使用json cpp 静态库 问题解决
    <转>c++ builder JSONCPP 注意事项 XE2 解决编译问题 _Mfl
    窥探try ... catch与__try ... __except的区别
    二叉树与其它树
    《DirectX 9.0 3D游戏开发编程基础》 第二章 绘制流水线 读书笔记
    《DirectX 9.0 3D游戏开发编程基础》 第一章 初始化Direct3D 读书笔记
    《DirectX 9.0 3D游戏开发编程基础》必备的数学知识 读书笔记
    windows lua 多线程 线程同步
    <转>多线程中的lua同步问题
    php 检查email电子邮件函数(奇葩写法)
  • 原文地址:https://www.cnblogs.com/dnf1612/p/6277877.html
Copyright © 2011-2022 走看看