黑马程序员_java＿ＩＯ总结

Java IO 流详解

最新推荐文章于 2022-01-06 17:26:46 发布

原创最新推荐文章于 2022-01-06 17:26:46 发布 · 406 阅读

0 ·

CC 4.0 BY-SA版权

本文详细介绍了Java IO流的基础知识，包括字节流与字符流的区别、常用的IO流类及其实例化方法、缓冲区对象的作用及使用方法等。并通过多个示例展示了如何使用Java IO流进行文件操作。

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

javaIO总体是围绕以下四个抽象类来进行扩充展开。
　　　　[凡以...stream结尾的类，都是字节流/比特流；
　　　　凡以Reader或Writer结尾的类，都是字符流]

1.InputStream：输入字节流(通常所说的从文件中读取字节，以字符形式显示)。
2.OutputStream：输出字节流(通常所说的将字节写入到文件中)。
3.Reader：输入字符流
4.Writer：输出字符流
上述四个抽象类，必须要用相关的子类进行实例化。

IO流：
　字符流
　字节流

字符流：
FileReader
FileWriter。

BufferedReader
BufferedWriter

字节流：
FileInputStream
FileOutputStream

BufferedInputStream

BufferedOutputStream

其中加入buffered的前缀的是缓冲区对象，缓冲区对象的创建要先有流对象的存在，缓冲的存在是为了增强流的功能而存在，其实缓冲区内部也是使用流对象方法，只不过是将数据先存在临时创建的数组对象中，为了提高程序的效率

建立缓冲区对象必须把流对象作为参数传递给缓冲区的构造函数。
BufferedWriter bufw = new BufferedWriter(new FileWriter("buf.txt")); bufw.write("abce");//将数据写入到了缓冲区。

bufw.flush();//对缓冲区的数据进行刷新。将数据刷到目的地中。

bufw.close();//关闭缓冲区，其实关闭的是被包装在内部的流对象。

字节流和字符流的区别：

1，字节流读取的时候，读到一个字节就返回一个字节。字符流使用了字节流读到一个或多个字节(中文对应的字节数是两个，在UTF-8 码表中是3个字节)时。先去查指定的编码表，将查到的字符返回。

2，字节流可以处理所有类型数据，如图片，mp3，avi。而字符流只能处理字符数据。所以若是是处理纯文本数据，就要优先考虑使用字符流。除此之外都用字节流。

在IO流中，当流对象使用完后必须关闭，否则会消耗系统资源。

以下是IO流缓冲区对象的读写

readLine():方法的原理：其实缓冲区中的该方法，用的还是与缓冲区关联的流对象的read方法。只不过，每一次读到一个字符，先不进行具体操作，先创建数组进行临时存储数据。当读取到回车标记时，将临时容器中存储的数据一次性返回。

当read的方法都读完是会返回一个-1，这是因为而在所操作的数据中的很容易出现连续多个1的情况，而连续读到8个1，就是-1. 导致读取会提前停止。

转换流：
特点：
1，是字节流和字符流之间的桥梁。
2，该流对象中可以对读取到的字节数据进行指定编码表的编码转换。
什么时候使用呢?
1，当字节和字符之间有转换动作时。
2，流操作的数据需要进行编码表的指定时。   具体的对象体现：
1，InputStreamReader：字节到字符的桥梁。
2，OutputStreamWriter：字符到字节的桥梁。

  这两个流对象是字符流体系中的成员。
  那么它们有转换作用，而本身又是字符流。所以在构造的时候，需要传入字节流对象进来。
  构造函数：
InputStreamReader(InputStream):通过该构造函数初始化，使用的是本系统默认的编码表。   InputStreamReader(InputStream,String charSet):通过该构造函数初始化，可以指定编码表。

OutputStreamWriter(OutputStream):通过该构造函数初始化，使用的是本系统默认的编码表。 OutputStreamWriter(OutputStream,String charSet):通过该构造函数初始化，可以指定编码表

操作文件的字符流对象是转换流的子类。

如：FileRead是InputStreamReader的子类，FileWritre是OutputStreamWriter的子类

如果要使用指定编码时，要使用字符流

 

import java.io.FileWriter;

import java.io.IOException;

 

/*

 * 字符流和字节流

 * 字节流两个基类

 * InputStream OutputStream

 *

 * 字符流两个基类

 * Reader Writer

 * 先学习一下流的特点

 * 既然IO流是用于操作数据的，那么数据的常见体现形式:文件

 *

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

 * 需求：在硬盘上，创建一个文件并写入一些文件

 *

 * 找到一个专门用于操作文件的Writer子类对象。FileWriter

 */

public class Test8

{

        public static voidmain(String[] args) throws IOException

        {

                  //1. 创建一个FileWriter对象,该对象一被初始化就必须明确要操作的文件

                  //而且该文件会创建到指定的目录下

                  //如果该目录下已有同名文件，将会被覆盖

                  //其实该步就是要明确数据要存放的目的地

                    FileWriter fw=new  FileWriter("k:/hello.txt");

                   

                    //调用write()方法写到流中

                    fw.write("jj");

                    //将数据刷新到目的地

                    fw.flush();

                    fw.write("kkk");

                    fw.flush();

                   

                    //close()关闭流资源，但是关闭流之前会刷新一次缓冲中的数据.将数据刷到目的的中

                    //flush刷新后，流可以继续使用。而close后将不能！

                    fw.close();

        }

 

}

IO的异常处理

package d18;

 

import java.io.FileWriter;

import java.io.IOException;

 

/*

 * IO异常的处理方式

 */

public class Test9

{

    public static voidmain(String[]args)

        {

            FileWriterfw=null;

                  try

                  {

                           fw=newFileWriter("K:/hello.txt");

                           fw.write("hello");

                           fw.flush();//刷新

                  }

                  catch (IOExceptione)

                  {

                           e.printStackTrace();

                  }

                  finally

                  {

                           try

                           {

                                    if(fw!=null)//必须判断不为空

                                       fw.close();

                           }

                           catch(IOException e)

                           {

                                    e.printStackTrace();

                           }

                           

                  }

        }

}

Public FileWriter(StringFileName,booleanappend)//指定是否续写

package d18;

 

import java.io.File;

import java.io.FileWriter;

import java.io.IOException;

 

/*

 * 在一个已有文件续写

 * PublicFileWriter(StringFileName,boolean append)

 */

public class Test10

{

   public static voidmain(String[]args)

        {

                  FileWriter fw=null;

                  try

                  {

                           fw = newFileWriter("K:/hello.txt",true);

                           fw.write("这是追加的内容");

                           StringnextLine="\r\n";//windows的换行表示\r\n;

                           fw.write(nextLine+"你好"+nextLine+"谢谢");

                           fw.flush();

                  }

                  catch (IOExceptione)

                  {

                           e.printStackTrace();

                  }

                  finally

                  {

                           try

                           {

                                    if(fw!=null)//判断为空

                                    fw.close();

                           }

                           catch(IOException e)

                           {

                                    e.printStackTrace();

                           }

                  }

        }

}

读取数据

package d18;

 

import java.io.*;

 

public class Test11

{

   public static voidmain(String[]args)

        {

           FileReader fr=null;

           try

                  {

                     //创建一个文件读取流对像，和指定的名称的文件相关联。

                     //要保证该文件是已经存在的，如果不存在，会发生异常

                           fr=newFileReader("K:/hello.txt");

                           /*

                           //读单个字符fr.read()

                           int ch=fr.read();

                           System.out.println("ch="+(char)ch);

                           intch2=fr.read();

                           System.out.println("ch2="+(char)ch2);

                           

                           //通过以上可以发现，read()会自动向下读

                           */

                           

                           //读取结尾的标志-1

                           /*while(true)

                           {

                                    intch=fr.read();

                                    if(ch==-1)

                                              break;

                                    System.out.print((char)ch);

                           }*/

                           

                           //改进

                           int ch=0;

                           while((ch=fr.read())!=-1)                    

                           {

                                    System.out.print((char)ch);

                           }

                           //byte[]buffer=new byte[1024];

                  }

                  catch (Exception e)

                  {

                           e.printStackTrace();

                  }

           finally

           {

                     try

                           {

                                    if(fr!=null)

                                              fr.close();

                           }

                      catch (Exception e2)

                           {

                                    

                           }

           }

          

        }

}

package d18;

 

import java.io.FileNotFoundException;

import java.io.FileReader;

 

/*

 * 第二种方式:通过字符数组进行读取

 */

public class Test12

{

    public static voidmain(String[]args) throws Exception

        {

                  FileReader fr=newFileReader("K:/hello.txt");

                  //定义一个字符数组，用于存储读到的字符

                  //该read(Char[])返回的是读到的字符个数

                  char[] buf=new char[1024];

                  int num=0;

                  while((num=fr.read(buf))!=-1)

                  {

                           System.out.println("num="+num);

                           System.out.println(newString(buf,0,num));

                  }

        }

}

读取一个.java文件

package d18;

 

import java.io.FileNotFoundException;

import java.io.FileReader;

import java.io.FileWriter;

 

/*

 * 读取一个.java文件，并打印在控制台上

 */

public class Test13

{

   public static voidmain(String[]args) throws Exception

        {

           FileReader fr=new FileReader("Test.java");

                  char[] buf=new char[1024];

                  int len=0;

                  while((len=fr.read(buf))!=-1)

                  {

                           System.out.print(newString(buf,0,len));

                  }

        }

}

* 将c盘的一个文件复制到D盘

* 复制的原理：

* 将c盘下文件数据存储到D盘

* 步骤

* 1. 在D盘创建一个文件，用于存储c盘文件中的内容

* 2. 定义读取流和c盘文件关联

* 3. 通过不断的读写完成数据的存储

* 5. 关闭资源

package d18;

 

import java.io.File;

import java.io.FileReader;

import java.io.FileWriter;

import java.io.IOException;



public class Test14

{

   public static voidmain(String[]args) throws IOException

        {

                  cop_1();

                  cop_22();

        }

   //从c盘读一个字符，就向D盘写一个数据

    public static voidcop_1() throwsIOException

       {

              //创建目的去

            FileWriterfw=newFileWriter("haha_copy.txt");

           

            //与已有文件关联

            FileReaderfr=newFileReader("haha.txt");

            intch=0;

            while((ch=fr.read())!=-1)

            {                                                                                        

                     fw.write(ch);

            }

            fw.flush();

            fw.close();

       }

   

    public static voidcop_22() throwsIOException

    {

            FileWriterfw=newFileWriter("hello_copy.txt");

            FileReaderfr=newFileReader("hello.txt");

            char[]buf=new char[1024];

            intlen=0;

            while((len=fr.read(buf))!=-1)

            {

                     fw.write(buf,0,len);

            }

            fw.flush();

            fw.close();

    }

}

字符流的缓冲区

1. 缓冲区的出现提高了对数据的读写效率

2. 对应类

BufferedReader

BufferedWriter

3. 缓冲区要结合流才可以使用

4. 在流的基础上对流的功能进行增强

BufferedWriter

将文本写入字符输出流，缓冲各个字符，从而提供单个字符，数组和字符串的高效输入

可以指定缓冲区的大小，或者接受默认的大小。

该类提供了newLine()方法，它使用平台自己的行分割符概念，此概念由系统属性line.separator定义，并非所有平台都使用新行符”\n”来终止个行.因此调用此方法来终止每个输出航都要优于直接写新行符

BufferedWriter(Writer out)
创建一个使用默认大小输出缓冲区的缓冲字符输出流。

BufferedWriter(Writer out,int sz)
创建一个使用给定大小输出缓冲区的新缓冲字符输出流。

BufferedReader

从字符输入流读取文本，缓冲各个字符，从而实现字符，数组和行的高效读取。

可以指定缓冲区的大小，可以使用more的大小

BufferedReader(Reader in)
创建一个使用默认大小输入缓冲区的缓冲字符输入流。

BufferedReader(Reader in,int sz)
创建一个使用指定大小输入缓冲区的缓冲字符输入流。

package day19;

 

importjava.io.BufferedWriter;

importjava.io.FileWriter;

importjava.io.IOException;

 

/*

 * 缓冲区的对象是未提高流的操作效率而出现的

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

 */

public classTest1

{

        public static voidmain(String[] args) throws IOException

        {

                  //创建一个字符写入流

                  FileWriter fw=newFileWriter("buf.txt");

                  

                  //为了提高字符写入流效率，加入缓冲技术，

                  //只要将需要被提高效率的流对象作为参数传递给缓冲区的构造函数即可

                  

                  BufferedWriter bfw=newBufferedWriter(fw);

                  bfw.write("kkk");

                  

                  bfw.newLine();//跨平台

                  

                  bfw.write("lll");

                  //记住，只要用到缓冲区，就要记得刷新

                  bfw.flush();

                  

                  //close()先刷新在关闭，其实关闭缓冲区，就是关闭缓冲区的流对象

                  bfw.close();

        }

  

}                   

 
 

package day19;

 

import java.io.BufferedReader;

import java.io.FileNotFoundException;

import java.io.FileReader;

import java.io.FileWriter;

 

//字符读取流缓冲区；

//该缓冲区提供了一个一次读取一行的方法，方便对文本的读取，

public class Test2

{

    public static voidmain(String[]args) throws Exception

        {

                  //创建一个读取流对象和文件相关联

            FileReaderfr=newFileReader("buf.txt");

           

            //为了提高效率，加入了缓冲技术，

            //将字符读取流对象作为参数传递给缓冲对象的构造函数

            BufferedReaderbufr=newBufferedReader(fr);

           

            //按行读取

            Stringline=null;

           while((line=bufr.readLine())!=null)

            {

                     System.out.println(line);

            }

            bufr.close();

        }

}

 

 

packageday19;                                                     

 

import java.io.*;

 

/*

 * 通过缓冲区复制一个.java文件

 */

public class Test3

{

    public static voidmain(String[]args) throws Exception

        {

                  BufferedReaderbufr=new BufferedReader(new FileReader("Test.java"));

                  BufferedWriterbufw=new BufferedWriter(newFileWriter("TestCopy.java"));

                  String line=null;

                  while((line=bufr.readLine())!=null)

                  {

                           bufw.write(line);

                           bufw.newLine();

                  }

                  bufw.flush();

        }

}

*装饰设计模式

*当想要对已有的对象进行功能增强时

*可以定义类，将已有的对象传入，基于已有的功能，并提供加强功能

*那么将自定义的该类称为装饰类

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

*并基于被装饰的对象的功能，提供更强大的功能

package day19;

 

import javax.swing.SpinnerDateModel;

 



class Person

{

        public void chifan()

        {

                  System.out.println("吃饭");

        }

}

class SuperPerson

{

        private Person p;

        public SuperPerson(Person p)

        {

                  this.p=p;

        }

        public void superChifan()

        {

                  System.out.println("开胃酒");

                  System.out.println("吃饭");

                  System.out.println("甜点");

                  System.out.println("来一根");

        }

}

public class Test4

{

    public static voidmain(String[]args)

        {

                  Person p=newPerson();

                  //p.chifan();

                  SuperPerson sp=newSuperPerson(p);

                  sp.superChifan();

        }

}

package day19;

* MyReader

* |- MyTextReader

* |--MyBufferedTextReader

* |- MyMediaReader

* |--MyBufferedMediaReader

* |- MyDataReader

* |--MyBufferedDataReader

* class MyBufferReader

* {

* MyBufferReader(MyTextReadertext)

* {

* }

* MyBufferReader(MyMediaReadermedia)

* {

* }

*上面这个类扩展性很差

找到其参数的共性，通过多态的形式，可以提高扩展性

class MyBufferReader

* {

* MyBufferReader(MyReaderr)

* {

* }

* MyReader

* |- MyTextReader

* |- MyMediaReader

* |- MyDataReader

* |--MyBufferedDataReader

* 装饰模式比继承要灵活，避免了继承体系臃肿

* 并且降低了类与类直接的关系

* 装饰类因为增强已有的对象，具备的功能和已有的是相同的，只不过提供了更强的功能

* 所以装饰类和被装饰类通常是都属于一个体系中

public class Test5

{

public static voidmain(String[]args)

{

}

package day19;

import java.io.FileNotFoundException;

import java.io.FileReader;

import java.io.LineNumberReader;

public class Test6

{

    public static voidmain(String[]args) throws Exception

        {

                  FileReader fr=newFileReader("Test.java");

                  LineNumberReaderlnr=new LineNumberReader(fr);

                  String line=null;

                  lnr.setLineNumber(100);//设置起始行号

                  while((line=lnr.readLine())!=null)

                  {

                           System.out.println(lnr.getLineNumber()+":"+line);

                  }

                  lnr.close();

        }

}

public class Test7

{

public static voidmain(String[]args) throws Exception

{

FileReader fr=newFileReader("buf.txt");

MyLineNumberReadermylnr=new MyLineNumberReader(fr);

String line=null;

while((line=mylnr.myReadLine())!=null)

{

System.out.println(mylnr.getLineNumber()+":"+line);

}

mylnr.myColse();

}

package day19;

import java.awt.color.ICC_ColorSpace;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

* 字符流

* FileReader

* FileWriter

* BufferedReader

* BufferedWriter

* 字节流

* InputStream OutputStream

* 需求：想要操作图片数据.这事就要用到字节流

public class Test8

{

public static voidmain(String[]args) throws Exception

{

writeFile();

readFile_1();

System.out.println("\n____________________");

readFile_2();

readFile_3();

}

public static voidwriteFile() throwsException

{

FileOutputStreamfos=newFileOutputStream("fos.txt");

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

* 字符流一样走的字节流

fos.close();//不具备刷新功能

}

public static voidreadFile_1() throwsException

{

FileInputStreamfis=newFileInputStream("fos.txt");

intch=0;

while((ch=fis.read())!=-1)

{

System.out.print((char)ch);

}

fis.close();

}

public static voidreadFile_2() throwsException

{

FileInputStreamfis=newFileInputStream("fos.txt");

intlen=0;

byte[]buf=new byte[1024];

while((len=fis.read(buf))!=-1)

{

System.out.println(newString(buf,0,len));

}

public static voidreadFile_3() throwsException

{

FileInputStreamfis=newFileInputStream("fos.txt");

intnum=fis.available();//用处：定义一个刚刚好的数组

System.out.println("总个数:"+num);//包括\r\n

byte[]buf=new byte[num];//定义一个刚刚好的数组

intlen=0;

while((len=fis.read(buf))!=-1)

{

System.out.println(new String(buf,0,len));

}

//定义刚刚好的数组，也有弊端，一个电影都哈几百兆，虚拟机启动才64兆

//所以这种方法要慎用

}

package day19;

import java.io.FileInputStream;

import java.io.FileOutputStream;

* 复制一个图片

* 思路:

* 1. 用字节流读取流和图片关联

* 2. 用字节写入流对象创建一个图片文件，用于存储渠道的图片资源

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

* 4. 关闭资源

public class Test9

{

public static voidmain(String[]args)

{

FileInputStreamfis=null;

FileOutputStreamfos=null;

try

{

fis=newFileInputStream("ex.png");

fos=new FileOutputStream("ex_cp.png");

byte[]buf=new byte[1024];

int len=0;

while((len=fis.read(buf))!=-1)

{

fos.write(buf,0, len);

}

catch (Exception e)

{

throw newRuntimeException(e);

}

finally

{

try

{

if(fis!=null)

fis.close();

} catch(Exception e2)

{

//TODO: handle exception

}

try

{

if(fos!=null)

fos.close();

} catch(Exception e2)

{

//TODO: handle exception

}

package day19;

import java.io.BufferedInputStream;

import java.io.BufferedOutputStream;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

* 演示mp3的复制，通过缓冲区

* BufferedInputStream

* BufferedOutputStream

public class Test10

{

public static voidmain(String[]args)throws Exception

{

copy_1();

}

//通过字节流的缓冲区完成复制

public static voidcopy_1() throwsException

{

BufferedInputStreambis=newBufferedInputStream(new FileInputStream("K:/a1.mp3"));

BufferedOutputStreambos=newBufferedOutputStream(new FileOutputStream("K:/a2.mp3"));

intby=0;

while((by=bis.read())!=-1)

{

bos.write(by);

}

bis.close();

bos.close();

}

package day19;

import java.io.BufferedInputStream;

import java.io.InputStream;

* 字节流:

* FileInputStream

* FileOutputStream

* BufferedInputStream

* BufferedOutputStream

* 读取键盘录入System.in

* 当录入一行数据后，就将数据打印，

* 如果录入的数是over,那么就停止录入

public class Test11

{

public static voidmain(String[]args)throws Exception

{

InputStreamis=System.in;

StringBuilder sb=newStringBuilder();

while(true)

{

intch=is.read();

sb.append((char)ch);

if(ch=='\r')

continue;

if(ch=='\n')

{

Strings=sb.toString();

if("over".equals(s))

break;

System.out.println(s);

sb.delete(0,sb.length());

}

else

{

sb.append((char)ch);

}

InputStreamReader 是字节流通向字符流的桥梁：它使用指定的 charset 读取字节并将其解码为字符。它使用的字符集可以由名称指定或显式给定，或者可以接受平台默认的字符集。

package day19;

import java.io.BufferedReader;

import java.io.InputStream;

import java.io.InputStreamReader;

* 通过刚才的键盘录入一行数据并打印器大写，发现就是读取一行数据的原理

* 也就是readLine方法

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

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

* System.in是字节流

* 就要设计到流的转换

public class Test12

{

public static voidmain(String[]args)throws Exception

{

//获取键盘录入对象

InputStreamis=System.in;

//将字节流对象转换成字符流对象,使用转换流,InputStreamReader

InputStreamReaderisr=new InputStreamReader(is);

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

BufferedReader br=newBufferedReader(isr);

String line=null;

while((line=br.readLine())!=null)

{

if("over".equals(line))

break;

System.out.println(line.toUpperCase());

}

br.close();

}

OutputStreamWriter 是字符流通向字节流的桥梁：可使用指定的 charset 将要写入流中的字符编码成字节。它使用的字符集可以由名称指定或显式给定，否则将接受平台默认的字符集。

package day19;

import java.io.BufferedReader;

import java.io.BufferedWriter;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.io.OutputStream;

import java.io.OutputStreamWriter;

* 通过刚才的键盘录入一行数据并打印器大写，发现就是读取一行数据的原理

* 也就是readLine方法

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

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

* System.in是字节流

* 就要设计到流的转换

public class Test12

{

public static voidmain(String[]args)throws Exception

{

//获取键盘录入对象

InputStreamis=System.in;

//将字节流对象转换成字符流对象,使用转换流,InputStreamReader

InputStreamReaderisr=new InputStreamReader(is);

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

BufferedReader br=newBufferedReader(isr);

OutputStreamos=System.out;

OutputStreamWriterosw=new OutputStreamWriter(os);

BufferedWriter bw=newBufferedWriter(osw);

String line=null;

while((line=br.readLine())!=null)

{

if("over".equals(line))

break;

//System.out.println(line.toUpperCase());

//或者

osw.write(line.toUpperCase());

bw.newLine();

osw.flush();

}

br.close();

}

package day19;

import java.io.BufferedInputStream;

import java.io.BufferedReader;

import java.io.BufferedWriter;

import java.io.FileOutputStream;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.io.OutputStreamWriter;

* 将键盘数据存入到文件

public class Test13

{

public static voidmain(String[]args)throws Exception

{

//键盘常见写法

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

BufferedWriterbufw=new BufferedWriter(new OutputStreamWriter(newFileOutputStream("fos.txt")));

String line=null;

while((line=bufr.readLine())!=null)

{

if("over".equals(line))

break;

bufw.write(line);

bufw.newLine();

bufw.flush();

}

bufw.close();

}

package day19;

import java.io.*;

* 将键盘数据存入到文件

public class Test14

{

public static voidmain(String[]args)throws Exception

{

//键盘常见写法

BufferedReaderbufr=new BufferedReader(new InputStreamReader(newFileInputStream("fos.txt")));

BufferedWriterbufw=new BufferedWriter(new OutputStreamWriter(System.out));

String line=null;

while((line=bufr.readLine())!=null)

{

if("over".equals(line))

break;

bufw.write(line);

bufw.newLine();

bufw.flush();

}

bufw.close();

}

流操作的基本规律:

最痛苦的就算流对象有很多，不知道该用哪个?

通过两个明确来完成

1. 明确源头和目的

源: 输入流InputStream Reader

目的:输出流 outputStream Writer

2. 操作的数据是否是村文本?

是:字符流

否:字节流

3. 当体系明确后，在明确要使用哪个具体的对象

通过设备来进行区分:

设备:内存，硬盘，键盘

目的设备:内存，硬盘，控制台

需求:

将一个文件中的数据存到另外一个文件:复制文件
源:文件

目的：文件

明确体系；

明确设备:硬盘，一个文件

Reader体系中可以使用Filereader

FileReader fr=newFileReader(“a.txt”);

是否需要提高效率?

是!加入Reader体系中的BufferedReader

BufferedReader br=newBufferedReader(fr);

目的:

是否是村文本?

是:writer

可以使用Filewriter

FileWriter fw=new FileWriter(“a.copt.txt”);

是否需要效率提高!

是!加入Writer体系中的缓冲区BufferedWriter

BufferedWriterbw=new BufferedWriter(fw);

练习：将一个图片文件中的数据存储到另外一个文件中

源头:文件 FileInputStream

目的:文件 FileOutputStream

需求:将键盘录入的数据存储到一个文件

源头:InputStreamReader

是不是村文本?

是!用Reader

设备:键盘

System.in字节流

不是选择Reader？System.in对应的是字节流?

为了操作键盘数据方便，转换成字符流按照字符串操作最方便的

所以既然明确了Reader，那么将System.in转换成Reader.

用了Reader体系中的转换流:InputStreamReader

InputStreamReaderisr=newinputStreamReader(System.in);

需要提高效率?需要!BufferedReader

BufferedReaderbufr=new BufferedReader(isr);

目的:outputStream writer

是否是村文本?是!Writer

设备:硬盘.一个文件使用FileWriter.

FileWriterfw=new Filewriter(“c.txt”);

需要提高效率?需要

BufferedWriterbufw=new BufferedWriter(fw);

*******************************************************************8

扩展一下:想要把录入的数据按照指定的编码表（utf-8），将数据存到文件中

目的:OutputStream Writer

是否是村文本?是! Writer.

设备:硬盘。一个文件.使用FileWriter

FileWriter默认的编码GBK

但是存储市，需要加入指定的码表，而指定的编码表只能转换流可以指定.treamWriter.

所以要使用的对象是OutputStreamWriter

而该转换流对象需要接受一个字节输出流，而且还可以操作的文件的字节输出流

OutputStreamWriterosw=newOutputStreamWriter(new FileOutputStream(“d.txt”));

需要高效?需要

BufferedWriterbuw=new BufferedWriter(osw);

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

BufferedWriterbw=new BufferedWriter(newOutputStreamWriter(new FileOutputStream("d.txt"),"UTF-8"));

package day19;

import java.io.BufferedReader;

import java.io.BufferedWriter;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.InputStreamReader;

import java.io.OutputStreamWriter;

public class Test15

{

public static void main(String[]args)throwsException

{

//常见的键盘输入

BufferedReaderbr=newBufferedReader(new InputStreamReader(System.in));

BufferedWriter bw=newBufferedWriter(new OutputStreamWriter(newFileOutputStream("d.txt"),"UTF-8"));

Stringline=null;

while((line=br.readLine())!=null)

{

if("over".equals(line))

break;

bw.write(line);

bw.newLine();

bw.flush();

}

bw.close();

}

package day19;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.PrintStream;

import java.util.Date;

//将异常信息保存到文件

public class Test16

{

public static voidmain(String[]args) throws Exception

{

try

{

int[] arr=newint[2];

System.out.println(arr[3]);

} catch (Exceptione)

{

//e.printStackTrace(newPrintStream("error.txt"));

PrintStreamps=new PrintStream("errorlog.txt");

ps.println(newDate().toString());

System.setOut(ps);

e.printStackTrace(System.out);

}