黑马程序员——Java基础---IO(一)---IO流概述、字符流

------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

   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、写入字符流步骤

import java.io.*;
class FileWriterDemo
{
    public static void main(String[] args )throws Exception
    {
        //创建一个FileWriter对象。该对象一被初始化就必须要明确被操作的文件。
        //而且该文件会被创建到指定目录下。如果该目录下已有同名文件，将被覆盖。
        //其实该步  就是明确 数据要存放的目的地
        FileWriter fw=new FileWriter("demo.txt");

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

        fw.write("abcde");

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

        //关闭流资源，但是关闭之前会刷新一次内部的缓冲区的数据
        //和flush区别，flush刷新后，流可以继续使用，close刷新后，会将流关闭
        fw.close();

    }
}

注意：

        1、其实java自身不能写入数据，而是调用系统内部方式完成数据的书写，使用系统资源后，一定要关闭资源。

　　　　  即可以在finally中对流进行关闭资源。

        2、文件的数据的续写是通过构造函数 FileWriter(Strings,boolean append)，在创建对象时，传递一个true参数，代表不覆盖已有的文件。并在已有文件的末尾处进行数据续写。（windows系统中的文件内换行用 两个转义字符表示，在linux系统中只用 表示换行）

        3、由于在创建对象时，需要指定创建文件位置，如果指定的位置不存在，就会发生IOException异常，所以在整个步骤中，需要对IO异常进行try处理。

思考：　　

　　   1、有了垃圾回收机制为什么还要调用close方法进行关闭？

　　　　答：垃圾回收机制是不定时的，回收时间不是我们所能控制的，并且流不单单在内存中分配了空间，也在操作系统占有了资源，java的gc是能从内存中回收不  　　　　　  使用的对象，但对操作系统分配的资源是无能为力的，所以就要调用close()方法来通知OS来释放这个资源。

　　　2、为什么IO异常一定要处理？

　　　　答：程序运行中出现异常就会终止程序,  导致后面的代码运行不到,  我们要是写的代码面向客户, 出现问题客户不一定知道为什么, 所以我们要对可能出现的

　　　　　　问题进行处理.  一旦发现可能出现问题的代码,而我们可以通过捕获异常，使异常后面的程序正常运行。即提高代码的健壮性。

2、读取字符流步骤

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

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

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

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

示例：

//将C盘一个文本文件复制到D盘

/*
复制的原理：
    其实就是将C盘下的文件数据存储到D盘的一个文件中。

步骤：
    1    在D盘创建一个文件。用于存储C盘文件中的数据
    2    定义读取流和Cpan文件关联
    3    通过不断的读写完成数据存储
    4    关闭资源
*/
import java.io.*;
class CopyTest
{
    public static void main(String[] args)
    {
        copy_2();
    }
    public static void copy_2()
    {
        FileWriter fw=null;
        FileReader fr=null;
        try
        {
            fw=new FileWriter("SystemDemo_copy.txt");//写入流关联文本文件
            fr=new FileReader("SystemDemo.java");//读取流关联文本文件
            char[] buf=new char[1024];//创造第三方 字节数组，使两个流能够联系起来
            int len=0;
            while((len=fr.read(buf))!=-1)  //将读取流的字节存到字节数组中，只要没有读到-1（即结束标志），继续存
            {
                fw.write(buf,0,len);//将字节数组中的数据，通过写入流  写入 关联的文本文件
            }
        }
        catch (IOException e)
        {
            throw new RuntimeException("读写失败");
        }
        finally
        {
            if(fr!=null)
                try
                {
                    fr.close(); //将读取流的数据关闭
                }
                catch (IOException e)
                {
                }
            if(fw!=null)
                try
                {
                    fw.close();//将写入流的数据刷到指定文件内，并关闭流资源
                }
                catch (IOException e)
                {
                }
        }
    }


    public static void copy_1()throws  IOException
    {
        //创建目的地
        FileWriter fw=new FileWriter("Demo_copy1.txt");
        //与已有文件关联
        FileReader fr=new FileReader("Demo.txt");
        int ch=0;
        while((ch=fr.read())!=-1)//一个字节一个字节读的,而且会自动往下读
        {
            fw.write(ch);
        }
        fw.close();
        fr.close();
    }

}

注意：

        1、定义文件路径时，可以用“/”或者“\”。

        2、在创建一个文件时，如果目录下有同名文件将被覆盖。

        3、在读取文件时，必须保证该文件已存在，否则出异常。

三、字符流的缓冲区——BufferedReader和BufferedWriter

1、缓冲区的出现：提高了流的读写效率，所以在缓冲区创建前，要先创建流对象。即先将流对象初始化到构造函数中。 

2、缓冲技术原理：此对象中封装了数组，将数据存入，再一次性取出。

3、写入流缓冲区BufferedWriter的步骤：

/*缓冲区的出现是为了提高流的操作效率而出现的

所以在创建缓冲区之前，必须要先有流对象

该缓冲区中提供了一个跨平台的换行符
newline()
*/
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();
    
    }
}

小知识：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();、

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

/*

通过缓冲区复制一个。java文件*/
import java.io.*;
class CopyTextBybuf
{
    public static void main(String[] args)
    {
        BufferedReader bufr=null;//为了防止异常的产生，首先要创建缓冲区
        BufferedWriter bufw=null;
        try
        {
            bufr=new BufferedReader(new FileReader("BufferedWriterDemo.java"));//将关联文件后的读写流都放到缓冲区中
            bufw=new BufferedWriter(new FileWriter("bufWriter_Copy.txt"));
            
            String line=null;
            while((line=bufr.readLine())!=null)//缓冲区提供了一次读一行的方法
            {
                bufw.write(line);
                bufw.newLine();
                bufw.flush();//刷新缓冲区
            }
        }
        catch (IOException e)
        {
            throw new RuntimeException("读写失败");
        }
        finally
        {
            try
            {
                if(bufr!=null)
                    bufr.close();
            }
            catch (IOException e)
            {
                throw new RuntimeException("读取关闭失败");
            }
            
            try
            {
                if(bufw!=null)
                    bufr.close();
            }
            catch (IOException e)
            {
                throw new RuntimeException("写入关闭失败");
            }
        }
    }
}

5、自定义BufferedReader：

原理：

        可根据BufferedReader类中特有一行一行读取方法readLine()的原理，自定义一个类中包含相同功能的方法

步骤：

        a、初始化自定义的类，加入流对象。

        b、定义一个临时容器，原BufferedReader封装的是字符数组，此类中可定义一个StringBuilder的容器，最终可实现字符串的提取。

/*
明白了BufferedReader 类中特有方法 readLine() 的原理后，
可以自定义一个类中包含一个功能和readLine 一致的方法

用来模拟一下 BufferedReader
*/
import java.io.*;
class MyBufferedReader extends Reader
{
    private Reader r;
    MyBufferedReader(Reader r)
    {
        this.r=r;

    }
    //可以一次读一行  数据的方法
    public String myReaderLine() throws IOException
    {
        //定义一个临时容器。  原BufferReader 封装的是字符数组
        //为了演示方便。定义一个StringBuilder容器
        //因为最终还是要将数据变成字符串
        StringBuilder sb=new StringBuilder();//创建字符串容器，用于存储文本中的字符
        int ch=0;
        while((ch=r.read())!=-1)//一次读一个，但是没有遇到回车符时，会暂时先存储在StringBuilder中
        {
            if(ch=='
')
                continue;
            if(ch=='
')
                return sb.toString();
            else
                sb.append((char)ch);
        }
        if(sb.length()!=0)
            return sb.toString();
        return null;
    

    }    /*
    因为MyBufferedReader extends Reader，而Reader中存在抽象方法
    所以我们要覆盖Reader类中的抽象方法。

    */
    public int read(char[] cbuf, int off, int len) throws IOException
    {
        return r.read(cbuf,off,len) ;
    }

    public void close()throws IOException
    {
        r.close();
    }
    public void myClose()throws IOException
    {
        r.close();
    }
}
class MyBufferedReaderDemo
{
    public static void main(String[] args)throws IOException
    {
        FileReader fr=new FileReader("buf.txt");//字符读取流关联文本文件
        MyBufferedReader myBuf=new MyBufferedReader(fr);//建立读取缓冲区容器，将字符读取流放入
        String line=null;
        while((line=myBuf.myReaderLine())!=null)  //实现自定义读取方式
        {
            System.out.println(line);//打印出每行 读取到的内容
        }

        myBuf.myClose();//关闭 读取缓冲区
    }
}

四、装饰设计模式

/*
装饰设计模式：
当想要对已有的对象进行功能增强时，
可以定义类，将已有对象传入，基于已有的功能，并提供加强功能。
那么自定义的该类称为装饰类

装饰类通常会通过构造函数方法接收被装饰的对象。

并基于被装饰的对象的功能，提供更强的功能
*/
class Person
{
    public void chifan()
    {
        System.out.println("吃饭");
    }
    public void wc()
    {
        System.out.println("go to wc");
    }
}
class SuperPerson
{
    private Person p;
    SuperPerson(Person p)
    {
        this.p=p;
    }
    public void superChifan()
    {
    
        System.out.println("开胃酒");
        p.chifan();
        p.wc();
        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();
    }
}

装饰和继承的区别：

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

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

        3）从继承结构转为组合结构。

注：在定义类的时候，不要以继承为主；可通过装饰设计模式进行增强类功能。灵活性较强，当装饰类中的功能不适合，可再使用被装饰类的功能。