黑马程序员技术交流社区

标题: 关于IO流的问题 [打印本页]

---

作者: zhangxun    时间: 2014-9-6 00:08
标题: 关于IO流的问题
深夜12点了，直到很多人还没睡呢，苦逼的我还在一边敲着代码一边做个学习笔记，第一次看IO的视频，感觉有点乱，求一个系统点的IO资料

---

作者: 黑马的小菜鸟    时间: 2014-9-6 00:48

概述：

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

---

作者: 黑马的小菜鸟    时间: 2014-9-6 00:49
第一节   字符流
一、简述：

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

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

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

二、字符流的读写

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）读取后要将流资源关闭。


示例：

[java] view plaincopyprint?
<span style="font-family:Arial;font-size:10px;">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("读取流资源失败。");  
                }  
            }  
        }  
    }  
}  
</span>  

---

作者: 黑马的小菜鸟    时间: 2014-9-6 00:50
二、文件的拷贝：

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


示例：

[java] view plaincopyprint?
<span style="font-family:Arial;">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("写入流资源关闭失败。");  
                }  
            }  
        }  
    }  
}</span>  


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

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

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

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

1）创建一个字符写入流对象

2）为提高字符写入流效率，加入缓冲技术，只要将需要被提高效率的流对象作为参数传递给缓冲区的构造函数即可。

      注意，只要用到缓冲去就需要刷新。

3）其实关闭缓冲区就是在关闭缓冲区中的流对象。

－－－＞该缓冲区中提供了一个跨平台的换行符：newLine()。

4、读取流缓冲区BufferedReader的步骤：
1）创建一个读取流对象和文件关联

2）为提高效率，加入缓冲技术，将字符读取流对象作为参数传递给缓冲对象的构造函数。

3）该缓冲区提供了一个一次读一行的方法readLine()，方便与对文本数据的获取，当返回null时，表示读到文件末尾。

      readLine()方法返回的时只返回回车符之前的数据内容，并不返回回车符，即读取的内容中不包含任何行终止符（回车符和换行符）。

--->readLine()方法原理：无论是读一行，或读取多个字符，其实最终都是在硬盘上一个一个读取。所以最终使用的还是read方法一次读一个。

示意图：


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

示例：

[java] view plaincopyprint?
<span style="font-family:Arial;">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("写入流资源关闭失败。");  
                }  
            }  
        }  
    }  
}  
</span>  


6、自定义BufferedReader：

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

步骤：a.初始化自定义的类，加入流对象。

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

[java] view plaincopyprint?
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()

示例：

[java] view plaincopyprint?
......  
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);  
    }  
}  
......  

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

---

作者: 黑马的小菜鸟    时间: 2014-9-6 00:51
四、装饰设计模式：

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

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

3、装饰和继承的区别：

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

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

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

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

        要继承相应的父类，就需要将所有的抽象方法实现，或交给子类实现。

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


第二节   字节流
一、概述：

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

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

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

                              OutputStream  --->  输出流（写）

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

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

5、特有方法：

      int available() --->  放回数据字节的长度，包含终止符

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

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

二、拷贝媒体文件：

1、思路：

1）用字节流读取流对象和媒体文件相关联

2）用字节写入流对象，创建一个媒体文件，用于存储获取到的媒体文件数据

3）通过循环读写，完成数据的存储

4）关闭资源

示例：

[java] view plaincopyprint?
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("读取流关闭失败");  
                }         
            }  
        }  
    }  
}  

三、字节流缓冲区：
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做与运算即可
[java] view plaincopyprint?
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();  
    }  
}  

---

作者: 黑马的小菜鸟    时间: 2014-9-6 00:52
第三节   流操作规律
一、读取键盘录入：

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的子类

[java] view plaincopyprint?
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("写入流关闭失败。");  
            }  
        }  
    }  
}  

二、流操作规律：

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
[java] view plaincopyprint?
FileReader fr = new FileReader("a.txt");  
BufferedReader bufr = new BufferedReader(fr);  

2）目的：使用写入流：OutputStream和Writer

      --->  明确体系：是否为文本文件：是，选Writer
      --->  明确设备：明确要使用该体系中哪个对象：硬盘上一个文件。即Writer体系中可操作对象的是FileWriter

      --->  是否需要高效：是，加入Writer体系中的缓冲区：BufferedWriter
[java] view plaincopyprint?
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);

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

示例：

[java] view plaincopyprint?
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("写入流关闭失败。");  
            }  
        }  
    }  
}  

---

作者: 黑马的小菜鸟    时间: 2014-9-6 00:55
第四节   信息

一、异常的日志信息：

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

示例：

[java] view plaincopyprint?
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);  
        }  
    }  
}  
二、系统信息：

获取系统信息：
Properties getProperties()
将信息输出到指定输出流中
void  list(PrintStream out)
将输出流中数据存入指定文件中
new PrintStream("systeminfo.txt")
示例：

[java] view plaincopyprint?
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("获取系统信息失败。");  
        }  
    }  
}  

---

欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2