JAVASE学习笔记第19天

IO流（BufferWriter）

字符流的缓冲区：

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

l  对应的类：

²  BufferWriter

²  BufferReader

l  缓冲区要结合流才能使用（也就是说在创建缓冲区之间必须有流对象）

l  在流的基础上对流的功能进行了增强

例子：

import java.io.*;

 

class Demo1

{

       publicstatic void main(String[] args)throws IOException

       {

              //创建一个写入流对象

              FileWriterfw = new FileWriter("lili.txt");

 

              //创建一个缓冲区

              //缓冲区的引入就是为了提高效率，

              //创建缓冲区只需要将流对象作为参数传递给缓冲区的构造函数即可

              BufferedWriterbw = new BufferedWriter(fw);

 

              bw.write("aaaa");

              bw.newLine();

              bw.write("lilililii");

              bw.newLine();//在缓冲区中有特点的方法，用来换行。

             

              //记住只要有缓冲区就要刷新

              bw.flush();

              //其实缓冲区关闭的是传进来的流

              bw.close();

       }

}

IO流（BufferReader）

1、字符读取流缓冲区：

该缓冲区提供了一个一次读一行的方法readLine，方便对文本的读取，当读到文本的末尾的时候，返回的是null

 

2、例子：

importjava.io.*;

 

class Demo2

{

public static void main(String[] args)throwsIOException

{

        //创建一个字符读取流对象

       FileReaderfr = new FileReader("lili.txt");

 

        //创建一个读取缓冲区对象

        //其实就是将读取流对象作为参数传递给读取缓冲区对象

        BufferedReader br = newBufferedReader(fr);

       

        for(String s=null;(s=br.readLine())!=null;)

        {

               System.out.println(br.readLine());//读取一行

        }

 

        br.close();

}

}

 

IO流（通过缓冲区复制文本文件）

/**

需求：

将一个Java文件中的内容复制到另外一个文件中

注意：readLine中读取的内容不包括换行符。

*/

import java.io.*;

 

class CopyByBuf

{

       publicstatic void main(String[] args)

       {

              //定义引用

              BufferedReaderbuffr = null;

              BufferedWriterbuffw=null;

 

              try

              {

                     //创建对象

                     buffr= new BufferedReader(new FileReader("Demo1.java"));

                     buffw= new BufferedWriter(new FileWriter("Demo1_copy.txt"));

 

                     Stringlen =null;

                     while((len=buffr.readLine())!=null)

                     {

                            buffw.write(len);

                            buffw.newLine();  //要自己手动换行

                            buffw.flush();

                     }

              }

 

              catch(IOException e)

              {

                     thrownew RuntimeException("读写失败");

              }

              finally

              {

                     try

                     {

                            if(buffr!=null)

                            {

                                   buffr.close();

                            }

                     }

                     catch(IOException e)

                     {

                            thrownew RuntimeException("读取失败");

                     }

 

                     try

                     {

                            if(buffw!=null)

                            {

                                   buffw.close();

                            }

                     }

                     catch(IOException e)

                     {

                            thrownew RuntimeException("写入失败");

                     }

              }

       }

}

IO流（MyBufferedReader）

/**

需求：自己定义一个类，类中包含一个功能和readLine一致的方法

*/

import java.io.*;

 

//定义自己的读取缓冲区

class MyBufferedReader

{

       privateFileReader fr;

 

       MyBufferedReader(FileReaderfr)

       {

              this.fr=fr;

       }

 

       //定义自己的readLine方法

       publicString myreadLine()throws IOException

       {

              //定义一个数组

              StringBuildersb = new StringBuilder();

 

              intlen=0;

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

              {

                     if(len=='\r')

                            continue;

                     if(len=='\n')

                            returnsb.toString();

                     //else

                            sb.append((char)len);

              }

              //注意这个哦

              if(sb.length()!=0)

                     returnsb.toString();

 

              returnnull;

       }

 

       publicvoid myclose()throws IOException

       {

              fr.close();

       }

}

 

class Demo3

{

       publicstatic void main(String[] args)throws IOException

       {            

                     FileReaderfr = new FileReader("lili.txt");

 

                     MyBufferedReadermbr =new MyBufferedReader(fr);

 

                     Stringlen = null;

                     while((len=mbr.myreadLine())!=null)

                     {

                            System.out.println(len);

                     }

                     mbr.myclose();

       }            

}

 

IO流（装饰设计模式）

/**

装饰设计模式：

当想要对已经有的对象进行功能增强的时候，

可以定义类，激昂已经有的对象导入，基于已经有的功能，提出加强的功能

那么自定义的该类成为装饰类。

 

装饰类通常会通过构造方法接受装饰对象。

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

 

装饰类和继承的区别

装饰设计比继承要灵活，避免了继承体系的臃肿，而且降低了类与类之间的关系

装饰类的好处还在于它无需改动原来的代码。

 

继承类的体系：

Reader

       |---TextReader

              |----TextBufferedReader

       |---MediaReader

              |----MediaBufferedReader

 

装饰类

Reader

       |--TextReader

       |--MediaReader

       |--BufferedReader

 

注意：

装饰类因为增强已有对象，所以具备的功能和已有对象的相同，

只不过提供了更强的功能。所以装饰类和被装饰类通常都属于一个体系中

 

*/

//原来的类

class Person

{

       publicvoid chifan()

       {

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

       }

}

 

//装饰类

class SueprPerson

{

       //将对象传进来

       privatePerson p ;

       SueprPerson(Personp)

       {

              this.p=p;

       }

 

       publicvoid chifan()

       {

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

              p.chifan();

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

       }

}

 

//调用类

class Demo4

{

       publicstatic void main(String[] args)

       {

              Personp =new Person();

              //以前的使用方法

              //p.chifan();

              //装饰之后

              SueprPersonsp = new SueprPerson(p);

              sp.chifan();

       }

}

IO流（LineNumberReader）

/**

LineNumberReader:

也是一个装饰类。

跟踪行号的字符缓冲流。

*/

import java.io.*;

 

class Demo5

{

       publicstatic void main(String[] args)throws IOException

       {

             

              FileReaderfr = new FileReader("Demo1.java");

 

              LineNumberReaderlnr = new LineNumberReader(fr);

             

              //设置行号

              lnr.setLineNumber(100);

              for(Stringlen=null;(len=lnr.readLine())!=null;)

              {

                     System.out.println(lnr.getLineNumber()+"   "+len); //带行号打印

              }

       }

}

 

IO流（MyLineNumberReader）

 

 

 

 

 

 

/**

需求：模拟一个LineNumberReader

*/

import java.io.*;

 

//模拟一个BufferedReader装饰类

 

class myBufferedReader extends Reader //继承Reader,说明它也是Reader体系中的一员

{

       privateReader r; //定义Reader的对象，可以接收一组Reader的类中的对象了

       myBufferedReader(Readerr) //装饰类的特点，使用构造函数将被装饰类的传递进来

       {

              this.r= r;            

       }

 

       //模拟reaLine方法

       //其实关于读取的方法在底层都是调用了read方法

       /*readLine的工作原理就是

        1。创建一个容器，用来存贮读出来的字符，（在BufferedReader中这个容器是个字符数组）

        2。遍历文件中的字符

        3。在遍历的过程中，如果读到'\r',进入下一循环;如果读到'\n'，从容器中把一行的内容输出；否则，就向容器里存入读到的字符。

        4。因为在整个文件的末尾，有可能不存在\r\n，所以会导致少输出一行，这时就在遍历完之后，在文件的末尾再判断一下，

                如果文件的长度！=0，则再输出容器中的内容。

       */

       publicString myReadLine()throws IOException //这里一般不抛

       {

              //创建一个容器

              StringBuildersb = new StringBuilder();

              //遍历文件

              intch =0;

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

              {

                     if(ch=='\r')

                            continue;

                     if(ch=='\n')

                            returnsb.toString();

                     else

                            sb.append((char)ch);//转换为字符

              }

              if(sb.length()!=0)

                     returnsb.toString();

              returnnull;

       }

 

       //覆盖Reader 类中的抽象方法

       publicint read(char[] cbuf,int off,int len) throws IOException

       {

              returnr.read(cbuf,off,len) ;

       }

 

       publicvoid close()throws IOException

       {

              r.close();

       }

}

 

//--------------------------------------------------------------------------------------------------------------

//模拟一个LineNumberReader方法

 

class MyLineNumberReader extendsmyBufferedReader  //继承MyBufferedReader

{

       privateint lineNumber;

 

       MyLineNumberReader(Readerr)

       {

              super(r);

       }

 

       publicvoid setLineNumber(int lineNumber)

       {

              this.lineNumber=lineNumber;

       }

       publicint getLineNumber()

       {

              returnlineNumber;

       }

 

       publicString myReadLine()throws IOException

       {

              lineNumber++;  //每次调用myReadLine的时候，行号加1

              returnsuper.myReadLine();    

       }     

}

 

//-----------------------------------------------------------

//调用者

class Demo6

{

       publicstatic void main(String[] args)throws IOException

       {

              FileReaderfr = new FileReader("Demo1.java");

             

              myBufferedReadermbr = new myBufferedReader(fr);

              MyLineNumberReadermbr1 = new MyLineNumberReader(fr);

 

              Stringlen =null;

 

              while((len=mbr1.myReadLine())!=null)

              {

                     System.out.println(mbr1.getLineNumber()+"cc"+len);

              }

 

              mbr1.close();      

       }

}

IO流（字节流File读写操作）

/**

字符流：

FileReader

FileWriter

 

BufferedReader

BufferedWriter

 

字节流：

InputStream OutputStream

需求：想要操作图片数据，这是就要用到字节流

*/

import java.io.*;

 

class Demo7

{

       publicstatic void main(String[] args)throws IOException

       {

              readFile_3();

       }

 

       //写

       publicstatic void writeFile()throws IOException

       {

              //创建对象

              FileOutputStreamfos = new FileOutputStream("fos.txt");

 

              //写入

              fos.write("adddd".getBytes());//将字符串装换外字节：getBytes(); 将字符串转换为字符toCharArray()

             

              //关闭资源  ，字节的不用刷新哦

              fos.close();

       }

 

       //一个一个的读

       publicstatic void readFile_1()throws IOException

       {

              FileInputStreamfis = new FileInputStream("fos.txt");

             

              intch=0;

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

              {

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

              }

       }

 

       //读取一组

       publicstatic void readFile_2()throws IOException

       {

              FileInputStreamfis = new FileInputStream("fos.txt");

 

              //定义一个容器

              byte[]buf = new byte[1024];

 

              intlen=0;

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

              {

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

              }

 

              fis.close();

       }

 

       //特有的方法：int avaliable() 返回的是文件中的字节数，包括回车符

       publicstatic void readFile_3()throws IOException

       {

              FileInputStreamfis = new FileInputStream("fos.txt");

              //定义一个容器

              intnum=fis.available();

              byte[]buf = new byte[num]; //应用，但是不建议用这种方法，有可能内存崩溃

 

              intlen=0;

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

              {

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

              }

 

              fis.close();           

       }

}

IO流（拷贝图片）

 

/**

需求：拷贝图片

思路：

1，创建一个字节流读取对象，与图片相关联

2，创建一个字节写入流对象，用于存储读取到的数据

3，通过读取操作读取数据

4，关闭资源

 

注意：以后看一个图片的时候，首相要看一下图片的属性，查看大小

*/

import java.io.*;

 

class Demo8

{

       publicstatic void main(String[] args)

       {

              //定义引用

              FileOutputStreamfos = null;

              FileInputStreamfis = null;

              try

              {

                     //创建对象并相关联

                     fos=newFileOutputStream("F:\\2.jpg");

                     fis=new FileInputStream("F:\\我.jpg");

 

                     intlen=0;

                     byte[]buf = new byte[1024];

 

                     while((len=fis.read(buf))!=-1)  //记住read方法

                     {

                                   fos.write(buf,0,len);  //记住write方法。

                     }

              }

              catch(IOException e)

              {

                     thrownew RuntimeException("图片读写失败");

              }

              finally

              {

                     try

                     {

                            if(fis!=null)

                                   fis.close();

                     }

                     catch(IOException e)

                     {

                            thrownew RuntimeException("图片读取失败");

                     }

                     try

                     {

                            if(fos!=null)

                                   fos.close();

                     }

                     catch(IOException e)

                     {

                            thrownew RuntimeException("图片写入失败");

                     }

              }

       }

}

 

 

 

 

 

IO流（字节流的缓冲区）

 

/**

字节流的缓冲区:

BufferedInputStream

BufferedOutputStream

*/

import java.io.*;

 

class Demo9

{

       publicstatic void main(String[] args)

       {

              copyMp3();

       }

 

       publicstatic void copyMp3()

       {

              //创建引用

              FileInputStreamfis=null;a

              FileOutputStreamfos =null;

              BufferedInputStreambufi=null;

              BufferedOutputStreambufo=null;

              try

              {

                     //创建对象

                     fis=new FileInputStream("F:\\1.mp3"); //读

                     fos=new FileOutputStream("F:\\2.mp3"); //写

 

                     bufo= new BufferedOutputStream(fos);  //写

                     bufi= new BufferedInputStream(fis);  //读

                    

                     //读写

                     for(intlen=0;(len=bufi.read())!=-1;)

                     {

                            bufo.write(len);

                     }

              }

              catch(IOException e)

              {

                     thrownew RuntimeException("读写失败");

              }

              finally

              {

                     try

                     {

                            if(bufo!=null)                    

                                   bufo.close();

                     }

                     catch(IOException e)

                     {

                            thrownew RuntimeException("写入文件失败");

                     }

                     try

                     {

                            if(bufi!=null)              

                                   bufi.close();

                     }

                     catch(IOException e)

                     {

                            thrownew RuntimeException("读取文件失败");

                     }

              }

       }

}

 

 

注意：out是写，in :读

 

IO流（自定义字节流的缓冲区）

真的不容易啊！！！！！！！
/**

自定义：BufferedInputStream

原理：

1，调用FileInputStream的read方法，从文件中抓取一部分数据，然后存放到自定义的字节数组中

2，使用BufferedInputStream的read方法读取数据

3，第一次抓取的数据读完了之后，再次从文件中抓取数据，放入到自定义数组中，重复2

步骤

1，自定义数组，指针、计数器

2，当count==0的时候，抓数据 ，如果count<0(也就是文件中没有数据，返回-1)

3，当count>0的时候，读取数据

*/

 

import java.io.*;

 

//自定义BufferedInputStream类，是一个装饰类

class MyBufferedInputStream

{

       //被装饰的类

       FileInputStreamfis;

       MyBufferedInputStream(FileInputStreamfis)

       {

              this.fis=fis;

       }

 

       //数组

       byte[]buf = new byte[1024];

 

       //指针、计数器

       intpos=0,count=0;

 

       //定义myRead方法,一次读取一个字节

       publicint myRead()throws IOException

       {

              //抓取数据

              if(count==0)

              {

                     count=fis.read(buf);

                     if(count<0)

                            return-1;

                     pos=0;

                     byteb =buf[pos];                                   

                     count--;

                     pos++;

                     returnb&255;  //因为byte会被向上提升，防止出现-1的情况，这样只取后8位

              }

              elseif(count>0)

              {

                     byteb =buf[pos];                                   

                     count--;

                     pos++;

                     returnb&255;                

              }

              return-1;  //这个无所谓

       }

 

       publicvoid myclose()throws IOException

       {

              fis.close();

       }

}

//-----------------------------------------------------------------

class Test1

{

       publicstatic void main(String[] args)throws IOException

       {

              copyMp3();

       }

 

       publicstatic void copyMp3()throws IOException

       {

              //创建引用

              FileInputStreamfis=null;

              FileOutputStreamfos =null;

              MyBufferedInputStreambufi=null;

              BufferedOutputStreambufo=null;

              try

              {

                     //创建对象

                     fis=new FileInputStream("F:\\1.mp3"); //读

                     fos=new FileOutputStream("F:\\3.mp3"); //写

 

                     bufo= new BufferedOutputStream(fos);  //写

                     bufi= new MyBufferedInputStream(fis);  //读

                    

                     //读写

                     for(intlen=0;(len=bufi.myRead())!=-1;)

                     {

                            bufo.write(len);

                     }

              }

              catch(IOException e)

              {

                     thrownew RuntimeException("读写失败");

              }

              finally

              {

                     try

                     {

                            if(bufo!=null)                    

                                   bufo.close();

                     }

                     catch(IOException e)

                     {

                            thrownew RuntimeException("写入文件失败");

                     }

                     try

                     {

                            if(bufi!=null)              

                                   bufi.myclose();

                     }

                     catch(IOException e)

                     {

                            thrownew RuntimeException("读取文件失败");

                     }

              }

       }

}

IO流（读取键盘录入）

/**

字符流：

FileWriter

FileReader

 

BufferedWriter

BufferedReader

 

字节流：

FileInputStream

FileOutputStream

 

BufferedInputStream

BufferedOutputStream

 

在System类中

System.in: 标准的输入，对应的设备是：键盘

System.out：标准的输出，对应的设备是:控制台

 

对于System.in的描述：public static final InputStream in

我们知道他的类型是InputStream

*/

 

/**

需求：

通过键盘录入数据。

当录入一行数据之后，就将该行数据进行打印。

如果录入的数据是over，那么就停止录入。

 

思路：

1，定义一个InputStream对象来接收键盘录入的数据

2，定义一个缓冲区，用来存放每次录入的数据

3，循环录入数据

4，在循环的过程中进行判断

       如果ch=='\r' ,进入到下一次的循环；

       如果ch=='\n'，如果遇到"over",停止录入；否则，打印。//????

 

 

 

import java.io.*;

 

class Test2

{

       publicstatic void main(String[] args)throws IOException

       {

              //定义对象

              InputStreamin = System.in;

              StringBuildersb = new StringBuilder();

 

              while(true)

              {

                     intch =in.read();

 

                     if(ch=='\r')

                            continue;

                     if(ch=='\n')

                     {

                            Stringstr = sb.toString();

                            if(str.equals("over"))

                                   break;

                            System.out.println(str);

                            sb.delete(0,sb.length());//清空

                     }     

                     else

                            sb.append((char)ch);

              }

       }

}

*/

IO流（读取转换流）

/**

上面的代码过于复杂

录入一行数据，这让我们想到了Reader类中的readLine()方法

但是键盘录入对象是一个InputStream对象，我们发现Reader

有一个子类叫做InputStreamReader可以将InputStream对象

抓换为Reader对象

*/

import java.io.*;

 

class Test2

{

       publicstatic void main(String[] args)throws IOException

       {

              //创建键盘录入对象

              InputStreamin = System.in;

             

              //将字节流对象转换为字符流对象

              InputStreamReaderisr =new InputStreamReader(in);

 

              //为了提高效率，使用BufferedReader方法

              BufferedReaderbr = new BufferedReader(isr);

 

              Stringlen=null;

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

              {

                     if(len.equals("over"))

                            break;

                     System.out.println(len);

              }

 

              br.close();

       }

}

 

 

 

 

 

IO流（写入转换流）

/**

将字符流转换为字节流的方法：

OutputStreamWriter类

 

使用上述内容，将System.out.println替换。

*/

import java.io.*;

 

class Test3

{

       publicstatic void main(String[] args)throws IOException

       {

              //创建键盘录入对象

              InputStreamin = System.in;

             

              //将字节流对象转换为字符流对象

              InputStreamReaderisr =new InputStreamReader(in);

 

              //为了提高效率，使用BufferedReader方法

              BufferedReaderbr = new BufferedReader(isr);

 

              BufferedReaderbufr =

                     new BufferedReader(newInputStreamReader(System.in)); //这句话必须记住！！！！！！！！！！！！！

                                                                     

//------------------------------------------------------------------------------------------

              //创建键盘输出对象那

              OutputStreamout = System.out;

 

              //将字节流转换为字符流

              OutputStreamWriterosw = new OutputStreamWriter(out);

 

              //使用BufferedWriter方法,从而使用换行

              BufferedWriterbw = new BufferedWriter(osw);

 

              BufferedWriterbufw =

                     newBufferedWriter(new OutputStreamWriter(System.out));

//--------------------------------------------------------------

              Stringlen=null;

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

              {

                     if(len.equals("over"))

                            break;

                     bw.write(len);

                     bw.newLine();

                     bw.flush();//写的不要忘记刷新

              }

 

              br.close();

       }

}

IO流（流操作的规律）（重点）

/**

关于流操作的处理：

 

1，需求：

源：键盘

目的：控制台

 

2,需求:想把键盘录入的数据存储到一个文件中

源：键盘

目的：文件

 

3,需求：想要将一个文件的数据打印在控制台上

源：文件

目的：控制台

 

//----------------------------------------------------------------------------------

综上可以总结出：

流对象的操作规律:

 

1，明确源和目的

       源：输入流，InputStream 、Reader

       目的：输出流：OutputStream 、Writer

 

2，是否为纯文本文件

        是：字符流 ,Reader、Writer

        不是：字节流，InputStream，OutputStream

 

3，经过以上两步，体系已经明确了，接下来通过具体的设备来区分具体使用什么对象

       源：内存、硬盘、键盘

       目的：内存、硬盘、控制台

 

4，经过以上三步，确定了对象之后，接下来，接下来考虑是否需要提高效率

       是：用缓冲器

       不是：不用缓冲器

 

//----------------------------------------------------------------------------

 

练习：将一个文本文件中的数据存储到另外一个文本文件中，复制文件

思路：

1，明确源和目的：

       源：输入流：InputStream、 Reader

              是否为纯文本文件？

                     是：Reader

              具体的设备？

                     硬盘：FileReader

              是否需要提高效率？

                     需要：创建Reader体系中的缓冲器对象

             

       BufferedReaderbufr =

              newBufferedReader(new FileReader("a.txt"));

 

       目的：输出流：OutputStream 、Writer

              是否为纯文本文件？

                     是：Writer

              具体的设备？

                     硬盘：FileWriter

              是否需要提高效率？

                     需要：创建Writer体系中的缓冲器

             

              BufferedWriterbw =

                     newBufferedWriter(new FileWriter("b.txt"));

 

//----------------------------------------------------------------------------

 

练习：将一个字节文件中的数据存储到另外一个字节文件中，复制文件

思路：

       1，明确源和目的？

              源：输入流，InputStream、Reader

                     是否为纯文本文件？

                            不是：InputStream

                     具体的设备？

                            硬盘：FileInputStream

                     是否提高效率？

                            是：创建InputStream体系中的缓冲器

 

              BufferedInputStreambufis =

                     new BufferedInputStream(newFileInputStream("a.jpg"));

 

 

              目的：输出流，OutputStream、Writer

                     是否为纯文本文件？

                            不是：OutputStrream

                     具体的设备？

                            硬盘：FileOutputStream

                     是否提高效率？

                            是：创建OutputStream体系中的缓冲器

                    

          BufferedOutputStream bufos =

                     newBufferedOutputStream(new FileOutputStream("b.txt"))；                 

 

//--------------------------------------------------------------------------------------------------------

FileReader和FileWriter中的编码格式为默认的格式，都是GBK

转换流什么时候使用呢？

       字符和字节之间转换的桥梁，通常，涉及到字符编码的时候，

       会用到转换流。

 

需求：将键盘录入的数据保存到一个文件中

       1，明确源和目的

              源：输入流，InputStream ,Reader

                     是否为纯文本文件？

                            是：Reader

                     具体设备？

                            键盘：

                                   分析：键盘录入对应的具体的对象是System.in

                                                   但是System.in对应的是InputStream

                                                   这就导致和我们的原来的体系不同了，

                                                   所以使用Reader体系中的InputStreamReader

                                                   将字节流转换为字符流

                                                   new InputStreamReader(System.in);

 

                     是否提高效率？

                            是：使用Reader体系中的BufferedReader

 

              BufferedReaderbufr =

                     newBufferedReader(new InputStreamReader(System.in));

 

              目的：输出流，OutputStream ,Writer

                     是否为纯文本呢？

                            是：Writer

                     具体的设备？

                            硬盘：FileWriter

                     是否提高效率？

                            是：创建Writer体系中的缓冲器

                    

                     BufferedWriterbufw =

                            newBufferedWriter(new FileWriter("a.txt"));

 

***********************************************************

       拓展:在以上的基础上，想要把指定的数据按照指定的编码表

       （UNF-8）,存储到文件中。

 

       FileWriter中的编码是GBK,用到了编码转换，想到了转换流

       OutputStreamWriter,而该转换流的对象是一个字符流的对象，

       由于我们的目的是纯文本，而且设备是硬盘，所以选择:FileWriter,

       OutputStreamWriteroutw =

              newOutputStreamWriter(new FileWriter("a.txt"),"UNF-8");

      

       为了提高效率：

              BufferedWriterbufw =

                     newBufferedWriter(new OutputStreamWriter(newFileWriter("a.txt"),"UNF-8")); 

 

*/

 

import java.io.*;

 

class Test4

{

       publicstatic void main(String[] args)throws IOException

      

              //1，键盘录入

              //BufferedReaderbufr=

                     //newBufferedReader(new InputStreamReader(System.in));

 

              //3，文件的录入

              BufferedReaderbufr=

                     newBufferedReader(new InputStreamReader(newFileInputStream("Test1.java")));

             

              //1，键盘输出

              BufferedWriterbufw=

                     newBufferedWriter(new OutputStreamWriter(System.out));

 

              //2，文件输出

              //BufferedWriterbufw=

                     //newBufferedWriter(new OutputStreamWriter(new FileOutputStream("out.txt")));

 

              //读取一行的操作

              Stringline=null;

             

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

              {

                     if(line.equals("over"))  //加入结束标志，这样就不需要用到ctrl+c结束了

                            break;

 

                     bufw.write(line);  //读取一行

                     bufw.newLine();//读完一行空格

                     bufw.flush();  //关于写的得刷新，才能将流中的内容写入出来

              }

 

              //关闭

              bufr.close();

              bufw.close();//这句话也可以省略，因为控制台结束，我们使用了over做判断

       }

}

IO流（改变标准输入输出设备）

 

import java.io.*;

 

class Test5

{

       publicstatic void main(String[] args)throws IOException

       {

              //改变键盘录入

              //System.setIn(newFileInputStream("Test1.java"));

 

              //改变输出设备

              System.setOut(newPrintStream("haha.txt"));

 

              //键盘录入

              BufferedReaderbufr =

                     newBufferedReader(new InputStreamReader(System.in));

 

              //键盘输出

              BufferedWriterbufw =

                     newBufferedWriter(new OutputStreamWriter(System.out));

 

              //读取

              String line = null;

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

              {

                     if(line.equals("over"))

                            break;

                     bufw.write(line);

                     bufw.newLine();

                     bufw.flush();

              }

 

              bufr.close();

       }

}

IO流（异常日志信息）（专门的东西是     log4j）

/**

异常日志信息文件的创建

*/

import java.io.*;

import java.util.*;

import java.text.*;

 

class Test6

{

       publicstatic void main(String[] args)

       {

              try

              {

                     int[]arr =new int[2];

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

              }

              catch(Exception e)

              {

                     try

                     {

                            //时间

                            Datedate =new Date();

                            SimpleDateFormatsdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

                            Stringstr=sdf.format(date);

 

                            //指定输出设备

                            PrintStreamps = new PrintStream("zz.log");

                            ps.println(str);

                            System.setOut(ps);

 

                            //e.printStackTrace(); 

                     //这句话其实底层调用的printStackTrace(PrintStream s)方法，将System.out作为对象传递过来了                            

                     }

                     catch(IOException ex)

                     {

                            thrownew RuntimeException("异常日志创建失败");

                     }            

              }

       }

}