Java基础 IO流——第二部分

 

新博客地址：Temi

第一讲，IO流(BufferedWriter)

一，字符流的缓冲区概述：

1. 缓冲区的出现提高了对数据的读写效率。
2. 对应类：BufferedWriter，BuuferedReader。（存在于java.io包中）
3. 缓冲区要结合流才可以使用。       ====缓冲区是为了提高流的操作效率出现的，所以在创建缓冲区之前必须要现有流对象====
4. 在流的基础上对流的功能进行了增强。

                      ========缓冲技术原理：BufferedWriter,BufferedReader对象里面封装了数组==========

二，缓冲区操作类的简单了解：

                    BufferedWriter  类：

1. 1. 1. 1. 1. 类的定义： public class BufferedWriter  extends Writer    将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。
            2. 构造方法：public BufferedWriter (Writer out) 创建一个使用默认大小输出缓冲区的缓冲字符输出流。===注：此处必须指明Writer对象作为参数，原因见概述第三条==========
            3. 构造方法：public BufferedWriter(Writer out, int sz)    创建一个使用给定大小输出缓冲区的新缓冲字符输出流。
            4. 方法：public void newLine()  throws IOException     写入一个行分隔符。行分隔符字符串由系统属性 line.separator 定义，并且不一定是单个新行 (' ') 符。
            5. public void write(int c)  throws IOException    写入单个字符。===注：此方法被重载多次，可写入char数组和字符串====

                   BufferedReader 类：

1. 1. 1. 1. 1. 类的定义：public class BufferedReader  extends Reader    从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。
            2. 构造方法：public BufferedReader(Reader in)     创建一个使用默认大小输入缓冲区的缓冲字符输入流。==注：指明Reader对象==
            3. 构造方法：public BufferedReader(Reader in,int sz)   创建一个使用指定大小输入缓冲区的缓冲字符输入流。
            4. 方法： public int read() throws IOException   读取单个字符。返回值：作为一个整数（其范围从 0 到 65535 (0x00-0xffff)）读入的字符，如果已到达流末尾，则返回 -1
            5. 方法： public int read(char[] cbuf, int off,  int len)  throws IOException    将字符读入数组的某一部分。==注： 包括off下标==
            6. 方法： public String readLine() throws IOException     读取一个文本行。通过下列字符之一即可认为某行已终止：换行 (' ')、回车 (' ') 或回车后直接跟着换行。
            7. 方法： public long skip(long n) throws IOException   跳过字符。返回值：实际跳过的字符数量。

三，缓冲区写入操作步骤：

1. 创建一个字符写入流对象：    FileWriter fw=new FileWriter("buf.txt");
2. 创建缓冲区对象：         BufferedWriter bw=new BufferedWriter(fw);
3. 调用缓冲区对象方法写入数据：         bw.write("abcd");   ===注：此步骤执行后，文件若不存在会被创建，但是，数据并没有写入文件。=====
4. 刷新缓冲区：                          bw.flush()；                 ===注：用到缓冲区后一定要刷新===
5. 关闭缓冲区：                          bw.close();                  ===注：缓冲区只是提高操作效率，真正实现写操作的是FileWriter对象，所以缓冲区的关闭其实是关闭的是他所提高效率的流对象，即FileWriter 对象。===

四，代码练习：

/*
* 缓冲区对象使用联系。重点观察写入过程
*什么时候创建文件，以及将数据写入文件的时机
*/
import java.io.*;
import java.util.Scanner;


public class BufferedWriterDemo {
             public static void main(String args[]){
                 
                   //声明实际写文件对象引用
                   FileWriter fw=null;
                   
                   //声明缓冲区对象引用
                   BufferedWriter bw=null;
                   
                   //表示文件字符串
                   String fileName="E:/buf.txt";
                   
                   //异常处理
                   try{
                       
                       //实例化对象引用
                       fw=new FileWriter(fileName);
                       
                       bw=new BufferedWriter(fw);
                       
                       
                       //调用缓冲对象方法写入数据此时并没有写进文件中，但是文件已经创建。若文件存在由于不是追加写方式，源文件内容清空
                       bw.write("abcd");
                       
                       //写入文件换行符，此方法跨平台
                       bw.newLine();
                       
                       //写入第二行
                       bw.write("第二行");
                       
                       //此处停顿，按任意键继续，此时可观察文件变化
                       System.out.println("刷新流之前：");
                       System.out.println("按任意键继续:");
                       
                       
                       //用户输入任意字符后继续；
                       new Scanner(System.in).next();
                       
                       //刷新缓冲流，将字符写入文件。
                       bw.flush();
                       
                       //此后观察文件发现数据已经写入
                       System.out.println("刷新流之后：");
                       
                        
                   }catch(IOException e){
                        System.out.println("写入操作发生错误！");
                   }finally{
                       try{
                           if(bw!=null)
                               bw.close();
                       }catch(IOException e){
                           System.out.println("关闭文件发生错误！");
                       }
                     
                           
                   }
             }
}

第二讲：IO流(BufferedReader)

 一，BufferedReader类的了解：见第一讲

二，缓冲区读入步骤：

1. 创建一个读取流对象和文件相关联。     FileReader fr=new FileReader("buf.txt");
2. 创建缓冲读取对象，提高读取操作效率。BufferedReader br=new BufferedReader(fr);
3. 使用缓冲区对象方法读取数据：            br.readLine();   ==注：readLine() 方法对于读取文本文件特别方便。特别注意：如果已到达流末尾，则返回 null 而不是 -1 ，此方法返回的字符串中不包括换行符==
4. 关闭缓冲区。

三，代码练习：

import java.io.*;


public class BufferedReaderDemo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
           
           //创建对象引用
           FileReader fr=null;
           BufferedReader br=null;
           
           //文件字符串
           String fileName="E:/buf.txt";
           
           
           //异常处理
           try{
               fr=new FileReader(fileName);
               
               br=new BufferedReader(fr);
               
               //创建字符串，保存读取内容
               String readLine=null;
               
               //循环读取文件内容，注意此处的判断条件是 null  而不是   -1
               while((readLine=br.readLine())!=null){
                   System.out.println(readLine);
               }
               
               
               //处理异常，给出提示
           }catch(FileNotFoundException e){
               System.out.println("文件没有找到！"+e.toString());
           }catch(IOException e){
               System.out.println("文件读取发生错误"+e.toString());
           }finally{
               try{
                   if(br!=null)
                       br.close();
               }catch(IOException e){
                   System.out.println("文件关闭失败："+e.toString());
               }
           }
    }

}

第三讲：IO流(通过缓冲区复制文本文件)

一，练习：通过缓冲区复制一个 .java文件

             注意事项：

1. 1. 1. readLine() 方法返回的字符串中不包括换行符，所以再写入新的文件时应该加上，使用BudderedWriter.newLine()方法。
      2. 每次循环写入都必须刷新。

二，代码练习：

import java.io.*;


public class CopyFile {
             public static void main(String args[]){
                     
                     //创建对象引用
                     BufferedReader br=null;
                     
                     BufferedWriter bw=null;
                     

                    //源文件字符串表示
                     String srcFileName="E:/test.java";
                     

                     //目标文件字符串表示
                     String destFileName="E:/dest.java";
  
                     //判断是否是.java文件
                     if(!srcFileName.endsWith(".java")){
                         System.out.println("文件后缀名不是 .java");
                         
                         //如果不是.java文件返回
                         return;
                     }
                     


                     //异常处理
                     try{


                         //使用匿名对象实例化缓冲区对象br 
                         br=new BufferedReader(new FileReader(srcFileName));
                         
                         bw=new BufferedWriter(new FileWriter(destFileName));
                         
                         //接受读入的字符串
                         String readLine=null;
                         

                         //循环读取
                         while((readLine=br.readLine())!=null){

                                 //读取一行，写入一行
                             bw.write(readLine);

                                 //由于readLine() 方法没有返回换行符，此处应当换行
                             bw.newLine();

                                 //刷新缓冲区，将数据写入文件
                             bw.flush();
                         }

                         //成功提示
                         System.out.println("文件拷贝完毕!");

                      //异常处理以及提示
                     }catch(FileNotFoundException e){
                         System.out.println("源文件没有找到,或者目标文件不存在"+e.toString());
                     }catch(IOException e){
                         System.out.println("文件拷贝失败"+e.toString());
                     }
             }
}

 第四讲：IO流(readLine的原理图例)

原理概括，readLine 方法最终操作其实也是一个一个的读取数据，只不过它把读取到的数据存进了自己的缓冲区中，当遇到换行符时，结束读取，并一次性返回所有数据。如图：

 

第五讲：IO流(MyBufferedReader)

 自定义readLine方法代码：

import java.io.*;

class MyBufferedReader {

          //定义对象引用，并进行封装，使用构造函数实例化
      private FileReader reader;
      

         //定义缓冲区，缓冲读入的字符
      private char[] str;
      
     
          //构造方法，传入一个FileReader对象进行文件读操作，使用默认缓冲区
      public MyBufferedReader(FileReader reader){
          this.reader=reader;
          this.str=new char[1024];
      }
      

         //使用自定义的缓冲区大小
      public MyBufferedReader(Reader Filereader,int size){
          this.reader=reader;
          this.str=new char[size];
      }
      
      

          //自定义函数进行缓冲的高效读写。此处异常交由调用者处理。
      public String myReadLine() throws IOException{
                    
                     //保存读取的单个字符；
             int ch=0;
                     
                     //记录读取的总字符数量
             int num=0;

                     //循环读取内容
             while((ch=this.reader.read()) != -1){
                   

                           //如果字符为 '
' 则跳过继续下一轮循环
                   if(ch == '
')
                       continue;

                           //如果字符为 '
' 则结束循环，返回读取的内容
                   else if(ch == '
')
                       return new String(str,0,num);

                          //如果超出缓冲区大小，则结束循环，返回读取内容
                          else if(num>=size)
                       return new String(str,0,num);
                   else{

                                   //将读取的字符保存在字符数组中，下标加一
                       str[num]=(char)ch;
                       num++;
                   }
             }

                     //判断最后一行数据是否存在
             if(num!=0)
             return new String(str,0,num);
             else return null;
      }
      
      
          //关闭流，实为关闭内部流对象。此处异常抛出。
      public void myClose() throws IOException{
          this.reader.close();
      }
}



public class MyBufferedReaderDemo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        MyBufferedReader mbr=null;
        
        String fileName="E:/testmybuf.txt";
        
        try{
            mbr=new MyBufferedReader(new FileReader(fileName));
            
            String readLine;

               //循环读取
            while((readLine=mbr.myReadLine())!=null){
                System.out.println(readLine);
            }
            System.out.println("读取完毕!");
            
        }catch(IOException e){
            System.out.println("读取文件错误"+e.toString());
        }finally{
            try{
                if(mbr!=null){
                    mbr.myClose();
                }
            }catch(IOException e){
                System.out.println("文件关闭时发生错误！"+e.toString());
            }
        }
    }

}

第六讲、第七讲、第八讲：装饰设计模式、装饰和继承的区别、自定义装饰类

一，装饰设计模式简介：

1.  装饰模式(Decorator)的定义：当想对已有对象进行功能增强时，可定义一个类，这个类将已有对象传入，基于已有对象的功能，并提供加强功能，那么自定义的该类称之为装饰类。又名包装(Wrapper)模式，装饰模式以对客户端透明的方式扩展对象的功能，是继承关系的一个替代方案。
2. 装饰模式的特点：
1. 1. 1. 1. 装饰类通常都会通过构造方法接收被装饰的对象，并基于被装饰的对象的功能，提供更强的功能。
         2. 装饰对象包含一个真实对象的引用(reference).
         3. 通常装饰类，与被装饰类实现同一个接口。即属于同一个接口或者类。
   2. 装饰设计模式和继承的区别：
      1. 1. 装饰模式比继承要灵活。避免了继承体系的臃肿，且降低了类与类之间的关系。装饰模式扩展的是对象的功能，不需要增加类的数量，而类继承扩展是类的功能，在继承的关系中，如果我们想增加一个对象的功能，我们只能通过继承关系，在子类中增加两个方法。
         2. 装饰模式是一种动态行为，可以对已经存在类进行随意组合，而类的继承是一种静态的行为，一个类定义成什么样的，该类的对象便具有什么样的功能，无法动态的改变。

 

 

二，代码练习（第五讲代码增强）：

 

import java.io.*;

class MyBufferedReader {

          //定义对象引用，并进行封装，使用构造函数实例化
      private FileReader reader;
      

         //定义缓冲区，缓冲读入的字符
      private char[] str;
      
     
          //构造方法，传入一个FileReader对象进行文件读操作，使用默认缓冲区
      public MyBufferedReader(FileReader reader){
          this.reader=reader;
          this.str=new char[1024];
      }
      

         //使用自定义的缓冲区大小
      public MyBufferedReader(Reader Filereader,int size){
          this.reader=reader;
          this.str=new char[size];
      }
      
      

          //自定义函数进行缓冲的高效读写。此处异常交由调用者处理。
      public String myReadLine() throws IOException{
                    
                     //保存读取的单个字符；
             int ch=0;
                     
                     //记录读取的总字符数量
             int num=0;

                     //循环读取内容
             while((ch=this.reader.read()) != -1){
                   

                           //如果字符为 '
' 则跳过继续下一轮循环
                   if(ch == '
')
                       continue;

                           //如果字符为 '
' 则结束循环，返回读取的内容
                   else if(ch == '
')
                       return new String(str,0,num);

                          //如果超出缓冲区大小，则结束循环，返回读取内容
                          else if(num>=size)
                       return new String(str,0,num);
                   else{

                                   //将读取的字符保存在字符数组中，下标加一
                       str[num]=(char)ch;
                       num++;
                   }
             }

                     //判断最后一行数据是否存在
             if(num!=0)
             return new String(str,0,num);
             else return null;
      }
      
      
          //关闭流，实为关闭内部流对象。此处异常抛出。
      public void myClose() throws IOException{
          this.reader.close();
      }



       //覆写父类中的抽象方法
        @Override
    public int read(char[] cbuf, int off, int len) throws IOException {

                //调用真是实现类实现具体操作
        return this.reader.read(cbuf, off, len);
    }


         //覆写父类中的抽象方法
    @Override
    public void close() throws IOException {
        this.reader.close();
        
    }
}



public class MyBufferedReaderDemo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        MyBufferedReader mbr=null;
        
        String fileName="E:/testmybuf.txt";
        
        try{
            mbr=new MyBufferedReader(new FileReader(fileName));
            
            String readLine;

               //循环读取
            while((readLine=mbr.myReadLine())!=null){
                System.out.println(readLine);
            }
            System.out.println("读取完毕!");
            
        }catch(IOException e){
            System.out.println("读取文件错误"+e.toString());
        }finally{
            try{
                if(mbr!=null){
                    mbr.myClose();
                }
            }catch(IOException e){
                System.out.println("文件关闭时发生错误！"+e.toString());
            }
        }
    }

}

第九讲、第十讲：IO流(LineNumberReader)、IO流(MyineNumberReader)

一，LineNumberReader类的了解：

1. 1. 1. 类的定义：public class LineNumberReader  extends BufferedReader     跟踪行号的缓冲字符输入流。此类定义了方法 setLineNumber(int)
         和 getLineNumber()，它们可分别用于设置和获取当前行号。==注：默认情况下，行编号从 0 开始。该行号随数据读取在每个行结束符处递增，可以通过调用 setLineNumber(int) 更改行号。setLineNumber(int) 不会实际更改流中的当前位置；它只更改将由 getLineNumber() 返回的值。===
      2. 方法：public int getLineNumber()     获得当前行号。
      3. 方法：public void setLineNumber(int lineNumber)    设置当前行号。

二，LineNumberReader类的原理：

                         在类的内部增加了一个行号计数器。

三，代码练习：

import java.io.*;
class  LineNumberReaderDemo
{
    public static void main(String[] args) 
    {
        LineNumberReader lnr=null;
        try
        {
             
            lnr=new LineNumberReader(new FileReader("LineNumberReaderDemo.java"));

                        //设置行号：此设置仅对 getLineNumber() 有效并不会影响源文件
            lnr.setLineNumber(100); 

                        //接受读取的字符串
            String line=null;

                        //循环读取
            while ((line=lnr.readLine())!=null ){
                                
                                //输出行号与内容
                System.out.println(lnr.getLineNumber()+":"+line); 
            }
        }

                //异常处理
        catch (IOException e)
        {
            throw new RuntimeException("读取数据失败");
        }
        finally
        {
            try
            {
                if(lnr!=null)
                    lnr.close();
            }
            catch (IOException e)
            {
                throw new RuntimeException("读取流关闭失败");
            }
        }    
    }
}

第十一讲，十二讲：IO流(字节流File读写操作)、IO流(拷贝图片)

一，字节流概述：

1. 1. 字节流除了可以操作文本文件外还可以操作其他文件，例如媒体文件。
   2. 字节流的顶层类： InputStream，OutputStream。
   3. 字节流的写入是直接写入文件的，所以不用进行刷新。==注：因为字节流操作的是字节，即数据的最小单位，不需要像字符流一样要进行转换为字节。所以可直接将字节数据写入到指定文件中。==

二，InputStream类的了解：

1. 1. 1. 构造方法：public abstract class InputStream  extends Object  implements Closeable   此抽象类是表示字节输入流的所有类的超类。
      2. 独特的方法：public int available() throws IOException   返回可以不受阻塞地从此输入流读取（或跳过）的估计字节数；如果到达输入流末尾，则返回 0。===注：可以利用此方法来指定读取方式中传入数组的长度，从而省去循环判断。但是如果文件较大，而虚拟机启动分配的默认内存一般为64M。当文件过大时，此数组长度所占内存空间就会溢出。所以，此方法慎用，当文件不大时，可以使用。===
      3. 直接已知子类：AudioInputStream, ByteArrayInputStream, FileInputStream, FilterInputStream, InputStream, ObjectInputStream, PipedInputStream, SequenceInputStream, StringBufferInputStream

三，拷贝图片步骤：

1. 1. 1. 用字节读取流对象和图片关联。
      2. 用字节流对象创建一个图片文件，存储获取到的图片数据。
      3. 通过循环读写，完成数据的存储。===注：此处不存在流的刷新====
      4. 关闭资源。

四，代码练习，拷贝图片：

        

import java.io.*;
public class  CopyImage{
    public static void main(String[] args){

                //创建对象引用
        FileInputStream fis=null;
        FileOutputStream fos=null;


        try{
            //实例化对象，与文件相关联
            fis=new FileInputStream("E:/image/pub.jpg");
             
            fos=new FileOutputStream("E:/image/pub2.jpg");


            //创建数组用于保存读取到的数据                                                           byte[] b=new byte[1024];

                        //记录读取到的字节数
            int len=0;

                        
                        //循环读取
            while ((len=fis.read(b))!=-1){
                                
                                //边读边写实现复制
                fos.write(b,0,len);
            }
        }


        catch (IOException e)
        {
            throw new RuntimeException("图片复制失败");
        }
        finally
        {
            try
            {
                if(fis!=null)
                    fis.close();//关闭输入字节流
            }
            catch (IOException e)
            {
                throw new RuntimeException("读取字节流关闭失败");
            }
            try
            {
                if(fos!=null)
                    fos.close();//关闭输出字节流
            }
            catch (IOException e)
            {
                throw new RuntimeException("写入字节流关闭失败");
            }
        }
    }    
}

第一十三讲、一十四讲：IO流(字节流的缓冲区)、IO流(自定义字节流的缓冲区-read和write的特点)

 一，缓冲输出流的了解：

1. 1. 1. 用到的类BufferedOutputStream，BufferedInputStream.
      2. BufferedInputStream类的定义：public class BufferedInputStreamextends FilterInputStream 为另一个输入流添加一些功能，即缓冲输入以及支持 mark 和 reset 方法的能力。
      3. 方法与InputStream类相同。

二，缓冲区的原理：将数据拷贝一部分，读取一部分，循环，直到数据全部读取完毕。如图：

三，字节流操作注意事项：

1. 1. 1. 读取方法应当返回 int 类型，而不是 byte 类型。==原理：数据在内存中以二进制形式存在，当读到八个一时，转换为 byte类型是 -1 ，则此时使用 -1作为文件结束的判断逻辑将会出错。解决办法：将byte 类型转换为 int 类型，并将转后的的数据的前24位二进制用零填充。代码实现： return byte&0xff;     0xff即 255 二进制形式为 00000000  000000000  00000000  11111111   所以将byte的前24位变为零==

四，代码练习：

import java.io.*;


public class MyBufferedInputStream {
             
    
             //定义被包装的类成员
             private InputStream in;
             
             //定义缓冲区的大小 
             private int size=1024;
             
             
             //定义变量分别表示读取数量，以及当前数组下标
             private int pos=0,count=0;
             
             //声明已知长度的缓冲区
             byte[] buf=new byte[size];
             
             
             //定义构造方法
             public MyBufferedInputStream(InputStream in){
                 this.in=in;
             }
             
            
             //定义构造方法
             public MyBufferedInputStream(InputStream in,int size){
                 this.in=in;
                 this.size=size;
             }
             
             
             //声明对外提供的方法
             //功能：一次从缓冲区中读取一个字节数据。
             public int myRead() throws IOException{
                 
                 //缓冲区中没有数据
                  if(count==0){
                      
                      //将数据读入缓冲区
                      count=in.read(buf);
                      
                      //到达文件末尾返回 -1
                      if(count<=0){
                          return -1;
                      }
                      
                      //返回缓冲区中的第一个字节
                      byte read=buf[pos];
                      
                      //缓冲区数据量 减一
                      count--;
                      
                      //缓冲区下标加一
                      pos++;
                      
                      //返回整形数据，原数据与上255，将钱24位设定为零，避免读取的字节为八个一时，错误判断为文件结束
                      return read&0xff;
                      
                  }
                  else {
                      
                      //缓冲区中有数据，直接返回
                      byte read=buf[pos];
                      
                      //改变下标
                      count--;
                      pos++;
                      
                      //返回修改之后的值
                      return read&0xff;
                  }
             }
             
             
             //定义主方法拷贝mp3
             public static void main(String args[]){
                 
                 
                 //声明引用句柄
                    FileInputStream src=null;
                    FileOutputStream dest=null;
                    MyBufferedInputStream mbi=null;
                    
                    //异常处理
                    try{
                        
                        //实例化源文件，目标文件
                        src=new FileInputStream("E:/my.mp3");
                        dest=new FileOutputStream("E:/my2.mp3");
                        
                        //实例化缓冲区读取对象
                        mbi=new MyBufferedInputStream(src);
                        
                        
                        //接受读取的数据
                        int read=0;
                        
                        //循环读取数据并写入文件
                        while((read=mbi.myRead())!=-1){
                            dest.write(read);
                        }
                        
                        
                        //异常处理
                    }catch(IOException e){
                        System.out.println("文件复制错误"+e.toString());
                    }finally{
                        try{
                            if(src!=null){
                                src.close();
                            }
                            if(dest!=null){
                                dest.close();
                            }
                        }catch(IOException e){
                            System.out.println("文件关闭发生错误"+e.toString());
                        }
                    }
             }
}

 

 

第一十五讲：IO流(读取键盘录入)

一，使用到的对象：System.in

1. 1. 1. 该对象的定义：public static final InputStream in   “标准”输入流。此流已打开并准备提供输入数据。通常，此流对应于键盘输入或者由主机环境或用户指定的另一个输入源。======注：次对象使用完毕后可以不进行显示的关闭==========
      2. System的另一个静态对象：  public static final PrintStream out    “标准”输出流。此流已打开并准备接受输出数据。

二，需求分析：

                   通过键盘录入数据，当录入一行数据后，就将改行打印，如果录入的数据是 end ，那么停止录入。

三，代码实现：

import java.io.*;


public class ReadIn {

    public static void main(String[] args)  {
        // TODO Auto-generated method stub
        
        //创建输入对象，指向System.in  ======次对象可以不用显示关闭==========
        InputStream in=System.in;
        
        //缓冲读入的字符
        StringBuilder sb=new StringBuilder();
        
        
        //一直读取键盘输入，直到用户输入end字符串
        while(true){
            
            //接受输入字符
            int ch=0;
            
            
            //读取输入内容
             try {
                  ch=in.read();
            } catch (IOException e) {
                 System.out.println("读取发生错误"+e.toString());
            }
             
             //进行判断，如果是  '
' 则进行下一次读取
             if(ch==13)
                 continue;
             
             //如果是 '
' 字符结束读取，打印用户的输入
             else if(ch==10){
                 
                 //如果用户输入的是  "end" 字符串，则结束读取
                 if("end".equals(sb.toString()))
                     break;
                 
                 //否则打印用户输入，进行下一次读取
                 System.out.println(sb);
                 
                 //打印完毕必须清空缓冲区
                 sb.delete(0, sb.length());
             }else 
                 
                 //普通字符存入缓冲区中
             sb.append((char)ch);
             
        }
    }

}

               ===========键盘录入也可以使用 crtl + c 快捷键结束===============

第一十六讲，一十七讲：IO流(读取转换流)，IO流(写入转换流)

一，需求分析：

                  使用readLine（）方法读取键盘的一行数据。

                  使用newLine() 方法进行换行。

二，思路分析：

1. 1. readLine() 方法是字符流BufferedReader类中的方法。
   2. 负责接收键盘录入的read() 方法是字节流InputStream 类中的方法。
   3. newLine() 方法是字符流BufferedWriter 类中的方法。

三，解决办法：

1. 使用转换流。InputStreamReader（字节转换字符流），OutputStreamReader（字符流转换字节流）。
   1. InputStreamReader 类的定义：public class InputStreamReaderextends Reader
   2. InputStreamReader 类的构造方法：
      1. public InputStreamReader(InputStream in)    创建一个使用默认字符集的 InputStreamReader。
      2. public InputStreamReader(InputStream in, String charsetName) throws UnsupportedEncodingException  创建使用指定字符集的 InputStreamReader。
      3. public InputStreamReader(InputStream in, Charset cs)     创建使用给定字符集的 InputStreamReader。
   3. OutputStreamWriter 类的定义：public class OutputStreamWriterextends Writer   OutputStreamWriter 是字符流通向字节流的桥梁
   4. OutputStreamWriter 类的构造方法：
      1. public OutputStreamWriter(OutputStream out)     创建使用默认字符编码的 OutputStreamWriter。
      2. public OutputStreamWriter(OutputStream out,  Charset cs)      创建使用给定字符集的 OutputStreamWriter。
      3. public OutputStreamWriter(OutputStream out,  CharsetEncoder enc)     创建使用给定字符集编码器的 OutputStreamWriter。
2. 将字节流转换成字符流，之后再使用字符流的 readLine() ,newLine()方法进行数据的按行读取，以及进行换行操作。

四，练习代码：

 

import java.io.*;


public class TransStreamDemo {
             public static void main(String args[]){
                 
                 //创建字符流对象，此对象包装了字节流对象
                 InputStreamReader isr=new InputStreamReader(System.in);
                 
                 
                 //创建缓冲字符流对象，使用readLine() 方法
                 BufferedReader br=new BufferedReader(isr);
                 
                 //接受输入的字符串
                 String line=null;
                 
                 //循环读取用户输入内容
                 while(true){
                     try {
                         
                         //如果用户输入 "end" 则结束读取
                        if("end".equals(line=br.readLine()))
                             break;
                    } catch (IOException e) {
                        // TODO Auto-generated catch block
                        System.out.println("读取发生错误"+e.toString());
                    }
                     
                     //输出用户的输入
                     System.out.println(line);
                 }
                 
             }
}

 ===============键盘录入最常见写法：BufferedReaderin=new BufferedReader(new InputStreamReader(System.in));====================

第一十八讲：IO流(流操作规律-1)

 一，操作流程：

1. 1. 明确目的和源：
      1. 源：键盘录入。
      2. 目的：控制台（屏幕设备）。
   2. 需求分析：
      1. 把键盘录入的数据存储到一个文件中。======源：键盘，目的地：文件（硬盘）==========
      2. 把一个文件数据打印到控制台上。      ======源：文件，目的地：控制台==========
   3. 通过两个明确来选择众多流对象中具体应该用那中体系。--------1，明确目的和源。2，操作的文件或者是源，是否是文本形式的。-----------------
   4. 当体系明确后再明确具体使用那个对象。        ====源设备：内存，硬盘，键盘，目的：内存，硬盘，控制台=====

二，练习分析：

1. 1. 将一个文本文件数据，存储到另一个文本文件中，即复制文件。
      1. 源：应为是源所以使用读取流（InputStream, Reader)。
      2. 是不是文本文件  （Reader)。  ===明确体系===
      3. 确定源对象：因为设备是硬盘文件，选择FileReader。      FileReader  fr=new FileReader("源.txt");
      4. 目的：因为是目的所以使用写入流（OutpurStream, Writer)。
      5. 是不是文本文件  (Writer)。   
      6. 确定目的对象：FileWriter。                                       FileWriter fw=new FileWriter("目的.txt");
      7. 输入流提高效率：  加入BufferedReader                       BufferedReader br=new BufferedReader(fr);
      8. 输出流提高效率：  加入BufferedWriter                        BufferedWriter bw=new BufferedWriter(fw);

三，复制图片代码练习：

 

import java.io.*;


public class MyImage {
             public static void main(String args[]){
                  
                 //确定使用的对象===源：硬盘，图片文件，目的：硬盘，图片文件
                 FileInputStream fis=null;
                 FileOutputStream fos=null;
                 
                 
                 //使用缓冲流提高效率
                 BufferedInputStream bis=null;
                 BufferedOutputStream bos=null;
                 
                 
                 String src="F:/Image/psb.jpg";
                 String dest="F:/Image/psb2.jpg";
                 
                 try{
                     
                     //实例化对象
                      fis=new FileInputStream(src);
                      bis=new BufferedInputStream(fis);
                      
                      bos=new BufferedOutputStream(fos=new FileOutputStream(dest));
                      
                      //转存读入的内容
                      byte[] b=new byte[1024];
                      
                      //循环读取写入实现文件复制
                      while(bis.read(b)!=-1)
                          bos.write(b);
                      
                      //给出成功提示
                      System.out.println("文件复制成功");
                 }catch(IOException e){
                     System.out.println("文件复制错误!"+e.toString());
                 }finally{
                     try{
                         if(bis!=null)
                             bis.close();
                         if(bos!=null)
                             bos.close();
                     }catch(IOException e){
                         System.out.println("文件关闭过程发生错误！"+e.toString());
                     }
                 }
             }
}

第一十九讲：IO流(流操作规律-2)

一，扩展：把录入的数据按照指定的编码表（UTF-8）（默认编码表是GBK），将数据存到文件中。

1. 1. 想要实现使用指定的编码表将数据存入文件中，只能使用转换流。OutputStreamWriter osw=new OutputStreamWriter(new FileInputStream("d.txt"),"UTF-8");
   2. 提高效率：BufferedWriter bw=new BufferedWriter(osw);

====转换流的使用时机：1，字符和字节之间的桥梁。2，涉及到字符编码转换。===

二，代码练习：使用指定的编码表（UTF-8)将键盘输入的数据存入文件中

 

import java.io.*;

public class TransStreamDemo2 {
             public static void main(String args[]){
                 
                 
                 //确定输入源为键盘，创建相对应的输入流对象，并使用装饰流提高效率
                 InputStream in=System.in;
                 
                 //输入流输入的为文本文件，使用转换流进行转换
                 InputStreamReader isr=new InputStreamReader(in);
                 BufferedReader br=new BufferedReader(isr);
                 
                 //读取键盘输入的常用格式：
                 //以上三句话可以省略写为：BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
                 //确定输出源为文件，创建相对应输出流对象，并使用装饰流提高效率
                 FileOutputStream fos=null;
                 
                 //输出流输出的为文本文件，使用输出流进行转换
                 OutputStreamWriter isw=null;
                 BufferedWriter bw=null;
                 try{
                     
                     //创建输出缓冲流，其中转换里流明确使用UTF-8编码格式
                     bw=new BufferedWriter(isw=new OutputStreamWriter(fos=new FileOutputStream("E:/test.txt"),"UTF-8"));
                     
                     //接受读入的一行数据
                     String line=null;
                     
                     //循环读取写入
                     while(!"end".equals(line=br.readLine())){
                         
                         //写入文件
                         bw.write(line);
                         
                         //写入换行符
                         bw.newLine();
                         
                         //缓冲流需要刷新
                         bw.flush();
                     }
                     
                     //成功提示
                     System.out.println("存入完毕");
                     
                     //异常处理
                 }catch(IOException e){
                     System.out.println("发生错误！"+e.toString());
                 }finally{
                     try{
                         if(bw!=null)
                             bw.close();
                     }catch(IOException e){
                         System.out.println("文件关闭发生错误!"+e.toString());
                     }
                 }
             }
}

 

第二十讲：IO流(改变标准输入输出设备)

一，改变标准输入、输出设备用到的System类中的方法：

1. 1. 1. public static void setIn (InputStream in)  重新分配“标准”输入流。
      2. public static void setOut(PrintStream out)   重新分配“标准”输出流。

二，代码练习：通过改变标准输入、输出实现文件的复制

import java.io.*;


public class TransStreamDemo3 {
             public static void main(String args[]){
                 
                 //目的和源都是 文件，创建相对应的流对象引用
                 FileInputStream in=null;
                 PrintStream out=null;
                 
                 //确定操作的是文本文件，使用相对应的缓冲刘提高效率
                 BufferedWriter bw=null;
                 BufferedReader br=null;
                 
                 //异常处理
                 try{
                     
                     //实例化输入输出流对象
                     in=new FileInputStream("E:/test.txt");
                     out=new PrintStream("E:/test_copy.txt");
                     
                     //分别调用 setIn() setOut() 方法重定向标准输入、输出。
                     System.setIn(in);
                     System.setOut(out);
                     
                     
                     //实例化缓冲流。使用转换流进行转换
                     br=new BufferedReader(new InputStreamReader(System.in));
                     bw=new BufferedWriter(new OutputStreamWriter(System.out));
                     
                     //接受读入的一行数据
                     String line=null;
                     
                     //循环读入写入操作
                     while((line=br.readLine())!=null){
                         
                         //写入数据
                         bw.write(line);
                         
                         //换行操作
                         bw.newLine();
                         
                         //清空缓冲区
                         bw.flush();
                     }
                     
                     //操作成功给出提示
                     System.out.println("文件复制成功！");
                 }catch(FileNotFoundException e){
                     System.out.println("文件没有找到"+e.toString());
                 }catch(IOException e){
                     System.out.println("文件复制发生作物"+e.toString());
                 }finally{
                     try{
                         if(br!=null)
                             br.close();
                         if(bw!=null)
                             bw.close();
                     }catch(IOException e){
                         System.out.println("文件关闭发生错误"+e.toString());
                     }
                 }
             }
}

 

第二十一讲，二十二讲:IO流(异常的日志信息)，IO流(系统信息)

一，需求分析：

1. 1. 将程序运行时异常记录在文件中。
   2. 加入异常产生的时间。

二，思路：

1. 1. 获取文件输出流，输出异常信息。
   2. 记录异常产生时间，并输入文件。
   3. 获取异常信息，并将之输入文件。

三，代码实现：

import java.io.*;
import java.util.Date;
import java.text.SimpleDateFormat;


public class ExceptionInfo {
             public static void main(String arga[]){
                 
                          //测试记录函数，此处会发生ArrayIndexOutOfBoundsException
                           try{
                               String s[]=new String[2];
                               s[3]="li";
                           }catch(Exception e){
                               log(new Date(),e);
                           }
             }
             
             //声明将异常记录在文件方法
             public static void log(Date date,Exception e){
                 //记录异常文件名
                 String filename="E:/Exception.log";
                 
                 //声明缓冲输出流，提高操作效率
                 BufferedWriter bw=null;
                 try{
                     
                     //实例化输出对象
                     bw=new BufferedWriter(new FileWriter(filename));
                     
                     //声明格式化日期操作类，格式化日期格式
                     SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                     
                     //写入异常发生时间
                     bw.write(sdf.format(date)+"===");
                     
                     //写入异常信息
                     bw.write(e.toString());
                 }catch(IOException ex){
                     System.out.println("记录异常发生错误"+ex.toString());
                 }finally{
                     try{
                         if(bw!=null)
                             bw.close();
                     }catch(Exception ex){
                         System.out.println("关闭文件发生错误"+ex.toString());
                     }
                 }
             }
}

四，输出系统信息。

1. 1. 获取系统信息：             Propertes  prop=System.getProperties();
   2. 列出系统信息：             prop.list(new PrintStream("E:/sysinfo.txt");

五，代码练习：

import java.io.*;
import java.util.Properties;


public class SysInfo {
             public static void main(String args[]){
                 
                 //获取系统信息
                 Properties prop=System.getProperties();
                 
                 //声明输出流句柄
                 PrintStream ps=null;
                 try{
                     
                     //实例化对象
                     ps=new PrintStream("E:/sysinfo.txt");
                     
                     //将系统信息输出到指定流中
                     prop.list(ps);
                 }catch(IOException e){
                     System.out.println("写入错误"+e.toString());
                 }finally{
                     try{
                         if(ps!=null)
                             ps.close();
                     }catch(Exception e){
                         System.out.println("关闭文件错误！"+e.toString());
                     }
                 }
             }
}

六，常用到的系统信息：

1. 1. user.language=zh   用户的语言
   2. file.encoding=GBK  系统编码
   3. user.name=Thinkpad  用户名
   4. line.separator=          换行符
   5. os.name=Windows 8  操作系统
   6. path.separator=;       路径分割符