io流

基本的字节输入流

     一般用于读取诸如图像数据之类的原始字节流，°字符建议使用FileReader
     public class FileInputStream extends InputStream
         用于读取诸如图像数据之类的原始字节流 ，其父类为抽象类
       
    构造
         public FileInputStream(File file)
                     fle将要读取的文件的目录 
          public FileInputStream(String name)
                      fle将要读取的文件的目录字符串形式
                       
          方法   
                  public int read()
                      从此输入流中读取一个数据字节，达到末尾返回-1 
                  public int read(byte[] b)  ，注意参数是字节数组
                        存储读取数据的缓冲区。读入缓冲区的字节总数.达到末尾返回-1 
                   public int read(byte[] b,int off, int len) 
                            off数组开始的索引，len读取的长度
                         返回读入缓冲区的字节总数

基本的字节输出流

           一般 用于写入诸如图像数据之类的原始字节的流 ,写字符建议FileWriter
              public class FileOutputStream extends OutputStream 
                  其父类是抽象类
             
             public FileOutputStream(File file)
             public FileOutputStream(File file, boolean append) 
                  布尔值 表示输出文件时数据是否追加(true)或覆盖(false) 
             public FileOutputStream(String name)
                  字符串形式的文件名 
             public FileOutputStream(String name, boolean append)
                  布尔值也表示是否追加 
            
     普通方法
             public void write(int b)
                   b要写入的字节。    
                    
              public void write(byte[] b)
                            要写入的字节数组  
              
              public void write(byte[] b,int off,   int len)
                         off是开始索引，len写入的长度 

              public void close() 
               
               public void flush()

Reader 字符输入流

     public abstract class Reader extends Object implements Readable, Closeable
        是字符输入流的最顶层的父类  
             
             public int read(CharBuffer target)
                   target 要将字符读入的缓冲区    
                   返回添加到缓冲区的字符数量   
                      
            public int read() 
               读取单个字符，返回整数读取的字符，读取完返回-1
            
            public int read(char[] cbuf) 
                 将字符读入数组 ，返回的去的字符数，读完返回-1 
                  
            public abstract int read(char[] cbuf,  int off, int len) 
                 将字符读取一部分到数组里 ，off开始索引，len长度
             public abstract void close() 
                 关闭该流并释放与之关联的所有资源

文件字符输入流

    public class FileReader extends InputStreamReader
                               而InputStreamReader是Reader的子类
      构造
    public FileReader(String fileName)
                要从中读取数据的文件的名称 
     public FileReader(File file)
                要从中读取数据的 File  
      public FileReader(FileDescriptor fd) 
                要从中读取数据的 FileDescriptor  
                
      
        
       普通方法都是继承父类的，没有自己独有的方法

字符输出流

     字符输出流的最顶层的父类Writer
     public abstract class Writer extends Object implements Appendable, Closeable, Flushable
   
        方法
        public void write(int c)  
              写入单个字符(字符的int值)
      
        public void write(char[] cbuf)
              要写入的字符数组  
               
        public abstract void write(char[] cbuf, int off, int len) 
              cbuf - 字符数组
              off - 开始写入字符处的索引
              len - 要写入的字符长度 
               
        public void write(String str)
              写入字符串。   
               
        public void write(String str, int off, int len)    
                  写入字符串的某一部分。
                  off - 相对初始写入字符的偏移量
                  len - 要写入的字符数 
         
        public Writer append(char c)
                  将指定字符添加到此 writer。 
        
       public Writer append(CharSequence csq,  int start, int end)
                  csq要添加子序的字符序列，如果为null,则添加四个字符"null"
                   start是子序列的第一个字符的索引 
                   end是子序列最后一个字符的索引 
                    
          public Writer append(CharSequence csq)
                    将指定字符序列添加到此 writer 
          
          public abstract void close()
                    关闭此流，但要先刷新它  
                     
          public abstract void flush()
                    刷新该流的缓冲 

文件字符输出流

         public class FileWriter extends OutputStreamWriter 
                     而OutputStreamWriter 是Writer的子类 
          
          构造
            
            public FileWriter(File file)
                    要写入数据的 File 对象 
                     
            public FileWriter(File file,  boolean append) 
                     根据给定的 File 对象构造一个 FileWriter 对象
                     第二个参数如果是true,则在文件末尾处写入字符，否则覆盖   
                      
             public FileWriter(FileDescriptor fd) 
                    要写入数据的 FileDescriptor 对象
              
              public FileWriter(String fileName)
                    根据给定的文件名构造一个 FileWriter 对象 
                     
               public FileWriter(String fileName,  boolean append)
                    根据给定的文件名来写入数据，
                    第二参数为true时，则将字符写入末尾，否则覆盖
                    
         该类没有自己独有的方法，都是继承父类的方法 
                   
                   使用步骤：
                      创建该类对象实例，构造中绑定数据的输入地址
                      使用writer方法将数据写入到内存缓冲区中(字符转换为字节的过程)
                      使用flush方法，把缓冲区的数据，刷新到文件中
                      close释放资源(会先把内存缓冲区的的数据刷新到文件中)
          
          close和flush的区别 
                    使用了flush方法后，刷新内存缓冲区，依然可以使用流对象，而close方法则是
                    先属性内存缓冲流后关闭流，系统释放资源，不可以在使用

Properties

   public class Propertiesextends Hashtable<Object,Object>
    唯一和io流相关的集合  
    Properties 类表示了一个持久的属性集,可保存在流中或从流中加载  
    性列表中每个键及其对应值都是一个字符串 
     
     构造  
         public Properties()
          
         public Properties(Properties defaults)
             创建一个带有指定默认值的空属性列表
              
        
      方法 
            
               public String getProperty(String key)
                   通过key值返回value值 
                
                public String getProperty(String key, String defaultValue)
                   通过key值来获取返回value值，如果不存在该key,则返回默认的
                     值defaultvalue 
                 
                 public Object setProperty(String key,String value) 
                      调用 Hashtable 的方法 put 
                         key - 要置于属性列表中的键。
                         value - 对应于 key 的值。
                          属性列表中指定键的旧值，如果没有值，则为 null 
                           
                  public Set<String> stringPropertyNames() 
                      此属性列表中的键集,其中该键及其对应值是字符串 
                  
                  
                  public void store(OutputStream out,String comments) 
                  public void store(Writer writer, String comments) 
                   
                   上面方法的第一个参数是字节输出流，不能写入中文(会乱码)
                   下面方法的第一个参数是字符输出流，可以写中文
                       String comments：注释，用来解释说明保存的文件时做什么用的，
                       不能使用中文，会产生乱码，默认是unicode编码，一般用空字符串 
         
         将数据写入硬盘里， 使用setProperty方法  
               
            使用load方法读取保存的键值对文件
                 读取数据   字节输入流，不能读取含有中文的键值对，会乱码
                 而字符输入流则不会乱码
                 

         
        
            读取过程中，键值默认链接符号可以使用=,空格(其他符号)
            存储键值对的文件中，可以使用#进行注释，被注释的键值不会被读取
            存储键值对的文件中，键与值默认是字符串，不用再加引号


   使用：
   Properties properties = new Properties();
   //加载该文件
    properties.load(new FileInputStream("E:\\project\\test\\one\\demo\\src\\main\\resources\\application.properties"));
    //获取所有的键
    Set<String> strings = properties.stringPropertyNames();
    //将键值写入指定文件文件
    properties.store(new FileOutputStream("C:\\xx"),"");
    Iterator<String> iterator = strings.iterator();
    while (iterator.hasNext()){
        System.out.println(properties.getProperty(iterator.next()));
    }

也可以写回我们读取的这个文件
   properties=new Properties();   //记得重新指向新的空间，不然会有重复的键值写入文件。
    properties.setProperty("npy","lxd"); //写入的键值
    //覆不覆盖需要看文件字节输出流FileOutputStream的第二个参数，false表示覆盖，true是追加。
    properties.store(new FileOutputStream("E:\\project\\test\\one\\demo\\src\\main\\resources\\application.properties",true),"");
    properties.clear();

------------------------------------------------------------------------
缓冲流

    缓冲流也叫高效流，是对4个基本的FileXxx流的增强，这四个流按
    数据类型分类
        字节缓存流：BufferedInputstream,  BufferedOutputStream
        字符缓冲流:   BufferedReader   BufferedWriter  
        缓存流的基本原则，是在创建流对象时，会创建一个内置的默认大小的·缓冲
        区数组，通过缓存区读写，减少io次数，提高读写效率

字节缓冲输入流

       就是在基本字节输入流增加了一个缓冲区(数组)
          提高基本字节输入流的读取速度         
   public class BufferedInputStream extends FilterInputStream 
        
        构造方法 
            public BufferedInputStream(InputStream in) 
              创建一个内部缓冲区数组并将其存储在 buf 中。 
            
            public BufferedInputStream(InputStream in, int size)
                     size - 缓冲区大小 
            
             部分字段  
                protected volatile byte[]   存储数据的内部缓冲区数 
                 
                 protected int count   比缓冲区中最后一个有效字节的索引大 1 的索引，  
                    此值始终处于 0 到 buf.length 的范围内 
           
           方法      
                   public int read() 
                   
                   public int read(byte[] b, int off, int len)
                                off开始索引位置，len长度  
                    还有一个从父类继承过来的重载方法，参数  byte[] 
                     
                     public void close()

字节缓冲输出流

      public class BufferedOutputStream extends FilterOutputStream 
         
         有两个字段 
         protected byte[] buf存储数据的内部缓冲区 
         protected int count缓冲区中的有效字节数，
             此值始终处于 0 到 buf.length 范围内
              
    构造   
         public BufferedOutputStream(OutputStream out) 
            创建一个新的缓冲输出流，以将数据写入指定的底层输出流 
         
         public BufferedOutputStream(OutputStream out, int size)  
            和上面一样 ，size是缓冲区的大小 
          
      方法   
          public void writer() 
             参数分别是   int b
                               byte[] b,int off, int len 
                               byte[] b  其中这方法是继承来的
            public void flush()  
                刷新此缓冲流
               
               其中writer方法将数据写入内部缓冲区中，只有flush或close才会将数据写
               入底层输入流

字符缓存输入流

       从字符输入流中读取文本，缓冲各个字符，
      从而实现字符、数组和行的高效读取。 
  public class BufferedReader extends Reader 
   
 构造
      public BufferedReader(Reader in 
          创建一个使用默认大小输入缓冲区的缓冲字符输入流 
       
      public BufferedReader(Reader in, int sz) 
            in - 一个 Reader    sz - 输入缓冲区的大小 
             
        可以使用FileReader对象，生成该对象的缓冲区，提高读取效率
  方法   
       public int read()   读取单个字符。  
        
       public int read(char[] cbuf, int off,int len) 
          off开始索引值  ，len长度   
        还有一个从父类继承来的byte[]参数的方法 
         
        public String readLine()
               读取一个文本行 、不包含任何终止符，读到末尾则返回null
                
        public void close()

字符缓存输出流

      public class BufferedWriter extends Writer 
构造 
    public BufferedWriter(Writer out) 
       创建一个使用默认大小输出缓冲区的缓冲字符输出流。 
        
    public BufferedWriter(Writer out,int sz) 
         sz - 输出缓冲区的大小，是一个正整数  
           
       可以使用FileWriter对象， 会为该对象生成一个缓冲区，提高写入效率
方法       
       
       public void write(int c)
              写入单个字符。 
               
        public void write(char[] cbuf,int off,  int len)
              写入字符数组的某一部分。    
               
         public void write(String s,  int off,  int len)
              写入字符串的某一部分。 
               
         public void newLine()  表示换行 
            补充一下，windows; \r\n  linux: \n   mac: \r
         
         public void flush()
        
         public void close()

转换流

可以读取任意编码的文件，可以写入任意编码的文件

字符转换输出流

        public class OutputStreamWriter extends Writer 
           是字符流通向字节流的桥梁，
           可使用指定的 charset 将要写入流中的字符编码成字节
            次调用 write() 方法都会导致在给定字符（或字符集）上调用编码转换器
            
       构造 
             public OutputStreamWriter(OutputStream out) 
                 创建使用默认字符编码的 OutputStreamWriter   
                 默认字符集utf-8 
                  
              public OutputStreamWriter(OutputStream out,Charset cs)
                    cs是字符集 
                     
        方法   
                 public void write(int c)
                        写入字符的int形式 
                         
                  public void write(char[] cbuf, int off, int len) 
                       写入字符数组的某一部分         
        
                  public void write(String str,  int off, int len) 
                      写入字符串的一部分       
                       
                   public String getEncoding()  
                       返回此流使用的字符编码的名称 
                        
                    public void flush()
                    public void close() 
                    还有来自父类的方法
                    public void write(String str)
                    public void write(char[] cbuf)

字符转换输入流

            public class InputStreamReader extends Reader   
                 是字节流通向字符流的桥梁 ，它使用指定的 charset 读取字节并将其解
                 码为字符  ，每次调用 InputStreamReader 中的一个 read() 方法都会导
                 致从底层输入流读取一个或多个字节
                  
            构造 
                public InputStreamReader(InputStream in)     
                 
                public InputStreamReader(InputStream in,String charsetName) 
                            String charsetName字符集名称   
           
           方法
               继承了父类所有方法
               public int read()   读取单个字符   
                
               public int read(char[] cbuf,  int offset,int length)    
                
               public int read(char[] cbuf)   
                
               public void close()

序列化

     把对象以流的方式写入到文件，叫对象的序列化  
      
      把文件中保存的对象，以流的方式读取出来，叫做对象的反序列化  

序列化

       public class ObjectOutputStreamextends OutputStreamimplements 
             ObjectOutput, ObjectStreamConstants 
              
     构造    
            protected ObjectOutputStream()

            public ObjectOutputStream(OutputStream out)
             
             public final void writeObject(Object obj)  
               注意要写入文件的对象，其类必须实现序列化接口Serializable

反序列化

 public class ObjectInputStreamextends InputStreamimplements ObjectInput, 
         ObjectStreamConstants        
           
           public ObjectInputStream(InputStream in)   
           
            public final Object readObject()
                         将文件中的数据反序列化成一个对象
        
        注意：  
           当我们序列化对象时，它的变量如果使用了static关键字的话，是无法序列
           化数据到文件中的  
            
            瞬态关键字
            transient关键字修饰成员变量，也可以使变量不被序列化，但又没有static
            的含义 ，想不被序列化，可以使用该关键字 
             
            注意：  
               当我们的对象序列化时，会在其class文件存在一个序列化的编号，而且
               其保存的文件也会生成一个相同的序列号，但是，如果我们修改了类后编
               译运行改变了序列号后再反序列化后，就会抛异常InvalidClassException
                    该序列号serialVersionUID
                    为了防止发生这种情况，可以声明该字段为静态的，最终的long型
                    数据

打印流

           public class PrintStreamextends FilterOutputStreamimplements                 
                Appendable, Closeable 
                  
              只负责打印，不负责读取  ，且永远不会抛Io异常
               该打印流可以改变输出语句的流向2 
               一般的输出都是在控制台 ，可以使用System.setOut方法改变输出语句的
               目的地 
               注意，然后写了setout方法后，在该条代码的下面输出到控制台的打印信息，会输出一份在我们提供的文件中

               如：PrintStream p=new PrintStream(目的地)
                  该目的地可以是file,String，输出流对象的形式