IO流基础

　　IO流,也称为数据流，用于处理设备之间的数据传输。
　　JAVA对数据的操作就是通过流的方式，而流分为两种:字符流，字节流

字符流：

　　可以内部制定码表，处理文字很方便，字符流里的基类是Reader，Writer
字节流：

　　操作字节数据。和字符流差不多，基类是InputSteram，OutputStream，如果不使用缓冲区，不需要flush()方法，查看父类方法，使用子类建立对象。

　　IO包中子类名称后缀就分明了字节流和字符流,前缀说明了功能，缓冲区的出现是为了提高流的效率，在创建缓冲区之前要先有流对象，只要用到缓冲区就要用到flush()刷新方法。关闭缓冲区就会关闭缓冲区中调用的流对象。

　　　　bufferedWriter缓冲区提供跨平台换行符方法newLine();
　　　　bufferedReader缓冲区提供一次读取一个文本行的方法readLine();不包含终止符，读到文件末尾返回null，加强了原有功能，如果想提高效率就使用缓冲区，Bufferedxxx。
装饰设计模式：
　　当想要对已有的对象进行功能增强时，定义一个类将已有对象传入，基于已有功能，提供加强功能，那么这个自定义的类就称为装饰类，装饰模式比继承要灵活，避免继承体系臃肿，降低类与类的关系，装饰类和被装饰类通常是一个体系的。

　　因为增强已有对象，具备的功能和已有的是相同的，只不过是加强功能，通常通过构造方法(接收被装饰的对象)，基于传入对象的功能提供更强的功能方法。

流操作的基本规律：
　　最痛苦的就是流对象有很多，不知道该用哪一个。

　　通过三个明确来完成

　　　　1，明确源和目的。
　　　　　　源：输入流。InputStream Reader。
　　　　　　目的：输出流。OutputStream Writer。
　　　　2，操作的数据是否是纯文本。
　　　　　　是：字符流。
　　　　　　不是：字节流。

　　　　3，当体系明确后，在明确要使用哪个具体的对象。
　　　　　　通过设备来进行区分：
　　　　　　源设备：内存，硬盘，键盘。
　　　　　　目的设备：内存，硬盘，控制台。

　　流操作的只有数据,而数据最明显的体现形式就是文件，而文件包含很多信息，属性，想操作文件的话，java就把文件封装成了对象File类，方便对文件或者文件夹的属性进行操作。

　　properties是Hashtable的子类，具备Map集合的特点，存储的键值对都是字符串，是集合中和IO技术结合的容器，用于键值对形式的配置文件。

　　字节流的两个顶层父类:

　　　　1.InputStream   2.outputStream

　　字符流的两个顶层父类:

　　　　1.Reader    2.Writer

　　这些体系的子类都是已父类名做为后缀，而前缀是该对象的功能。

　　字符流：

　　简单例子：将一个字符串写入到文件中

 　　//创建一个可以往文件中写入字符数据的字符流输出对象
 　　FileWriter fe = null;
     try {
         //在创键对象时必须要明确该文件的存储目的地
         //如果目的地存在该文件，则会被覆盖
         //如果构照文件中加入true,则可以对文件进行续写
         fe=new FileWriter("F:/1.txt",true);
         //调用write写入数据
             fe.write("asjhgfajkshgfaksjdfg");
         } catch (IOException e) {
             e.printStackTrace();
         }finally{
             try {//关闭流，关闭资源，在关闭前会调用flush();刷新缓冲区
             　　fe.close();
             } catch (IOException e) {
             　　e.printStackTrace();
             }
     }
     //将硬盘中的文件读取然后输入到控制台中：
     //1.创建读取流对象
     FileReader fr=null;
     try{
         //2.在读取的时候一定要 被明确被读取的文件，确保这个文件存在，不然会发生异常
         fr=new FileReader("f:/1.txt");
         int aa=0;
         while((aa=fr.read())!=-1){
         System.out.println((char)aa);
         }
 　　. . .  ..  . . .
 　　//用数组读取文件：
 　　//1.创建读取流对象
     FileReader fr=null;
     try{
         //2.在读取的时候一定要 被明确被读取的文件，确保这个文件存在，不然会发生异常
         fr=new FileReader("f:/1.txt");
         char [] ch=new char[1024];
         int leng=0;
         while((leng=fr.read(ch))!=-1){
         System.out.println(new String(ch,0,leng));
      }    

　　如果字符串中需要换行，可以在字符串中加入常量：(根据系统资源获取对应的换行符)
　　private static final String LINE_SEPARATOR =System.getProperty("line.separator");
　　IO异常：在用读写流对象调用colse()的时候一定要加判断判断对象不等于null否则会抛空指针异常

　　字符流缓冲区对象：BuffredReader ， BuffredWriter
　　在字符流缓冲区中：
　　　　newLine()：写入一个行分隔符。行分隔符字符串由系统属性 line.separator 定义，并且不一定是单个新行 ('\n') 符。
　　　　Newline()：只有BuffredWriter对象具备。
　　　　readLine()：读取一个文本行，一次读取一行数据，遇到换行符就终止，返回读取到的字符串，如果读取到流的末尾就返回null。
　　　　readKine()：方法只有BuffredReader具备。

　　使用方法：

 public static void main(String[] args) throws IOException {
        //字符流关联文件
         FileReader fr=new FileReader("f:/1.txt");
         FileWriter fw=new FileWriter("f:/2.txt");
         BufferedReader br=new BufferedReader(fr);
         BufferedWriter bw=new BufferedWriter(fw);
         char [] ch=new char[1024];
         int leng=0;
         //使用缓冲区读取数据，从缓冲区中读取数据
         while((leng=br.read(ch))!=-1)
         {
             //使用缓冲区写入数据到内存中
             bw.write(ch, 0, leng);
         }
         //关闭缓冲区，实际上就是关闭了流对象
         br.close();
         bw.close();
     }
 自定义缓冲区：
 public class MybufferReader {
    private Reader r;
    //定义一个数组作为缓冲区
    private char [] ch=new char[1024];
    //定义一个指针用于操作数组中的元素，当操作到最后一个元素时指针归零
    private int pos=0;
    //定义一个计数器，用于记住缓冲区的数据个数，当缓冲区中数据减到零，就从源中继续获取数据到缓冲区中
    private int count=0;
    public MybufferReader(Reader r) {
          this.r=r;
    }
     /*
      该方法一次从缓冲区中取一个字符
 　　*/
     public int myReader() throws IOException
     {
         //从源中获取一批数据到缓冲区中，只有count为0时。
         if(count==0)
         {
             count=r.read(ch);
             pos=0;
         }
         //当源中的数据取完时候返回负一
         if(count<0)
              return -1;

           char ch1=ch[pos];//读取缓冲区中数据
           pos++;//数组的指针+1
           count--;//缓冲区中数据的个数-1
           return ch1;

     }
     public String myReaderLine() throws IOException
     {
         StringBuilder sb=new StringBuilder();
         int ch=0;
         while((ch=myReader())!=-1)
         {
             if(ch=='\r')
                 continue;
             if(ch=='\n')
                 return sb.toString();
             //将从缓冲区中读到的字符存储到转存行数据的缓冲区中
             sb.append((char)ch);
         }
         if(sb.length()!=0)
             return sb.toString();
         return null;
     }
     public void mycolse() throws IOException
     {
         r.close();
     }

 }
 装饰设计模式：
    对一组对象的功能进行增强的时候，就可以使用该模式来解决问题。
 例如：public class PersonDemo {
     public static void main(String[] args) {
         Person p=new Person();
         p.chifan();
         newperson p1=new newperson(p);
         p1.chifan();
         newperson2 p2=new newperson2();
         p2.chifan();
     }
 }
 class Person
 {
     public void chifan()
     {
         System.out.println("吃饭");
     }
 }
 //这个类的出现是为了增强Person的功能出现的
 class newperson
 {
     private Person p;
     //构造方法中传入Person对象
     public newperson(Person p) {
     this.p=p;
     }
     //增强chifan方法
     public void chifan()
     {
         System.out.println("喝酒");
         p.chifan();
         System.out.println("吃甜点");
     }
 }
 //这个类继承于Person
 class newperson2 extends Person
 {
     public void chifan()
     {
         System.out.println("喝酒");
         super.chifan();
         System.out.println("吃甜点");
     }
 }
 装饰设计模式和继承都能实现这一特点，特点：只为提高功能，进行的继承导致继承体系越来越臃肿，不够灵活，而装饰比继承灵活。
 BufferedReader的子类LineNumberReader的基本使用。
 例子： public static void main(String[] args) throws IOException {
    FileReader fr=new FileReader("ArrayListTest.java");
    LineNumberReader lin=new LineNumberReader(fr);
    String str=null;
    //一次读取一行
    while((str=lin.readLine())!=null)
    {//输出行号和行内容
        System.out.println(lin.getLineNumber()+":"+str);
    }
 }