概述：

1、IO流：即Input Output的缩写。

2、特点：
1）IO流用来处理设备间的数据传输。
2）Java对数据的操作是通过流的方式。
3）Java用于操作流的对象都在IO包中。
4）流按操作数据分为两种：字节流和字符流。
5）流按流向分为：输入流和输出流。

注意：流只能操作数据，而不能操作文件。

3、IO流的常用基类：
1）字节流的抽象基流：InputStream和OutputStream
2）字符流的抽象基流：Reader和Writer

注：此四个类派生出来的子类名称都是以父类名作为子类名的后缀，以前缀为其功能；如InputStream子类FileInputStream和Reader子类FileReader

一、字符流

1、简述：

1、字符流中的对象融合了编码表。使用的是默认的编码，即当前系统的编码。

2、字符流只用于处理文字数据，而字节流可以处理媒体数据。

3、既然IO流是用于操作数据的，那么数据的最常见体现形式是文件。专门用于操作文件的Writer子类对象：FileWriter ---> 后缀名为父类名，前缀名为流对象的功能。

2、字符流的读写

1、写入字符流：

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

2）调用write(String s)方法，将字符串写入到流中。

3）调用flush()方法，刷新该流的缓冲，将数据刷新到目的地中。

4）调用close()方法，是关闭流资源。但是关闭前会刷新一次内部的缓冲数据，并将数据刷新到目的地中。

注：
--->close()和flush()区别：flush()刷新后，流可以继续使用；而close()刷新后，将会关闭流，不可再写入字符流。

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

--->数据的续写是通过构造函数FileWriter(String s,boolean append)，根据给定文件名及指示是否附加写入数据的boolean值来构造FileWriter对象。

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

2）调用读取流对象的read()方法。
read() ：一次读一个字符，且会继续往下读。
第一种方式：读取单个字符。
第二种方式：通过字符数组进行读取。

3）读取后要将流资源关闭。

示例：

import java.io.*;  
class IODemo{  
    public static void main(String[] args){  
        FileWriter fw =null;  
        FileReader fr = null;  
        //检测异常  
        try{  
            //创建读写对象，并指定目的地  
            fw = new FileWriter("Demo.txt");  
            fr = new FileReader("Demo.txt");  
            //将数据写入到指定文件中  
            for(int i=0;i<5;i++){  
                fw.write("abcde" + i + "\r\n");  
                fw.flush();  
            }  
            //从指定文件中读取数据  
            int len = 0;  
            char[] ch = new char[1024];  
            while((len=fr.read(ch))!=-1){  
                System.out.println(new String(ch,0,len));  
            }  
        }  
        //捕获异常  
        catch (IOException e){  
            throw new RuntimeException("读写文件失败");  
        }  
        //最终关闭两个流资源  
        finally{  
            if(fw!=null){  
                try{  
                    fw.close();  
                }  
                catch (IOException e){  
                    throw new RuntimeException("关闭流资源失败。");  
                }  
            }  
            if(fr!=null){  
                try{  
                    fr.close();  
                }  
                catch (IOException e){  
                    throw new RuntimeException("读取流资源失败。");  
                }  
            }  
        }  
    }  
}

2、文件的拷贝：

原理：
其实就是将一个磁盘下的文件数据存储到另一个磁盘的一个文件中。

步骤：
1、在D盘上创建一个文件，用于存储E盘文件中的数据
2、定义读取流和E盘文件关联
3、通过不断读写完成数据存储
方式一：读取一个字符，存入一个字符
方式二：先将读取的数据存入到内存中，再将存入的字符取出写入D盘
4、关闭流资源：输入流资源和输出流资源。

示意图

示例：

import java.io.*;  
class CopyDemo  
{  
    public static void main(String [] args)  
    {  
        FileReader fr = null;  
        FileWriter fw = null;  
        try{  
            fr = new FileReader("E:\\Dmeo.txt");  
            fw = new FileWriter("D:\\Dmeo.txt");  
            char[] ch = new char[1024];  
            int len = 0;  
            //用ch将读取的文件和写入的文件关联起来  
            while((len=fr.read(ch))!=-1)  
            {  
                fw.write(ch,0,ch.length);  
            }  
        }  
        catch (IOException e){  
            throw new RuntimeException("文件读写失败");  
        }  
        finally{  
            if(fr!=null){  
                try{  
                    fr.close();  
                }  
                catch (IOException e){  
                    throw new RuntimeException("读取流资源关闭失败。");  
                }  
            }  
            if(fw!=null){  
                try{  
                    fw.close();  
                }  
                catch (IOException e){  
                    throw new RuntimeException("写入流资源关闭失败。");  
                }  
            }  
        }  
    }  
}

3、BufferedWriter和BufferedReader：字符流缓冲区

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

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

3、写入流缓冲区BufferedWriter的步骤：
1）创建一个字符写入流对象
2）为提高字符写入流效率，加入缓冲技术，只要将需要被提高效率的流对象作为参数传递给缓冲区的构造函数即可。
注意，只要用到缓冲去就需要刷新。
3）其实关闭缓冲区就是在关闭缓冲区中的流对象。
－－－＞该缓冲区中提供了一个跨平台的换行符：newLine()

4、读取流缓冲区BufferedReader的步骤：
1）创建一个读取流对象和文件关联
2）为提高效率，加入缓冲技术，将字符读取流对象作为参数传递给缓冲对象的构造函数。
3）该缓冲区提供了一个一次读一行的方法readLine()，方便与对文本数据的获取，当返回null时，表示读到文件末尾。
readLine() 方法返回的时只返回回车符之前的数据内容，并不返回回车符，即读取的内容中不包含任何行终止符（回车符和换行符）。
readLine() 方法原理：无论是读一行，或读取多个字符，其实最终都是在硬盘上一个一个读取。所以最终使用的还是read方法一次读一个。

示意图

5、使用缓冲技术拷贝文件，提高效率：

示例：

import java.io.*;  
class CopyBufferedDemo{  
    public static void main(String[] args) {  
        BufferedReader bufr = null;  
        BufferedWriter bufw = null;  
        try{  
            //创建缓冲区，将读写流对象作为参数传入  
            bufr = new BufferedReader(new FileReader("D:\\JAVA\\IO\\buffered\\myJava.txt"));  
            bufw = new BufferedWriter(new FileWriter("D:\\JAVA\\IO\\文件拷贝\\myJava.txt"));  
            //定义字符串，通过readLine一次读一行，并存入缓冲区  
            String line = null;  
            while((line=bufr.readLine())!=null)  
            {  
                //将读取到缓冲区的数据通过line存入写入流中  
                bufw.write(line);  
                //换行符方法  
                bufw.newLine();  
                //将数据刷新到指定文件中  
                bufw.flush();  
            }  
        }  
        catch (IOException e){  
            throw new RuntimeException("读写文件失败。");  
        }  
        finally{  
            if(bufr!=null){  
                try{  
                    bufr.close();  
                }  
                catch (IOException e){  
                    throw new RuntimeException("读取流资源关闭失败。");  
                }  
            }  
            if(bufw!=null){  
                try{  
                    bufw.close();  
                }  
                catch (IOException e){  
                    throw new RuntimeException("写入流资源关闭失败。");  
                }  
            }  
        }  
    }  
}

6、自定义BufferedReader：
原理：
可根据BufferedReader类中特有发那个发readLine()的原理，自定义一个类中包含相同功能的方法

步骤：
a.初始化自定义的类，加入流对象。
b.定义一个临时容器，原BufferedReader封装的是字符数组，此类中可定义一个StringBuilder的容器，最终可实现字符串的提取。

import java.io.*;  
//自定义一个功能与BufferedReader相似的类，继承Reader  
class MyBufferedReader extends Reader  
{  
    //定义变量，用于全局  
    private Reader r;  
    //构造函数，传入读取流对象  
    MyBufferedReader(Reader r)  
    {  
        this.r = r;  
    }  
    //复写readLine放，并将异常抛出，有调用者处理  
    public String MyReadLine()throws IOException  
    {  
        //定义存储字符串的容器  
        StringBuilder sb = new StringBuilder();  
        int ch = 0;  
        //read()方法遍历文件，当达末尾时判断是否为-1结束循环  
        while((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();  
        //读到结尾处，返回null  
        return null;  
    }  
    /* 
    覆盖抽象方法: 
    */  
    public int read(char[] cbuf,int off,int len)throws IOException  
    {  
        return r.read(cbuf,off,len);  
    }  
    //覆盖close方法  
    public void close()throws IOException  
    {  
        r.close();  
    }  
    //创建自定义close方法  
    public void MyClose()throws IOException  
    {  
        r.close();  
    }  
}  
//测试  
class MyBufferedDemo{  
    public static void main(String [] args){  
        MyBufferedReader mbr = null;  
        //检测异常  
        try{  
            mbr = new MyBufferedReader(new FileReader("Demo.txt"));  
            String line = null;  
            //遍历文件，读取数据  
            while ((line=mbr.MyReadLine())!=null){  
                System.out.println(line);  
            }  
        }  
        //捕获异常  
        catch (IOException e){  
            throw new RuntimeException("读取文件失败。");  
        }  
        //最终关闭资源  
        finally{  
            if(mbr!=null){  
                try{  
                    mbr.MyClose();  
                }  
                catch (IOException e){  
                    throw new RuntimeException("读取流关闭失败。");  
                }  
            }  
        }  
    }  
}

7、LineNumberReader

在BufferedReader中有个直接的子类LineNumberReader，其中有特有的方法获取和设置行号：
setLineNumber()和getLineNumber()

示例：

......  
try  
{  
    fr = new FileReader("myJava.txt");  
    lnr = new LineNumberReader(fr);  
    lnr.setLineNumber(100);  
    String line = null;  
    while((line=lnr.readLine())!=null)  
    {  
        System.out.println(lnr.getLineNumber() + ":  " + line);  
    }  
}  
......  

通过这个例子，就可以引出装饰设计模式

4、装饰设计模式：

1、简述：
当想对已有对象进行功能增强是，可定义类：将已有对象传入，基于已有对象的功能，并提供加强功能，那么自定义的该类称之为装饰类。即对原有类进行了优化。

2、特点：
装饰类通常都会通过构造方法接收被装饰的对象，并基于被装饰的对i型那个的功能提供更强的功能。

3、装饰和继承的区别：

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

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

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

注：
在定义类的时候，不要以继承为主；可通过装饰设计模式进行增强类功能。灵活性较强，当装饰类中的功能不适合，可再使用被装饰类的功能。
要继承相应的父类，就需要将所有的抽象方法实现，或交给子类实现。

示例：其中MyBufferedReader的例子就是最好的装饰设计模式的例子。

二、字节流

1、概述：

1、字节流和字符流的原理是相似的，只不过字节流可以对媒体进行操作。

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

3、读写字节流：
InputStream ---> 输入流（读）
OutputStream ---> 输出流（写）

4、为何不用进行刷流动作：
因为字节流操作的是字节，即数据的最小单位，不需要像字符流一样要进行转换为字节。可直接将字节写入到指定文件中，但是需要在写代码的时候，如果有字符串，要将字符串转为字节数组再进行操作。

5、特有方法：
int available() ---> 放回数据字节的长度，包含终止符

在定义字节数组长度的时候，可以用到这个方法：
byte[] = new byte[fos.available()] （fos为字节流对象）

但是，对于这个方法要慎用，如果字节过大（几个G），那么如此大的数组就会损坏内存，超过jvm所承受的大小（指定内存为64M）。

2、拷贝媒体文件：

1、思路：
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("2.gif");  
            fis = new FileInputStream("1.gif");  
            int len = 0;  
            //定义字节数组，存储读取的字节流  
            byte[] arr = new byte[1024];  
            //循环读写流，完成数据存储  
            while((len=fis.read(arr))!=-1){  
                fos.write(arr,0,len);  
            }  
        }catch (IOException e){  
            throw new RuntimeException("复制图片失败");  
        }  
        //最终关闭资源  
        finally{  
            if(fos!=null){  
                try{  
                    fos.close();  
                }catch (IOException e){  
                    throw new RuntimeException("写入流关闭失败");  
                }  
            }  
            if(fos!=null){  
                try{  
                    fis.close();  
                }catch (IOException e){  
                    throw new RuntimeException("读取流关闭失败");  
                }         
            }  
        }  
    }  
}

3、字节流缓冲区：

1、读写特点：
read() ：会将字节byte型值提升为int型值
write() ：会将int型强转为byte型，即保留二进制数的最后八位。

2、原理：
将数据拷贝一部分，读取一部分，循环，直到数据全部读取完毕。
1）先从数据中抓取固定数组长度的字节，存入定义的数组中，再通过然后再通过read()方法读取数组中的元素，存入缓冲区
2）循环这个动作，知道最后取出一组数据存入数组，可能数组并未填满，同样也取出包含的元素
3）每次取出的时候，都有一个指针在移动，取到数组结尾就自动回到数组头部，这样指针在自增
4）取出的时候，数组中的元素再减少，取出一个，就减少一个，直到减到0即数组取完
5）到了文件的结尾处，存入最后一组数据，当取完数组中的元素，就会减少到0，这是全部数据就取完了

3、示意图：

示意图

4、自定义字节流缓冲区：
思路：
1、定义一个固定长度的数组
2、定义一个指针和计数器用于读取数组长度，和计数数组元素是否取完为0
3、每次将字节数据存入元素要先将数组中的元素取完

注：
取出的是byte型，返回的是int型，这里存在提升的动作，当byte中的八位全为1的时候是byte的-1，提升为int类型，就变为int型的-1，read循环条件就结束了变为-1的原因是由于在提升时，将byte的八位前都补的是1，即32位的数都是1，即为int型的-1了。

如何保证提升后的最后八位仍为1呢？
就需要将前24位补0，就可以保留原字节数据不变，又可以避免转为int型出现-1的情况；
那么要如何做呢？
这就需要将提升为int的数据和前24位为0，后八位仍为原字节数据的这个值做与运算。即和255做与运算即可

import java.io.*;  
class MyBufferedInputStream  
{  
    private InputStream in;  
    byte[] by = new byte[1024*4];  
    private int pos=0,count=0;  
    //传入加强的类  
    MyBufferedInputStream(InputStream in)  
    {  
        this.in = in;  
    }  
    //自定义读取方法  
    public int myRead()throws IOException  
    {  
        //先判断计数器  
        if(count==0)  
        {  
            //计数器为0则存入数据  
            count = in.read(by);  
            //计数器为负则返回-1，说明结束数据读取  
            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;  
        }  
        //为-1时即到数据结尾  
        return -1;  
    }  
    public void myClose()throws IOException  
    {  
        in.close();  
    }  
}

三、流操作规律

1、读取键盘录入：

1、System.out ：对应的是标准的输出设备 ---> 控制台
System.in ： 对应的是标准的输出设备 ---> 键盘
in字段返回的是IputStream类型，其read()方法在未读取到数据时，一直阻塞

2、如何使用readLine方法完成键盘录入一行数据的读取？
说明：
readLine()方法是字符流中BufferedReader类的方法；而键盘录入的read()方法是字节流IputStream的方法

那么，如何将字节流转成字符流在使用字符流缓冲区的readLine()的方法呢？
这就需要使用InputStreamReader对象。

3、转换流：

3.1、InputStreamReader：读取转换流
a.获取键盘录入对象： --->InputStream in = System.in;
b.将字节流对象转换成字符流对象，使用转换流InputStreamReader： --->

InputStreamReader isr = new InputStreamReader(in);

c.为提高效率，将字符串进行缓冲区技术操作，使用BufferedReader： --->

BufferedReader bufw = new BufferedReader(isr);

d.之后就可以使用readLine()方法读取录入的一行数据了。

3.2、OutputStreamWriter：写入转换流 ---> 和读取转换流同理，即使用对应的Writer的子类

import java.io.*;  
class StreamWriter{  
    public static void main(String[] args){  
        BufferedReader bfr = null;  
        BufferedWriter bfw = null;  
        try{  
            //最常见写法,键盘录入：  
            bfr = new BufferedReader(new InputStreamReader(System.in));  
            //输出控制台写法  
            bfw = new BufferedWriter(new OutputStreamWriter(System.out));  
            String line = null;  
            while((line=bfr.readLine())!=null){  
                //自定义结束标记  
                if("over".equals(line))  
                    break;  
                bfw.write(line.toUpperCase());  
                bfw.newLine();  
                bfw.flush();  
            }  
        }catch (IOException e){  
            throw new RuntimeException("读写失败。");  
        }  
        finally{  
            try{  
                if(bfr!=null)  
                    bfr.close();  
            }catch (IOException e){  
                throw new RuntimeException("读取流关闭失败。");  
            }  
            try{  
                if(bfw!=null)  
                    bfw.close();  
            }catch (IOException e){  
                throw new RuntimeException("写入流关闭失败。");  
            }  
        }  
    }  
}

2、流操作规律：

1、将键盘录入的数据打印到屏幕上
源：键盘录入 ---> 目的：控制台

2、将键盘录入的数据存入文件中
源：键盘录入 ---> 目的：文件
---> 创建一个写入（输出）流对象文件作为参数，传给转换流（桥梁）：OutputStreamWriter

3、要将一个文件的数据打印到控制台：
源：文件 ---> 目的：控制台
---> 创建一个读取（输入）流对象文件作为参数，传给转换流（桥梁）：InputStreamReader

4、流操作基本规律：
在写代码过程中最痛苦的是：流对象较多，不知道该用哪一个，这就需要有如下的三点明确：
第一、明确源和目的：
源 ：输入流 ---> InputStream和Reader
目的：输出流 ---> OutputStream和Writer

第二、明确操作的数据是否为纯文本：
是：字符流
否：字节流

第三、当体系明确后，再明确具体要用哪个具体对象，通过设备来区分
源 设 备：内存（ArrayStream）、硬盘（FileStream）、键盘（System.in）
目的设备：内存（ArrayStream）、硬盘（FileStream）、控制台（System.out）

可以在下面的需求体现中，发现元和目的是对应的，都为对应体系的一对对象。

5、需求体现：
5.1、将一个文本文件中的数据存入另一个文件，即复制文本
1）源：使用读取流：InputStream和Reader
---> 明确体系：是否为文本文件：是，选Reader
---> 明确设备：明确要使用该体系中哪个对象：硬盘上一个文件。
即Reader体系中可操作文件的对象：FileReader
---> 是否需要高效：是，加入Reader体系中的缓冲区：BufferedReader

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

2）目的：使用写入流：OutputStream和Writer
---> 明确体系：是否为文本文件：是，选Writer
---> 明确设备：明确要使用该体系中哪个对象：硬盘上一个文件。即Writer体系中可操作对象的是FileWriter
---> 是否需要高效：是，加入Writer体系中的缓冲区：BufferedWriter

FileWriter fw = new FileWriter("b.txt");  
BufferedWriter bufw = new BufferedWriter(fw);  

5.2、将图片复制到另一个文件夹中：
1）源：InputStream和Reader
图片：字节流 ---> InputStream
设备：硬盘上的文件 ---> FileInputStream

2）目的：OutoutStream和Writer
图片：字节流 ---> OutputStream
设备：硬盘上的文件 ---> FileOutputStream

5.3、将键盘录入数据保存到一个文件中。
这个需求中有源和目的，都存在：
1）源：InputStream和Reader
纯文本？是，字符流 ---> Reader
设备：键盘 ---> 对应的是System.in，是字节流
---> 为方便操作键盘的文本数据，转成字符流；按照字符串操作是最方便的，所以既然明确了Reader，那么就将产生字节流System.in转为字符流Reader，就需用Reader体系中的转换流InputStreamReader
即

InutStreamReader isr = new InputStreamReader(System.in);

---> 是否需要高效：是，加入Reader体系中的缓冲区：BufferedReader;
即

BufferedReader bufr = new BufferedReader(isr);

2）目的：OutoutStream和Writer
纯文本？是，字符流 ---> Writer
设备：硬盘上的文件 ---> FileWriter
---> 是否需要高效：是，加入Writer体系中的缓冲区：BufferedWriter；
即 BufferedWriter bufw = new BufferedWriter(fw);

5.4、扩展：
想要将录入的数据按指定编码表（UTF-8），将数据存入文件
1）源：InputStream和Reader
纯文本？是，字符流 ---> Reader
设备：键盘 ---> 对应的是System.in，是字节流；需要用转换流：InputStreamReader，
即

InputStreamReader isr = new InputStreamReader(System.in);

2）目的：OutoutStream和Writer
纯文本？是，字符流 ---> Writer
设备：硬盘上的文件 ---> 应该用FileInputStream，但是存储时，需要加入指定的编码表，而指定编码表只有转换流可以指定，所以要使用的对象是：OutputStreamWriter；而转换流对象要接收一个字节输出流，且还可以操作文件的字节输出流，即FileOutputStream
即：

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

---> 是否需要高效：是，

BufferedWriter bufw = new BufferedWriter(osw);

记住：转换流何时使用：字符流和字节流间的桥梁，通常涉及字符编码转换时，需要用到转换流。

示例：

import java.io.*;  
class FileStreamWriter{  
    public static void main(String[] args){  
        BufferedReader bfr = null;  
        BufferedWriter bfw = null;  
        try{  
            System.setIn(new FileInputStream("推荐书籍.txt"));  
            System.setOut(new PrintStream("copy.java"));  
            //最常见写法,键盘录入：  
            bfr = new BufferedReader(new InputStreamReader(System.in));  
            //输出控制台写法  
            bfw = new BufferedWriter(new OutputStreamWriter(System.out));  
            //bfw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("d.txt"),"UTF-8"));  
            String line = null;  
            while((line=bfr.readLine())!=null){  
                //自定义结束标记  
                if("over".equals(line))  
                    break;  
                bfw.write(line.toUpperCase());  
                bfw.newLine();  
                bfw.flush();  
            }  
        }  
        catch (IOException e){  
            throw new RuntimeException("读写失败。");  
        }  
        finally{  
            try{  
                if(bfr!=null)  
                    bfr.close();  
            }catch (IOException e){  
                throw new RuntimeException("读取流关闭失败。");  
            }  
            try{  
                if(bfw!=null)  
                    bfw.close();  
            }  
            catch (IOException e){  
                throw new RuntimeException("写入流关闭失败。");  
            }  
        }  
    }  
}

四、信息

1、异常的日志信息：

当程序在执行的时候，出现的问题是不希望直接打印给用户看的，是需要作为文件存储起来，方便程序员查看，并及时调整的。

示例：

import java.io.*;  
import java.util.*;  
import java.text.*;  
  
class ExceptionInfo  
{  
    public static void main(String[] args){  
        try{  
            int[] arr = new int[2];  
            System.out.println(arr[3]);  
        }catch (IOException e){  
            try{  
                Date d = new Date();  
                SimpleDateFormat sfd = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");  
                String s = sfd.format(d);  
  
                PrintStream pf = new PrintStream("exception.log");  
                pf.println(s);  
                System.set(ps);  
            }  
            catch (IOException ex){  
                throw new RuntimeException("日志文件创建失败。");  
            }  
            e.printStackTrace(System.out);  
        }  
    }  
}

2、系统信息：

获取系统信息：

Properties getProperties()

将信息输出到指定输出流中

void  list(PrintStream out)

将输出流中数据存入指定文件中

new PrintStream("systeminfo.txt")

示例：

import java.util.*;  
import java.io.*;  
  
class SystemInfo   
{  
    public static void main(String[] args)   
    {  
        PrintStream ps = null;  
        try  
        {  
            //获取系统信息：  
            Properties pop = System.getProperties();  
            //创建输出流对象，将输出流中数据存入指定文件中  
            ps = new PrintStream("systeminfo.txt");  
            //将属性列表输出到指定的输出流  
            pop.list(ps);  
        }  
        catch (Exception e)  
        {  
            throw new RuntimeException("获取系统信息失败。");  
        }  
    }  
}

五、File类

1、概述：

1、File类：文件和目录路径的抽象表现形式

2、特点：
1）用来将文件或文件夹封装成对象
2）方便于对文件与文件夹的属性信息进行操作
3）File对象可以作为多数传递给流的构造函数

2、创建File对象：

方式一：

File f1 = new File("a.txt");

---> 将a.txt封装成对象，可将已有的和未出现的文件或文件夹封装成对象

方式二：

File f2 = new File("c:\\abc","b.txt");

---> 分别指定文件夹和文件。好处：降低了两者的关联程度，

方式三：

File d = new File("c:\\abc");     File f3 = new File(d,"c.txt");

---> 可以传入父目录和文件名。
目录分隔符：调用File.separator，相当于是反斜杠 \

3、File类常见方法：

1、创建：

boolean createNewFile()  //在指定位置创建文件，若文件存在，则返回true，与输出流不同，输出流对象已建立就创建文件，如果存在，就会被覆盖

boolean mkdir()  //创建文件夹，只能创建一级目录

boolean mkdirs()  //创建多级文件夹。

2、删除：

boolean delete()  //删除文件。文件存在，返回true；文件不存在或者正在被执行，返回false

void deleteOnExit() //在程序结束时删除文件

3、判断：

boolean canExecute()   //当前文件是否能被执行

boolean exists()  //当前文件是否存在

boolean isFile()       //当前文件是否是文件

boolean isDirectory()  //当前文件是否是文件夹（目录）；注意：在判断文件对象是否是文件或目录是们必须要判断该文件对象封装的内容是否存在，通过exists判断

boolean isHidden()   //当前文件是否是隐藏文件

boolean isAbsolute()   //测试此抽象路径名是否为绝对路径名

4、获取信息：

String getName()     //获取文件名

String getPath()     //获取文件的相对路径（即创建的对象传入的参数是什么就获取到什么）

String getParent()   //获取父目录，该方法返回绝对路径中的父目录，获取相对路径，返回null， 如果相对路径中有上一级目录，则返回的即为该目录

String getAbsolutePath()  //获取绝对路径

long length()   //返回文件的大小

long lastModified()  //返回上次修改的时间

static File[] listRoots() //获取文件的系统根，即各个盘符

String[] list()     //列出当前目录所有文件，包含隐藏文件。注：调用了list方法的file对象，必须是封装了一个目录，且该目录必须存在。

boolean renameTo(File dest)  //对文件重命名为dest

5、列出及过滤文件：

String[] list()   //列出当前目录所有文件，包含隐藏文件，调用list方法的file对象，必须是封装了一个目录，且该目录必须存在。

File[] list(FilenameFilter filter)  //FilenameFilter：文件名过滤器，是一个接口，其中包含一个方法，accept(File dir,String name)，返回的是boolean型，对不符合条件的文件过滤掉。

File[] listFiles()  //获取当前文件夹下的文件和文件夹，返回类型为File数组

ListFiles(FilenameFilter filter)   //同list，是对获取的 当前文件夹下的文件和文件夹的 文件名过滤器。

示例：

import java.io.*;  
class FileMethod  
{  
    public static void sop(Object obj)  
    {  
        System.out.println(obj);  
    }  
    public static void main(String[] args) throws IOException  
    {  
  
        //methodCreate();  
        //methodDel();  
        methodList();  
    }  
    public static void methodCreate()throws IOException  
    {  
        File f = new File("file.txt");  
        boolean b = f.createNewFile();  
        sop("create:" + b);  
        File dir = new File("abc");  
        File dir2 = new File("ab.txt");  
        b = dir2.mkdir();  
        sop("mkdir2:" + b);  
        b = dir.mkdir();  
        sop("midir:" + b);  
        File dirs = new File("abc\\aa\\bb\\cc");  
        b = dirs.mkdirs();  
        sop("mkdirs:" + b);  
    }  
    public static void methodDel()throws IOException  
    {  
        File f = new File("file.txt");  
        boolean b = f.delete();  
        sop("delete:" + b);  
        File f2 = new File("Demo.txt");  
        f2.createNewFile();  
        f2.deleteOnExit();//为避免由于在执行后面的程序发生异常，这里如果创建了一个临时文件，需要在程序结束时删除。  
    }  
  
    public static void methodList()throws IOException  
    {  
        File f = new File("D:\\File");  
        String[] arr =  f.list(new FilenameFilter(){  
            public boolean accept(File dir,String name)  
            {  
                return name.endsWith(".bmp");  
            }  
        });  
        sop("len:" + arr.length);  
        for(String name : arr)  
        {  
            sop("bmp文件为：" + name);  
        }  
    }  
}

4、递归：

对于每次循环都是用同一个功能的函数，即函数自身调用自身，这种表现形式或手法，称为递归。

注意：
1、限定条件，是作为结束循环用的，否则是死循环
2、注意递归的次数，尽量避免内存溢出。因为每次调用自身的时候都会先执行下一次调用自己的发那个发，所以会不断在栈内存中开辟新空间，次数过多，会导致内存溢出。

举例一：
列出指定目录下文件或文件夹，包含子目录，即列出指定目录下所有内容
分析：
因为目录中还有目录，只有使用同一个列出目录功能的函数完成即可，在列出过程中出现的还是目录的话，还可以再调用本功能，这就是利用递归原理。

import java.io.*;  
class FileBack  
{  
    public static void main(String[] args)   
    {  
        File f = new File("D:\\File\\f");  
        backShowName(f);  
    }  
    //获取文件及文件夹名  
    public static void backShowName(File dir)  
    {  
        //每次调用前，打印目录名  
        System.out.println(dir.getName());  
        //将文件存入File数组  
        File[] files = dir.listFiles();  
        for(int i=0; i<files.length;i++)  
        {  
            //如果是文件夹，调用自身  
            if(files[i].isDirectory())  
                backShowName(files[i]);  
            else  
                System.out.println(files[i].getName());  
        }  
    }  
}

举例二：
删除一个带内容的目录：
删除原理：
在window中，删除目录是从里往外删除的，同样使用递归

import java.io.*;  
class FileBack  
{  
    public static void main(String[] args)   
    {  
        File f = new File("D:\\File\\f");  
        removeDirs(f);  
    }  
    //删除文件夹所有内容  
    public static void removeDirs(File f)  
    {  
        //将文件存入File数组  
        File[] files = f.listFiles();  
        for (int i=0;i<files.length;i++)  
        {  
            //如果是文件夹，调用自身  
            if(files[i].isDirectory())  
                removeDirs(files[i]);  
            else  
                System.out.println(files[i].getName() + ":files:" + files[i].delete());  
        }  
        System.out.println(f.getName() + ":-dir-:" + f.delete());  
    }  
}

举例三：
将一指定目录中的java文件的绝对路径，存到一个文本文件中，建立一个java文件列表文件
思路：
1、对指定目录进行递归
2、获取递归过程所有的java文件的路径
3、将这些路径存储到集合中
4、将集合中的数据写到一个文件中

import java.util.*;  
import java.io.*;  
class WriterToFiles  
{  
    public static void main(String[] args)   
    {  
        File f = new File("D:\\JAVA");  
        List<File> list = new ArrayList<File>();  
        File dir = new File(f,"javalist.txt");  
        filesToList(f,list);  
        writeToFile(list,dir.toString());  
  
    }  
    //对指定目录进行递归  
    public static void filesToList(File f,List<File> list)  
    {  
        File[] files = f.listFiles();  
        for (int i=0;i<files.length;i++)  
        {  
            //如果是文件夹，再调用自身  
            if(files[i].isDirectory())  
                filesToList(files[i],list);  
            else  
            {  
                //获取递归过程所有的java文件的路径  
                if(files[i].getName().endsWith(".java"))  
                    //将这些路径存储到集合中  
                    list.add(files[i]);  
            }  
        }  
    }  
    //将集合中的数据写到一个文件中  
    public static void writeToFile(List<File> list,String javaListFile)  
    {  
        BufferedWriter bufw = null;  
        try  
        {  
            bufw = new BufferedWriter(new FileWriter(javaListFile));  
            //遍历集合，获取文件路径，并写入文件中  
            for(File f : list)  
            {  
                String path = f.getAbsolutePath();  
                bufw.write(path);  
                bufw.newLine();  
                bufw.flush();  
            }  
        }  
        catch (IOException e)  
        {  
            throw new RuntimeException("文件路径获取失败");  
        }  
        //最终关闭写入流资源  
        finally  
        {  
            try  
            {  
                if(bufw!=null)  
                bufw.close();  
            }  
            catch (IOException e)  
            {  
                throw new RuntimeException("文件路径获取失败");  
            }  
        }  
    }  
}

六、Properties 类

1、概述：

1、Properties是Hashtable的子类，它具备Map集合的特点，而且它里面还有存储的键值对，都是字符串，无泛型定义。是集合中和IO技术想结合的集合容器。

2、特点：
1）可用于键值对形式的配置文件
2）在加载时，需要数据有固定的格式，常用的是：键=值

2、特有方法：

1、设置和获取元素：

Object setProperty(String key,String value)  //调用Hashtable的方法put

String getProperty(String key)    //指定key搜索value

Set<String> stringPropertyName()   //返回属性列表的键集，存入Set集合

void load(InputStream ism)  //从输入字符流中读取属性列表

void load(Reader reader)  //从输入字符流中读取属性列表

load方法举例：

//load方法  
public static void loadMthod()throws IOException  
{  
    Properties pop =new Properties();  
    FileInputStream fis = new FileInputStream("info.txt");  
    //将流中的数据加载进集合  
    pop.load(fis);  
      
    pop.setProperty("zz","25");  
    pop.setProperty("ww","24");  
    FileOutputStream fos = new FileOutputStream("info.txt");  
    pop.store(fos,"hehe");  
    pop.list(System.out);  
    fis.close();  
    fos.close();  
  
}

举例：
如何将六种的数据存储到集合中？
将文本文件中的键值数据存到集合中：
1、用一个流和文件关联
2、读取一行数据，将改行数据用“=”切割
3、将等号左边作为键，右边作为值，存入到Properties集合即可

//将流中的数据存储到集合中  
public static void method()throws IOException  
{  
    BufferedReader bufr = null;  
    try  
    {  
        Properties pop = new Properties();  
        bufr = new BufferedReader(new FileReader("info.txt"));  
        String line = null;  
        while((line=bufr.readLine())!=null)  
        {  
            String[] arr = line.split("=");  
            pop.setProperty(arr[0],arr[1]);  
        }  
        System.out.println(pop);  
    }  
    catch (IOException e)  
    {  
        throw new RuntimeException("文件操作失败");  
    }  
    finally  
    {  
        try  
        {  
            if(bufr!=null)  
                bufr.close();  
        }  
        catch (IOException e)  
        {  
            throw new RuntimeException("关闭流资源操作失败");  
        }  
    }         
}

示例：用于记录应用程序运行次数
如果使用次数已到，那么给出注册提示需要使用计数器，但是在程序结束后，会在内存中消失，此时就需要将其存入到文件中，所以需要一个配置文件，用于记录该软件使用的次数。便于阅读和操作数据

键值对数据 ---> Map集合；
数据以文件形式存储 ---> IO技术。
--->Map+IO=Properties

import java.util.*;  
import java.io.*;  
class RunCount  
{  
    public static void main(String [] args)throws IOException  
    {  
        //创建一个Properties对象，集合和io的结合  
        Properties pop = new Properties();  
        //创建一个文件对象，用于操作文件  
        File file = new File("count.ini");  
        //先判断文件是否存在，如果不存在就创建一个  
        if(!file.exists())  
            file.createNewFile();  
  
        //创建读取流对象，读取文件中的信息  
        FileInputStream fis = new FileInputStream(file);  
        //将流中的文件信息存入集合中  
        pop.load(fis);  
          
        //定义计数器  
        int count = 0;  
        //获取文件中键所对应的值  
        String value = pop.getProperty("time");  
        //判断值是否为null，不为空就将值传给计数器  
        if(value!=null)  
        {  
            count = Integer.parseInt(value);  
            //判断计数器是否为到达次数  
            if(count>=5)  
            {  
                System.out.println("次数已到，请注册");  
                return ;  
            }  
        }  
        count++;  
        //将获得的键值设置后存入集合中  
        pop.setProperty("time",count+"");  
        FileOutputStream fos = new FileOutputStream(file);  
        pop.store(fos,"");  
        fos.close();  
        fis.close();  
    }  
}

七、打印流

1、概述：

1、打印流包括：PrintStream和PrintWriter

2、该流提供了打印方法，可将各种类型的数据都原样打印

2、字节打印流：PrintStream

构造方法中可接收的参数类型：

1、file对象。File

2、字符串路径：String

3、字符输出流：OutputStream

3、字符串打印流：PrintWriter

构造方法中可接受的参数类型

1、file对象：File

2、字符串路径：String

3、字节输出流：OutputStream

4、字符输出流：Writer

举例：

import java.io.*;  
  
class PrintDemo  
{  
    public static void main(String[] args) throws IOException  
    {  
        //键盘录入，创建读取流对象  
        BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));  
        //使用打印流，将文件输出  
        //输出到屏幕  
        PrintWriter out = new PrintWriter(new FileWriter("a.txt"),true);  
        String line = null;  
        while((line=bufr.readLine())!=null)  
        {  
            if("over".equals(line))  
                break;  
            out.println(line.toUpperCase());  
            //out.flush();  
        }  
        bufr.close();  
        out.close();  
    }  
}

八、合并流

1、概述：

1、SequenceInputStream可以将多个流连接成一个源

2、构造函数：

SequenceInputStream(Enumeration<? extends FileInputStream> e)

2、如何合并多个文件：

1、创建集合，并将流对象添加进集合

2、创建Enumeration对象，将集合元素加入。

3、创建SequenceInputStream对象，合并流对象

4、创建写入流对象，FileOutputStream，将数据写入流资源

5、定义数组，将读取流数据存入数组，并将数组中元素写入文件中。

举例：
假设有三个文件，将三者合并到一个新文件中

//合并流对象  
public static void sequenceFile()throws IOException  
{  
    FileOutputStream fos = null;  
    SequenceInputStream sis = null;  
    try  
    {  
        //创建集合，存储多个文件  
        ArrayList<FileInputStream> al = new ArrayList<FileInputStream>();  
        for(int i=1;i<=3;i++)  
        {  
            al.add(new FileInputStream(i+".part"));  
        }  
        //匿名内部类访问局部变量要final  
        final Iterator<FileInputStream> it = al.iterator();  
        //创建Enumeration匿名对象  
        Enumeration<FileInputStream> en = new Enumeration<FileInputStream>()  
        {  
            public boolean hasMoreElements()  
            {  
                return it.hasNext();  
            }  
            public FileInputStream nextElement()  
            {  
                return it.next();  
            }  
        };  
        //合并流对象，将集合元素加入。  
        sis = new SequenceInputStream(en);  
        //创建写入流对象，FileOutputStream  
        fos = new FileOutputStream("7.bmp");  
        byte[] b = new byte[1024*1024];  
        int len = 0;  
        //循环，将数据写入流资源  
        while((len=sis.read(b))!=-1)  
        {  
            fos.write(b);  
        }  
  
    }  
    catch (IOException e)  
    {  
        throw new RuntimeException("文件操作失败");  
    }  
    //关闭流资源  
    finally  
    {  
        try  
        {  
            if(fos!=null)  
                fos.close();  
        }  
        catch (IOException e)  
        {  
            throw new RuntimeException("关闭流资源操作失败");  
        }  
        try  
        {  
            if(sis!=null)  
                sis.close();  
        }  
        catch (IOException e)  
        {  
            throw new RuntimeException("关闭流资源操作失败");  
        }  
    }         
}

3、切割流资源：

1、先关联文件FileInputStream

2、定义写入流变量：FileOutputStream

3、创建数组，并定义切割所需的大小|

4、循环读写数据，并每次创建一个新写入流，创建完后并写入文件中

5、关闭流资源

    //切割流对象  
    public static void splitFile()throws IOException  
    {  
        //创建全局变量  
        FileInputStream fis = null;  
        FileOutputStream fos = null;  
        try  
        {  
            //创建文件读取流  
            fis = new FileInputStream("0.bmp");  
            //创建数组  
            byte[] b = new byte[1024*1024];  
            int len = 0;  
            //计数器  
            int count = 1;  
            //循环写入数据  
            while((len=fis.read(b))!=-1)  
            {  
                //每次创建一个新写入流，写入后关闭流资源  
                fos = new FileOutputStream((count++)+".part");  
                fos.write(b,0,len);  
                fos.close();  
            }  
        }  
        catch (IOException e)  
        {  
                throw new RuntimeException("关闭流资源操作失败");  
        }  
        //关闭流资源  
        finally  
        {  
            try  
            {  
                if(fis!=null)  
                    fis.close();  
            }  
            catch (IOException e)  
            {  
                throw new RuntimeException("关闭流资源操作失败");  
            }  
        }  
          
    }  
}