黑马程序员——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处理。

2、读取字符流步骤

        1）创建一个文件读取流对象，和指定名称的文件相关联。要保证该文件已经存在，若不存在，将会发生异常FileNotFoundException。

        2）调用读取流对象的read()方法。read()：一次读一个字符，且会继续往下读。

              第一种方式：读取单个字符。第二种方式：通过字符数组进行读取。

        3）读取后要调用close方法将流资源关闭。

示例：

 public static void singleCharReader()
        {
                FileReader fr = null;
                try
                {
                        fr = new FileReader("格式化数字.txt");
                        for (int ch=0;(ch=fr.read())!=-1 ; )
                        {
                                System.out.print(ch);
                        }
                }
                catch (IOException e)
                {
                        throw new RuntimeException("reading failure");
                }
                finally
                {
                        try
                        {
                                if(fr!=null)
                                        fr.close();
                        }
                        catch (IOException e)
                        {
                        }
                }
        }

        public static void arrayCharReader()
        {
                FileReader fr = null;
                try
                {
                        fr = new FileReader("格式化数字.txt");
                        char[] arr = new char[1024];//定义一个字符数组，通常大小为1024的整数倍。用于临时存储读取的字符  
                        for (int len=0;(len=fr.read(arr))!=-1 ; )//读到的字符被放入数组中，返回值为一次读到的个数
                        {
                              //显示字符数组的字符个数 
                              System.out.println(new String(arr,0,len));
                        }
                }
                catch (IOException e)
                {
                }
                finally
                {
                        if(fr!=null)
                                try
                                {
                                        fr.close();     
                                }
                                catch (IOException e)
                                {
                                }
                                
                }
}

由此可以看到，利用读取输出流复制文件能采用2中方式进行。

        public static void main(String[] args) throws IOException   
        {
                //charCopy();
                arrayCopy();
        }
        public static void charCopy()
        {
                FileReader fr = null;
                FileWriter fw = null;
                try
                {
                        fr = new FileReader("c:\\download\\格式化数字.txt");
                        fw = new FileWriter("e:\\download\\资料大全\\格式化数字.txt");
                        for(int ch =0;(ch = fr.read())!=-1;)
                                fw.write(ch);
                                
                }
                catch (IOException e)
                {
                }
                finally
                {
                        if (fr!=null)
                                try
                                {
                                        fr.close();
                                }
                                catch (IOException e)
                                {
                                }
                        if (fw!=null)
                        {
                                try
                                {
                                        fw.close();
                                }
                                catch (IOException e)
                                {
                                }
                        }
                }
        }
        
        public static void arrayCopy()
        {
                FileReader fr = null;
                FileWriter fw = null;
                try
                {
                        fr = new FileReader("c:\\download\\格式化数字.txt");
                        fw = new FileWriter("e:\\download\\資料大全\\格式化数字.txt");   
                        char[] arr = new char[1024];
                        int len = 0;
                        while( (len = fr.read(arr))!=-1)
                                fw.write(arr,0,len);
                        fw.write("copy complete");
                }
                catch (IOException e)
                {
                }
                finally
                {
                        if (fr!=null)
                                try
                                {
                                        fr.close();
                                }
                                catch (IOException e)
                                {
                                }
                        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();、

示例：通过缓冲区复制一个文本文件。

                BufferedWriter bfw = null;
                BufferedReader bfr = null;
                try
                {
                        bfw = new BufferedWriter(new FileWriter("格式化数数字_缓冲复制.txt"));
                        bfr = new BufferedReader(new FileReader("格式化数字.txt"));
                        for (String line=null;(line=bfr.readLine())!=null ; )
                        {
                                bfw.write(line);
                                bfw.newLine();
                                bfw.flush();
                        }
                }
                catch (IOException e)
                {
                        throw new RuntimeException("copy failure");
                }
                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的容器，最终可实现字符串的提取。

import java.io.*;
public class  testIO
{
        public static void main(String[] args)
        {
                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("读取流关闭失败");
                        }
                }
        }

}

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;
        }
        //覆写父类中的read方法
        public int read(char[] buf,int off,int len) throws IOException
        {
                return r.read(buf,off,len);
        }
        public void close() throws IOExceptino
        {
                r.close();
        }
}

第三节     字节流

一、概述

1、字节流和字符流的基本操作是相同的，但字节流还可以操作其他媒体文件。

2、由于媒体文件数据中都是以字节存储的，所以，字节流对象可直接将媒体文件的数据写入到文件中，而可以不用再进行刷流动作。

3、读写字节流：InputStream   输入流（读）

                             OutputStream  输出流（写）

4、为何不用进行刷流动作：

        因为字节流操作的是字节，即数据的最小单位，无需像字符流一样要进行转换为字节。所以可直接将字节数据写入到指定文件中。

5、InputStream特有方法：

        int available();//返回文件中的字节个数

注：可以利用此方法来指定读取方式中传入数组的长度，从而省去循环判断。但是如果文件较大，而虚拟机启动分配的默认内存一般为64M。当文件过大时，此数组长度所占内存空间就会溢出。所以，此方法慎用，当文件不大时，可以使用。

import java.io.*;
public class  testIO
{
        public static void main(String[] args)
        {
                //byteArrayCopy();
                availableCopy();        
        }
        
        public static void byteArrayCopy()
        {
                FileInputStream fis = null;
                FileOutputStream fos = null;
                try
                {
                        fis = new FileInputStream("C:\\Users\\Administrator\\Desktop\\ws.jpg");
                        fos = new FileOutputStream("C:\\Users\\Administrator\\Desktop\\ws_avcopy.jpg");
                        //利用数组的读取方式
                        byte[] b = new byte[1024];
                        for (int len=0;(len = fis.read(b))!=-1 ; )
                        {
                                fos.write(b,0,len);
                        }
                }
                catch (IOException e)
                {

                }
                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 availableCopy()
        {
                FileInputStream fis = null;
                FileOutputStream fos = null;
                try
                {
                        fis = new FileInputStream("C:\\Users\\Administrator\\Desktop\\ws.jpg");
                        fos = new FileOutputStream("C:\\Users\\Administrator\\Desktop\\ws_copy.jpg");   
                        byte[] b = new byte[fis.available()];
                        fis.read(b);
                        fos.write(b);
                }
                catch (IOException e)
                {
                }
                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即可。

import java.io.*;
public class  testIO
{
        public static void main(String[] args)
        {
                copy();
        }
        
        public static void copy()
        {
                BufferedOutputStream bout = null;
                MyBufferedInputStream mbin = null;
                try
                {
                        //关联复制文件输入流对象到缓冲区
                        mbin = new MyBufferedInputStream(new FileInputStream("C:\\Users\\Administrator\\Desktop\\ws.jpg"));
                        //指定文件黏贴位置的输出流对象到缓冲区
                        bout = new BufferedOutputStream(new FileOutputStream("C:\\Users\\Administrator\\Desktop\\ws_copy.jpg"));
                        int by=0;
                        while ((by=mbin.myRead())!=-1)
                        {
                                bout.write(by);
                        }
                }
                catch (IOException e)
                {
                        throw new RuntimeException("图片复制失败");
                }
                finally
                {
                        try  
            {  
                if(mbin!=null)  
                mbin.close();//关闭输入字节流  
            }  
                        catch(IOException e)  
                        {  
                                throw new RuntimeException("读取字节流关闭失败");  
                        }  
                        try  
                        {  
                                if(bout!=null)  
                                   bout.close();//关闭输出字节流  
                        }  
                        catch(IOException e)  
                        {  
                                throw new RuntimeException("写入字节流关闭失败");  
                        }  
                }       
        }
}

class MyBufferedInputStream
{
        private InputStream in;
        private byte[] by = new byte[1024];
        private int count = 0, pos = 0;//定义计数器和指针
        MyBufferedInputStream(InputStream in)
        {
                this.in = in;
        }

        public int myRead() throws IOException
        {
                if (count==0)
                {
                        count  = in.read(by);
                        if(count<0) //说明文件数据已全被取出
                                return -1;
                        pos  = 0;
                        byte b = by[pos];
                        count--;
                        pos++;
                        return b&255;
                }
                else if (count>0)
                {
                        byte b = by[pos];
                        count--;
                        pos++;
                        return b&0xff;
                }
                return -1;
        }

        public void close() throws IOException
        {
                in.close();
        }
}

第四节     流操作规律

一、键盘录入

1、标准输入输出流

        System.in：对应的标准输入设备，键盘。

        Ssytem.out：对应的是标准的输出设备，控制台。

        System.in的类型是InputStream.

        System.out的类型是PrintStream是OutputStream的子类FilterOutputStream的子类。

2、整行录入

       当使用输入流进行键盘录入时，只能一个字节一个字节进行录入。以下代码自定义了一个缓冲区将字节整行读入

                StringBuilder sb = new StringBuilder();
                while (true)
                {
                        int ch = in.read();
                        if (ch == ‘\r‘)
                                continue;
                        if (ch == ‘\n‘)
                        {
                                String str = sb.toString();
                                if("over".equals(str))
                                        break;
                                System.out.println(str.toUpperCase());
                                sb.delete(0,sb.length-1);
                        }
                        sb.append((char)ch);
                }  

这种正行录入的方式，和字符流读一行数据的原理是一样的。也就是readLine方法。那么能不能直接使用readLine方法来完成键盘录入的一行数据的读取呢？readLine方法是字符流BufferedReader类中方法。而键盘录入的read方法是字节流InputStream的方法。

那么能不能将字节流转成字符流再使用字符流缓冲区的readLine方法呢？这就需要用到转换流了。

3、转换流

3.1 转换流的由来：

       a、字符流与字节流之间的桥梁  b、方便了字符流与字节流之间的操作

转换流的应用：

      字节流中的数据都是字符时，转成字符流操作更高效。

3.2   InputStreamReader将字节流通向字符流

       a、获取键盘录入对象。

              InputStream in=System.in;

       b、将字节流对象转成字符流对象，使用转换流。

              InputStreamReaderisr=new InputStreamReader(in);

       c、为了提高效率，将字符串进行缓冲区技术高效操作。使用BufferedReader

              BufferedReaderbr=new BufferedReader(isr);

       //键盘录入最常见写法

              BufferedReaderin=new BufferedReader(new InputStreamReader(System.in));

3.3   OutputStreamWriter字符流通向字节流

       字符通向字节：录入的是字符，存到硬盘上的是字节。步骤和InputStreamReader转换流一样。

黑马程序员——IO流概述、字符流、字节流、流操作规律(一)

标签：

原文地址：http://www.cnblogs.com/tozr/p/4531752.html