黑马程序员--IO流学习笔记

 

--------- android培训、java培训、期待与您交流！ ---------

8 IO(Input Output)流

8.1 IO流入门

1，简单了解：

IO流用来处理设备之间的数据传输，Java中对数据的操作时通过流的方式，并且Java操作流的对象在IO包中。

2，流的分类：

• 流按操作数据分为：字节流与字符流。
• 流按方向来分：输入流与输出流。
• 字节流的抽象基类：InputStream，OutputStream
• 字符流的抽象基类：Reader，Writer
• 注：由这四个类派生出来的子类名称都是以其父类名作为子类名的后缀。
  如： InputSteam 的子类 FileInputStream,StringBufferInputStream等。
   如： Reader 的子类 BufferedReader，InputStreamReader等。

3，IO流是用于操作数据的，
那么数据的最常见体现形式是：文件。

 

那么先以操作文件为主来演示。

需求:在硬盘上，创建一个文件并写入一些文字数据。

找到一个专门用于操作文件的Writer子类对象。FileWriter。  后缀名是父类名。 前缀名是该流对象的功能。

主要步骤如下：

• 创建一个FileWriter对象。该对象一被初始化就必须要明确被操作的文件。
    而且该文件会被创建到指定目录下。如果该目录下已有同名文件，将被覆盖。
    其实该步就是在明确数据要存放的目的地。

　　FileWriter fw = new FileWriter("demo.txt");//明确被操作的文件demo.txt。

• 调用write方法，将字符串写入到流中。

　　fw.Write("abcd");

• 刷新流对象中的缓冲中的数据。将数据刷到目的文件中。

　　fw.flush();

• 关闭流资源，但是关闭之前会刷新一次内部的缓冲中的数据。将数据刷到目的地中。
  close和flush区别：flush刷新后，流可以继续使用，close刷新后，会将流关闭。

　　 fw.close();

import java.io.*;
class  FileWriterDemo
{
    public static void main(String[] args) throws IOException
    {
        //创建一个FileWriter对象。明确被操作的文件
        FileWriter fw = new FileWriter("demo.txt");

        //调用write方法，将字符串写入到流中。
        fw.write("abcde");

        //刷新流对象中的缓冲中的数据。
        //将数据刷到目的地中。
        //fw.flush();


        //关闭流资源，但是关闭之前会刷新一次内部的缓冲中的数据。
        fw.close();
    }
}

那又怎样像已知文件中添加数据可不是覆盖该文件呢？
已有文件的数据续写如下示例

import java.io.*;
class  FileWriterDemo3
{
    public static void main(String[] args) throws IOException
    {

        //传递一个true参数，代表不覆盖已有的文件。并在已有文件的末尾处进行数据续写。
        FileWriter fw = new FileWriter("demo.txt",true);

        fw.write("nihao\r\nxiexie");

        fw.close();
    }
}

 

4，IO异常处理方式，以程序示例

import java.io.*;

class  FileWriterDemo2
{
    public static void main(String[] args) 
    {
        FileWriter fw = null;//定义全局变量，保证各个模块都可以调用此对象
        try
        {
            fw = new FileWriter("demo.txt");//实现功能部分写在try块中
            fw.write("abcdefg");

        }
        catch (IOException e)
        {
            System.out.println("catch:"+e.toString());//捕捉异常写在catch块中
        }
        finally        //程序最后必须执行的操作的写在finally块中
        {
            try
            {
                if(fw!=null)//关闭之前先判断fw是否为空
                    fw.close();                
            }
            catch (IOException e)
            {
                System.out.println(e.toString());
            }
            
        }        

    }
}

5，类Reader，读取文件的内容

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

　　FileReader fr = new FileReader("demo.txt");//要确保demo.txt是已经存在的文件

• 读取方法一：调用读取流对象的read方法。
   read():一次读一个字符。而且会自动往下读，如果已经到达流的末尾，则返回-1；　　　　

　　  int ch = 0;

  　　while((ch=fr.read())!=-1)
  　　{
   　　　　System.out.println("ch="+(char)ch);
  　　}

• 读取方法二：通过字符数组进行读取

 　　定义一个字符数组。用于存储读到字符。
  　 该read(char[])返回的是读到字符个数。

　　char[] buf = new char[1024];//大小是1024的整数倍

　　由于read(char[]返回的是读到的字符个数，如果已到达流的末尾，则返回 -1

　　　int num = 0;
  　　while((num=fr.read(buf))!=-1)//判断是否到达流的末尾
  　　{
  　　 System.out.println(new String(buf,0,num));
  　　}

• 最后关闭流对象

　　fr.close();

　　两种读取方式示例

　　

class  FileReaderDemo
{
    public static void main(String[] args) throws IOException
    {
                               //创建流对象
        FileReader fr = new FileReader("demo.txt");

                               //方式一：读取单个字符
              int ch = 0;

        while((ch=fr.read())!=-1)
        {
            System.out.println(
        }


        //方式二：把字符读入数组

        
                                 char[] buf = new char[1024];

        int num = 0;
        while((num=fr.read(buf))!=-1)
        {
            System.out.println(new String(buf,0,num));
        }
        
                             //关闭流
                    fr.close();

    }
}

 

8.2 字符流的缓冲区

1，缓冲区了解

●缓冲区的出现提高了对数据的读写效率
●对应类
 BufferedWriter
 BufferedReader
●缓冲区要结合流才可以使用
●在流的基础上对流的功能进行了增强。

2，缓冲区使用示例

• 缓冲区的出现是为了提高流的操作效率而出现的。
• 所以在创建缓冲区之前，必须要先有流对象。
• 该缓冲区中提供了一个跨平台的换行符。newLine();
• 字符写入流缓冲区：BufferedWriter

import java.io.*;

class  BufferedWriterDemo
{
    public static void main(String[] args) throws IOException
    {
        //创建一个字符写入流对象。
        FileWriter fw = new FileWriter("buf.txt");

        //为了提高字符写入流效率。加入了缓冲技术。
        //只要将需要被提高效率的流对象作为参数传递给缓冲区的构造函数即可。
        BufferedWriter bufw = new BufferedWriter(fw);

        for(int x=1; x<5; x++)
        {
            bufw.write("abcd"+x);
            bufw.newLine();
            bufw.flush();
        }

        //记住，只要用到缓冲区，就要记得刷新。
        //bufw.flush();

        //其实关闭缓冲区，就是在关闭缓冲区中的流对象。
        bufw.close();
    }
}

• 字符读取流缓冲区：BufferedReader
• 该缓冲区提供了一个一次读一行的方法 readLine()，方便于对文本数据的获取。
• 当返回null时，表示读到文件末尾。
• readLine方法返回的时候只返回回车符之前的数据内容。并不返回回车符。

import java.io.*;

class  BufferedReaderDemo
{
    public static void main(String[] args) throws IOException
    {
        //创建一个读取流对象和文件相关联。
        FileReader fr = new FileReader("buf.txt");

        //为了提高效率。加入缓冲技术。将字符读取流对象作为参数传递给缓冲对象的构造函数。
        BufferedReader bufr = new BufferedReader(fr);
        

        String line = null;

        while((line=bufr.readLine())!=null)
        {
            System.out.print(line);
        }


        bufr.close();
    }

}

3，简介装饰设计模式与继承

装饰类：当想要对已有对象进行功能增强时，可以定义列，将已有对象传入，

基于已有功能，并提供加强功能，那么自定义类称为装饰类。装饰类会通过构造

函数接收被装饰的对象，并基于被装饰的对象的功能提供更强的功能。

示例如下：

class Person
{
    public void chifan()
    {
        System.out.println("吃饭");
    }
}

class SuperPerson 
{
    private Person p ;//定义已有类对象
    SuperPerson(Person p)//通过构造函数传入对象
    {
        this.p = p;
    }
    public void superChifan()
    {
        System.out.println("开胃酒");
        p.chifan();//调用已有对象的类方法
        System.out.println("甜点");
        System.out.println("来一根");
    }
}



class  PersonDemo
{
    public static void main(String[] args) 
    {
        Person p = new Person();

        //p.chifan();

        SuperPerson sp = new SuperPerson(p);
        sp.superChifan();

    }
}

为什么要用装饰类，装饰类和继承相比有什么优越性？
通过MyReader基类的继承分析

MyReader//专门用于读取数据的类。
 |--MyTextReader
  |--MyBufferTextReader
 |--MyMediaReader
  |--MyBufferMediaReader
 |--MyDataReader
  |--MyBufferDataReader

class MyBufferReader
{
 MyBufferReader(MyTextReader text)
 {}
 MyBufferReader(MyMediaReader media)
 {}
}
上面这个类扩展性很差。
找到其参数的共同类型。通过多态的形式。可以提高扩展性。

class MyBufferReader extends MyReader
{
 private MyReader r;//
 MyBufferReader(MyReader r)
 {}
} 

MyReader//专门用于读取数据的类。
 |--MyTextReader
 |--MyMediaReader
 |--MyDataReader
 |--MyBufferReader

以前是通过继承将每一个子类都具备缓冲功能。
那么继承体系会复杂，并不利于扩展。

现在优化思想。单独描述一下缓冲内容。
将需要被缓冲的对象。传递进来。也就是，谁需要被缓冲，谁就作为参数传递给缓冲区。
这样继承体系就变得很简单。优化了体系结构。

装饰模式比继承要灵活。避免了继承体系臃肿。
而且降低了类于类之间的关系。

装饰类因为增强已有对象，具备的功能和已有的是相同的，只不过提供了更强功能。
所以装饰类和被装饰类通常是都属于一个体系中的。

4，LineNumberReader使用介绍

public class LineNumberReaderextends BufferedReader

跟踪行号的缓冲字符输入流。此类定义了方法 setLineNumber(int) 和 getLineNumber()，它们可分别用于设置和获取当前行号。

默认情况下，行编号从 0 开始。该行号随数据读取在每个行结束符处递增，并且可以通过调用 setLineNumber(int) 更改行号。但要注意的是，setLineNumber(int) 不会实际更改流中的当前位置；它只更改将由 getLineNumber()返回的值。

可认为行在遇到以下符号之一时结束：换行符（'\n'）、回车符（'\r'）、回车后紧跟换行符。

import java.io.*;

class LineNumberReaderDemo 
{
    public static void main(String[] args)throws IOException 
    {
        FileReader fr = new FileReader("PersonDemo.java");

        LineNumberReader lnr = new LineNumberReader(fr);

        String line = null;
        lnr.setLineNumber(100);
        while((line=lnr.readLine())!=null)
        {
            System.out.println(lnr.getLineNumber()+":"+line);
        }

        lnr.close();
    }
}

 

 8.3 字节流

1， 字节流：
InputStream  OutputStream

需求，想要操作图片数据。这时就要用到字节流。
复制一个图片.

 

/*
FileInputStream中 多了一个 available()方法，是返回流中字符的长度

*/
import java.io.*;
class  FileStream
{
    public static void main(String[] args) throws IOException
    {
        readFile_3();
    }

    public static void readFile_3()throws IOException
    {
        FileInputStream fis = new FileInputStream("fos.txt");
        
//        int num = fis.available();//流中字符的长度
        byte[] buf = new byte[fis.available()];//定义一个刚刚好的缓冲区。不用在循环了。

        fis.read(buf);

        System.out.println(new String(buf));

        fis.close();
    }


    public static void readFile_2()throws IOException
    {
        FileInputStream fis = new FileInputStream("fos.txt");

        byte[] buf = new byte[1024];
        int len = 0;
        while((len=fis.read(buf))!=-1)
        {
            System.out.println(new String(buf,0,len));
        }

        fis.close();
        
    }



    public static void readFile_1()throws IOException
    {
        FileInputStream fis = new FileInputStream("fos.txt");

        int ch = 0;

        while((ch=fis.read())!=-1)
        {
            System.out.println((char)ch);
        }

        fis.close();
    }

    public static void writeFile()throws IOException
    {
        FileOutputStream fos = new FileOutputStream("fos.txt");
        

        fos.write("abcde".getBytes());

        fos.close();

        
    }
}

readFile_1()方法中使用了InputStream中的

public int read()
         throws IOException

从此输入流中读取下一个数据字节。返回一个 0 到 255 范围内的 int 字节值。

如果因为已经到达流末尾而没有字节可用，则返回 -1。

读一个数据字节就输出，麻烦，通常不采用。

 readFile_2()方法中使用了InputStream中的

public int read(byte[] b)
         throws IOException

从此输入流中将 byte.length个字节的数据读入一个 byte 数组中。在某些输入可用之前，此方法将阻塞。

此方法只执行 read(b, 0, b.length) 调用并返回结果。

将所有数据字节都存入一个数组，然后在一块儿打印，很合理。这个是经常使用的方法。

 readFile_3()方法中使用了InputStream中的

 public int available()
              throws IOException

是返回流中字符的长度，当文件很小时用这个是可以的，但是当文件过大，不可用。

2，拷贝图片示例

操作图片使用字节流

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

import java.io.*;
class  CopyPic
{
    public static void main(String[] args) 
    {
        FileOutputStream fos = null;
        FileInputStream fis = null;
        try
        {
            fos = new FileOutputStream("c:\\2.bmp");
            fis = new FileInputStream("c:\\1.bmp");//1.bmp是被复制的文件

            byte[] buf = new byte[1024];

            int len = 0;

            while((len=fis.read(buf))!=-1)
            {
                fos.write(buf,0,len);
            }
        }
        catch (IOException e)
        {
            throw new RuntimeException("复制文件失败");
        }
        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("写入关闭失败");
            }
        }
    }
}

 

 3，读取键盘录入

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

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

import java.io.*;
class  ReadIn
{
    public static void main(String[] args) throws IOException
    {
        InputStream in = System.in;
        StringBuilder sb = new StringBuilder();

        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);

        }
    }
}

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

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

readLine方法是字符流BufferedReader类中的方法。

而键盘录入的read方法是字节流InputStream的方法。

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

public class InputStreamReaderextends Reader

InputStreamReader 是字节流通向字符流的桥梁：它使用指定的 charset 读取字节并将其解码为字符。

它使用的字符集可以由名称指定或显式给定，或者可以接受平台默认的字符集。

public class OutputStreamWriterextends Writer

OutputStreamWriter 是字符流通向字节流的桥梁：可使用指定的 charset 将要写入流中的字符编码成字节。

它使用的字符集可以由名称指定或显式给定，否则将接受平台默认的字符集。

字节流与字符流转换示例

import java.io.*;

class  TransStreamDemo
{
    public static void main(String[] args) throws IOException
    {
        //获取键盘录入对象。
        //InputStream in = System.in;

        //将字节流对象转成字符流对象，使用转换流。InputStreamReader
        //InputStreamReader isr = new InputStreamReader(in);

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

        //BufferedReader bufr = new BufferedReader(isr);


        //键盘的最常见写法。将字节流转换成字符流
        BufferedReader bufr = 
                new BufferedReader(new InputStreamReader(System.in));


        
//        OutputStream out = System.out;
//        OutputStreamWriter osw = new OutputStreamWriter(out);
//        BufferedWriter bufw = new BufferedWriter(osw);
//                             将
        BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(System.out));

        String line = null;

        while((line=bufr.readLine())!=null)
        {
            if("over".equals(line))
                break;
            bufw.write(line.toUpperCase());
            bufw.newLine();
            bufw.flush();
        }

        bufr.close();

    }
}

8.4 流对象的操作规律分析总结

流对象有很多，到底什么时候该用哪一个？相信大家十分迷茫，现将流对象使用规律介绍如下：

1，三个明确

1）明确源和目的。
 源：输入流。InputStream  Reader
 目的：输出流。OutputStream  Writer。

2）操作的数据是否是纯文本。
 是：字符流。
 不是：字节流。

3）当体系明确后，在明确要使用哪个具体的对象。
 通过设备来进行区分：
 源设备：内存，硬盘。键盘
 目的设备：内存，硬盘，控制台。

2，具体实例分析

1）将一个文本文件中数据存储到另一个文件中。复制文件。
 源：因为是源，所以使用读取流。InputStream Reader
 是不是操作文本文件。
 是！这时就可以选择Reader
 这样体系就明确了。

 接下来明确要使用该体系中的哪个对象。
 明确设备：硬盘。上一个文件。
 Reader体系中可以操作文件的对象是 FileReader

 是否需要提高效率：是！。加入Reader体系中缓冲区 BufferedReader.

 FileReader fr = new FileReader("a.txt");
 BufferedReader bufr = new BufferedReader(fr);

 目的：OutputStream Writer
 是否是纯文本。
 是！Writer。
 设备：硬盘，一个文件。
 Writer体系中可以操作文件的对象FileWriter。
 是否需要提高效率：是！。加入Writer体系中缓冲区 BufferedWriter
 
 FileWriter fw = new FileWriter("b.txt");
 BufferedWriter bufw = new BufferedWriter(fw);

2）需求：将键盘录入的数据保存到一个文件中。
 这个需求中有源和目的都存在。
 那么分别分析
 源：InputStream Reader
 是不是纯文本？是！Reader
 
 设备：键盘。对应的对象是System.in.
 不是选择Reader吗？System.in对应的不是字节流吗？
 为了操作键盘的文本数据方便。转成字符流按照字符串操作是最方便的。
 所以既然明确了Reader，那么就将System.in转换成Reader。
 用了Reader体系中转换流,InputStreamReader

 InputStreamReader isr = new InputStreamReader(System.in);

 需要提高效率吗？需要！BufferedReader
 BufferedReader bufr = new BufferedReader(isr);

 

 目的：OutputStream  Writer
 是否是存文本？是！Writer。
 设备：硬盘。一个文件。使用 FileWriter。
 FileWriter fw = new FileWriter("c.txt");
 需要提高效率吗？需要。
 BufferedWriter bufw = new BufferedWriter(fw);

 **************
 扩展一下，想要把录入的数据按照指定的编码表（utf-8），将数据存到文件中。
 
 目的：OutputStream  Writer
 是否是存文本？是！Writer。
 设备：硬盘。一个文件。使用 FileWriter。
 但是FileWriter是使用的默认编码表。GBK.
 
 但是存储时，需要加入指定编码表utf-8。而指定的编码表只有转换流可以指定。
 所以要使用的对象是OutputStreamWriter。
 而该转换流对象要接收一个字节输出流。而且还可以操作的文件的字节输出流。FileOutputStream

 OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("d.txt"),"UTF-8");

 需要高效吗？需要。
 BufferedWriter bufw = new BufferedWriter(osw);

 所以，记住。转换流什么时候使用。字符和字节之间的桥梁，通常，涉及到字符编码转换时，
 需要用到转换流。

 

 

　--------- android培训、java培训、期待与您交流！ ----------

 

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　详细请查看：http://edu.csdn.net/heima/