码迷,mamicode.com
首页 > 其他好文 > 详细

IO流

时间:2014-11-16 09:18:47      阅读:261      评论:0      收藏:0      [点我收藏+]

标签:style   blog   io   color   ar   os   使用   sp   java   

 

    IO流

  •         概念
    1.             字节流     //主要使用于音频,视频,图片
    2.             字符流     //主要使用于文本,在内部转为字节流保存,字节流的子类
    3.             名称     //后缀名是父类名,前缀名时该流对象的功能
    4.             throws IOException      //抛出的异常
    5.             复制文件

                1:创建一个文件,用于储存被复制文件的数据
                2:定义读取流与被复制文件关联
                3:通过不断读写完成数据储存
                4:关闭资源
                直接复制例子

 1                     FileWirter Fw = null;
 2                     FileReader Fr = null;
 3                     try{
 4                         fw = new FileWirter("demo_copy.txt");     //创建文件
 5                         fr = new FileReader("demo.txt");     //关联文件
 6                         int len = 0;
 7                         char[] ch = new char[1024];
 8                         while((len=fr.read(ch)) != -1){        //判断文件是否到达末尾
 9                             fw.write(ch, 0, len);                  //写入文件有效数据
10                             fw.flush()}                              //刷新文件缓冲区
11                     }catch( IOException e ){                   //若错误,抛出异常
12                         throw new RuntimeException("读写失败");
13                     }finally{                     //肯定执行的文件,用于关闭文件流
14                         try{                       //每个没见流都需要一个try{}来关闭
15                             if(fw != null)
16                                 fw.close();
17                         }catch( IOException e ){
18                             throw new RuntimeException("写入关闭失败");
19                         }try{
20                             if(fr != null)
21                                 fr.close();
22                         }catch( IOException e ){
23                             throw new RuntimeException("读取关闭失败");
24                         }
25                     }

 



                缓冲复制例子

 1                     BufferedWriter bufferedFw = null;
 2                     ButteredReader butteredFr = null;
 3                     try{
 4                          bufferedFw = new BufferedWirter(new FileWriter("demo_capy.txt") );
 5                          butteredFr = new ButteredReader(new FileReader("demo.txt"));
 6                         String line =null;
 7                         while((line=bufferedFr.readLine()) != null){        //判断行是否为空
 8                             bufferedFw.write(line);             //写入行
 9                             bufferedFw.newLine();             //换行
10                             butteredFw.flush();                  //刷新缓冲区
11                         }
12                     }catch(IOException e){
13                         throw new RuntimeException("读写失败");
14                     }finally{
15                         try{
16                             if(bufferedFw != null)
17                                 bufferedFw.close()
18                         }catch(IOException e){
19                             throw new RuntimeException("写入关闭失败");
20                         }try{
21                             if(bufferedFr != null)
22                                 bufferedFr.close()
23                         }catch(IOException e){
24                             throw new RuntimeException("读取关闭失败");
25                         }
26                     }

 


            换行
                windows,记事本下 "\r\n" 是一个换行符
                Linux,"\n"就是一个换行符

  •         字符流

            Reader     //读取

                FileReader      //文件读取

          FileReader fr = new FileReader("demo.txt");       //使用方式,
          若文件不存在抛出异常 FileNotFoundException
          固定了使用的编码表,GBK
                方法
                    int read()           //读取单个字符。
                        FileReader fr = new FileReader("demo.txt");
                        fr.read();              //使用方式,读取一个字符,将指针往后移一位
                    int read(char[] cbuf)      //读取数组字符,返回读取个数
                    long skip(long n)   //跳过字符
                    void close()         //关闭该流并释放与之关联的所有资源。
                BufferedReader     //缓冲读取,体改效率

          FileReader fr = new FileReader("demo.txt");
          BufferedReader bufferedFr = new BufferedReader(fr);      //使用方式,传入需要体改效率的对象
          bufferedFw.close();               //关闭缓冲区就等于关闭文件流对象
          BufferedReader(Reader in, int sz)         //第二个参数为指定缓冲区的大小
                    特有方法
                        String readLine()     //读取一个文本行。到结束时返回null
                    LineNumberReader       //跟踪行号的缓冲字符输入流。

          FileReader fr = new FileReader("demo.txt");
          LineNumberReader lnr = new LineNumberReader(fr);        //使用方式


                        int getLineNumber()         // 获得当前行号。
                        void setLineNumber(int lineNumber)       //设置当前行号。

1                         LineNumberReader例子:
2                             FileReader fr = new FileReader("demo.txt");
3                             LineNumberReader lnr = new LineNumberReader(fr);
4                             String line = null;
5                             lnr.setLineNumber(100);                  //第一行为101,第二行为102;
6                             while((line=lnr.readLine) != -1){
7                                 System.out.println(lnr.getLineNumber()+" : "+line)}

 

 

1                     BufferedReader例子
2                         public static void main(String[] args) throws Exception {
3                                     BufferedReader bufr = new BufferedReader(new FileReader("E:\\Computer\\Java\\小记2\\类的唯一性.txt"));
4                                     String line = null;
5                                     while((line=bufr.readLine())!=null){
6                                         System.out.println(line);
7                                     }
8                                 }

 


                                            InputStreamReader    //转换流,将字节流转为字符流
                                                BufferedReader bufr = new BufferedReader(
                                           new InputStreamReader(System.in));    //输入

 1                                                     //将输入的字符串显示在控制台
 2                             BufferedReader br = new BufferedReader(
 3                                            new InputStreamReader
 4                                            (System.in));    //输入,这是源,根据需求可以改为new FileInputStream("demo.txt")
 5                             BufferedWirter br = new BufferedWirter(
 6                                            new OutputStreamWirter
 7                                           (System.out));  //这是目的,根据需求可以改为new FileOutputStream("demo.txt")
 8                             String line = null;
 9                             while((line=bufr.readLine()) != null){
10                                 if(line.equals("over"))
11                                     break;
12                                 bufw.write(line);                //输出输入的一行
13                                 bufw.newLine();                //新的一行
14                                  bufw.fuush();                   //刷新缓冲区
15                             }

 

 

  •             Wirter    //写入

                FileWirter      //文件写入
                方法
                    void write(String str)   //写入字符串。
                    void flush()     //刷新该流的缓冲。
                    void close()    //关闭该流,关闭前刷新该流
                BufferedWriter      //写入缓冲区,提高效率
                    特有方法
                        void newLine()    //写入一个行分隔符。
                OutputStreamWriter     //OutputStreamWriter 是字符流通向字节流的桥梁:可使用指定的 charset 将要写入流中的字符编码成字节。

 1                                         //将输入的字符串显示在控制台
 2                     BufferedReader br = new BufferedReader(
 3                                    new InputStreamReader
 4                                    (System.in));    //输入,这是源,根据需求可以改为new FileInputStream("demo.txt")
 5                     BufferedWirter br = new BufferedWirter(
 6                                    new OutputStreamWirter
 7                                   (System.out));  //这是目的,根据需求可以改为new FileOutputStream("demo.txt")
 8                     String line = null;
 9                     while((line=bufr.readLine()) != null){
10                         if(line.equals("over"))
11                             break;
12                         bufw.write(line);                //输出输入的一行
13                         bufw.newLine();                //新的一行
14                          bufw.fuush();                   //刷新缓冲区
15                     }

 

 

  •         字节流

            InputStream     //输入流(读取)
                FileInputStream     //文件输入流
                方法
                    int available()     //返回文件的字节数,
                    void close()      //关闭输入流,释放资源
                    int read()       //读取下一字节

返回值是 int 类型是为了避免-1的发生
-1在字节(8位)中显示  11111111
转为 int 类型也是-1
11111111 11111111 11111111 11111111     
如何让byte类型转化为int时前面+0而不是+1,
用&
   11111111 11111111 11111111 11111111
&00000000 00000000 00000000 11111111
--------------------------------------------------------
  00000000 00000000 00000000 11111111
所以在源代码中 return byte&0xFF           //0xFF为16进制的255,(11111111为二进制的255)

 


                    long skip(long n)       //跳过和丢弃此输入流中数据的 n 个字节。
                SequenceInputStream  //合并文件流
            OutputStream     //输出流(写入)
                FileOutputStream      //文件输出流
                方法
                    void write(byte[] b)     //将 b.length 个字节从指定的 byte 数组写入此输出流。
                    void flush()        //刷新此输出流并强制写出所有缓冲的输出字节。
                    void close()          //关闭此输出流并释放与此流有关的所有系统资源。

  •         异常的处理方式
 1 FileWirter fw = null;
 2 try{
 3     fw = new FileWirter("demo.txt");
 4     fw.write("abcd");
 5 }cath  (  IOException e  ){
 6     thow new RuntimeException("读写失败");
 7 }finally{
 8     try{
 9         if( fw!=null )         //若前面抛出异常,则不执行close
10             fw.close();}
11     cath(   IOException e  ){}
12 }

 

 

  •         流的操作规律:

            想要知道开发时用到哪些对象。只要通过四个明确即可。

  1 1,明确源和目的(汇)
  2     源:InputStream  Reader
  3     目的:OutputStream  Writer
  4 
  5 2,明确数据是否是纯文本数据。
  6     源:是纯文本:Reader
  7         否:InputStream
  8     目的:是纯文本 Writer
  9         否:OutputStream
 10 
 11     到这里,就可以明确需求中具体要使用哪个体系。
 12 
 13 3,明确具体的设备。
 14     源设备:
 15         硬盘:File
 16         键盘:System.in
 17         内存:ArrayStream
 18         网络:Socket流
 19 
 20     目的设备:
 21         硬盘:File
 22         控制台:System.out
 23         内存:ArrayStream
 24         网络:Socket流
 25 
 26 4,是否需要其他额外功能。
 27     1,是否需要高效(缓冲区);
 28         是,就加上buffer.
 29     2,转换。
 30 
 31 需求1:复制一个文本文件。
 32     1,明确源和目的。
 33         源:InputStream Reader
 34         目的:OutputStream  Writer
 35     2,是否是纯文本?
 36         是!
 37         源:Reader
 38         目的:Writer
 39 
 40     3,明确具体设备。
 41         源:
 42             硬盘:File
 43         目的:
 44             硬盘:File
 45 
 46         FileReader fr = new FileReader("a.txt");
 47         FileWriter fw = new FileWriter("b.txt");
 48 
 49     4,需要额外功能吗?
 50         需要,需要高效。
 51         BufferedReader bufr = new BufferedReader(new FileReader("a.txt"));
 52         BufferedWriter bufw = new BufferedWriter(new FileWriter("b.txt"));
 53 
 54 需求2:读取键盘录入信息,并写入到一个文件中。
 55 
 56     1,明确源和目的。
 57         源:InputStream Reader
 58         目的:OutputStream  Writer
 59     2,是否是纯文本呢?
 60         是,
 61         源:Reader
 62         目的:Writer
 63     3,明确设备
 64         源:
 65             键盘。System.in
 66         目的:
 67             硬盘。File
 68 
 69         InputStream in = System.in;
 70         FileWriter fw = new FileWriter("b.txt");
 71         这样做可以完成,但是麻烦。将读取的字节数据转成字符串。再由字符流操作。
 72     4,需要额外功能吗?
 73         需要。转换。    将字节流转成字符流。因为名确的源是Reader,这样操作文本数据做便捷。
 74             所以要将已有的字节流转成字符流。使用字节-->字符 。InputStreamReader
 75         InputStreamReader isr = new InputStreamReader(System.in);
 76         FileWriter fw = new FileWriter("b.txt");
 77 
 78         还需要功能吗?
 79         需要:想高效。
 80         BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
 81         BufferedWriter bufw = new BufferedWriter(new FileWriter("b.txt"));
 82 
 83 
 84 
 85 需求3:将一个文本文件数据显示在控制台上。
 86     1,明确源和目的。
 87         源:InputStream Reader
 88         目的:OutputStream  Writer
 89     2,是否是纯文本呢?
 90         是,
 91         源:Reader
 92         目的:Writer
 93     3,明确具体设备
 94         源:
 95             硬盘:File
 96         目的:
 97             控制台:System.out
 98 
 99         FileReader fr = new FileReader("a.txt");
100         OutputStream out = System.out;//PrintStream
101     4,需要额外功能吗?
102         需要,转换。
103         FileReader fr= new FileReader("a.txt");
104         OutputStreamWriter osw = new OutputStreamWriter(System.out);
105         需要,高效。
106         BufferedReader bufr = new BufferedReader(new FileReader("a.txt"));
107         BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(System.out));
108 
109 
110 需求4:读取键盘录入数据,显示在控制台上。
111     1,明确源和目的。
112         源:InputStream Reader
113         目的:OutputStream  Writer
114     2,是否是纯文本呢?
115         是,
116         源:Reader
117         目的:Writer
118     3,明确设备。
119         源:
120             键盘:System.in
121         目的:
122             控制台:System.out
123 
124         InputStream in = System.in;
125         OutputStream out = System.out;
126 
127     4,明确额外功能?
128         需要转换,因为都是字节流,但是操作的却是文本数据。
129         所以使用字符流操作起来更为便捷。
130         InputStreamReader isr = new InputStreamReader(System.in);
131         OutputStreamWriter osw = new OutputStreamWriter(System.out);
132 
133         为了将其高效。
134         BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
135         BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(System.out));

 



        将堆中的对象保存为本地文件
            java.io.ObjectInputStream    //对文件进行读取
            java.io.ObjectOutputStream        //写入对象
        操作基本数据类型对象
        随机访问文件的读取和写入。
            java.io.RandomAccessFile
                方法
                    增
                        void write(int b)
          向此文件写入指定的字节。
                        void writeBytes(String s)
          按字节序列将该字符串写入该文件。
                    删
                        void close()
          关闭此随机访问文件流并释放与该流关联的所有系统资源。
                    改
                        void seek(long pos)
          设置到此文件开头测量到的文件指针偏移量,在该位置发生下一个读取或写入操作。
                        void setLength(long newLength)
          设置此文件的长度。
                        int skipBytes(int n)
          尝试跳过输入的 n 个字节以丢弃跳过的字节。 (修改指针位置)
                    查
                        String readUTF()
          从此文件读取一个字符串。
                        int readUnsignedByte()
          从此文件读取一个无符号的八位数。
                        long getFilePointer()             //返回当前指针位置
                        long length()      //返回文件大小
                        int read()
          从此文件中读取一个数据字节。
                        int readInt()
       从此文件读取一个有符号的 32 位整数。
                        void readFully(byte[] b)
          将 b.length 个字节从此文件读入 byte 数组,并从当前文件指针开始。
                        void readFully(byte[] b, int off, int len)
          将正好 len 个字节从此文件读入 byte 数组,并从当前文件指针开始。

IO流

标签:style   blog   io   color   ar   os   使用   sp   java   

原文地址:http://www.cnblogs.com/sidianshui/p/4100983.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!