JAVA-IO流②

1、 字符流FileReader

 public static void main(String[] args) {
      FlieReader reader=null;
      try{
          reader=new FileReader("test.txt");
          int readNum=0;
          //这里和字节流不太一样，字节流是新增字节数组，这里是新增字符数组
          char[] chars=new char[10];
          while((readNum=reader.read(char))!=-1){
              System.out.print(new String(chars,0,readNum));
          }
      }catch(FileNotFoundException e){
          e.printStackTrace();
      }catch(IOException e){
          e.printStackTrace();
      }finally{
          if(reader!=null){
              try{
                  reader.close();
              }catch(IOException e){
                  e.printStackTrace();
              }
          }
      }
  }

2、 自带缓冲区的BufferedReader

  
  //这里偷懒了，再声明里直接抛出异常，正常不能这么做，这样就没有地方处理异常了！！！
  public static void main(String[] args) throws Exception{
      FileReader fr=new FileReader("test.txt");
      BufferedReader br=new BufferedReader(fr);
      
      //字节流，这个字节流可能是框架自带的
      FileInputStream fis=new FileInputStream("test.txt");
      //这是一个桥梁，连接了字节流和字符流，一个转换器
      //可以在这里进行设计字符集
      InputStreamReader isr=new InputStreamReader(fis,"UTF-8");
      //转换后的字符流当作参数导入
      BufferedReader br2=new BufferedReader(isr);
      
      //相对isr这个流来说，InputStreamreader是包装流 FileInputStream是节点流
      //相对br2这个流来说，BuggeredReader是包装流 InputStreamReader是节点流
      
      String readStr=null;
      //readLine()这个方法可以直接将文本的一整行内容全部取出，不会增加换行
      while((readStr=br2.readLine())!=null){
          System.out.println(readStr);
      }
      
      br.close();
      //关闭bufferedReader他的参数字符流是不需要要关闭的，可以看close()方法
      br2.close();
  }

3、 通过System.getProperty("file.encoding")获取字符集

  //通过这行代码可以获取字符集
  System.getProperty("file.encoding");

4、 FileWrite写入文件

  
  public static void main(String[] args)throws Exception {
      FileWriter fw=new FileWriter("test.txt",true);
      fw.write("\n 这一次我能写Sting");
      //需要刷新，并且并且关流，FileWriter存在一定的缓冲区，如果不刷新，不关流，缓冲区没写满，会不执行
      //到我们的代码中
      fw.flush();
      fw.close();
  }   

5、 自带缓冲区的BufferedWriter

  public static void main(String[] args)throws Exception {
      BufferedWriter bw=new BufferedWriter（new OutputStreamWriter(new FileOutputStream("test.txt,true")));
      bw.write("\n这一次我一定能通过BufferedWriter写String");
      bw.flush();
      bw.close();
  }

这个BufferedWriter比FileWriter效率要高，因为FileWriter在每次执行writer的时候会进行转码，而BufferedWriter只有缓冲区写满了才会转码，这个要注意以下，不能回答因为bufferedWriter有缓冲区所以快，因为FileWriter也有缓冲区。

对于小文件可能关联不大，但是如果文件大小特别的话，BufferWriter效率就体现出来了。

6、 DataIO数据IO

写入：

 
  public static void main(String[] args)throws Exception {
      FileOutputStream fos=new FileOutputStream("DataIOTest.txt");
      DataOutStream dot=new DataOutputStream(fos);
      
      byte b=1;
      short s=2;
      int i=3;
      long l=4L;
      float f=3.00F;
      double d=3.14;
      char c='这';
      
      boolean flag=true;
      dot.writeByte(b);
      dot.writeByte(s);
      dot.writeByte(i);
      dot.writeByte(l);
      dot.writeByte(f);
      dot.writeByte(d);
      dot.writeByte(c);
      dot.writeBoolean(flag);
  }

读取：读取的时候一定要确保读的顺序和写的顺序是一样的

  
  public static void main(String[] args)throws Exception {
      FileInputStream fis=new FileInputStream("DataIOTest.txt");
      DataInputStream dit=new DataInputStream(fis);
      
      byte b=dit.readByte();
      short s=dit.readShort();
      int i=dit.readInt();
      long l=dit.readLong();
      float f=dit.readFloat();
      double d=dit.readDouble();
      char c=dit.readBoolean();
      boolean flag=dit.readBoolean();
      
      System.out.println(b);
      System.out.println(s);
      System.out.println(i);
      System.out.println(l);
      System.out.println(f);
      System.out.println(d);
      System.out.println(c);
      System.out.println(flag);
  }

7、 序列化

 

第一步，将对象进行Serializable接口实现

​ Serializable接口，这个属于标识接口，它不存在任何抽象方法，增加上这个接口，说明这个类允许被序列化。

​ transient关键字，这个关键字打上的属性不会被序列化，反序列化结果为null。

import java.io.Serializable;
  ​
  public class User implements Serializable{
      private String sUserName;
      private transient String sPassword;
      
      public User(String sUserName,String sPassword){
          this.sUserName=sUserName;
          this.sPassword=sPasswprd;
      }
      
      @Override
      public String toString(){
          return "User{"+
                  "sUserName'"+sUserName+'\'+
                  ",sPassword='"+sPassword+'\'+
                  '}';
      }
      
      public String getsUserName(){
          return sUserName;
      }
      
      public void setsUserName(String sUserName){
          this.sUserName=sUserName;
      }
      
      public String getPassword(){
          return sPassword;
      }
      
      public void setsPassword(String sPassword){
          this.sPassword=sPassword;
      }
  }
  
  //序列化
  public static void main(String[] args)throws Exception {
      ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("ObjectTest.txt"));
      oss.writeObject(new User("Zhangsan","password"));
      oss.writeObject(new User("Lisi","password"));
      oss.writeObject(new User("Wangwu","password"));
      //刷新流
      oss.flush();
      //关闭流
      oss.close();
  }
  
  //反序列化
  public static void main(String[] args)throws Exception {
      ObjectInputStream ois=new ObjectInputStream(new FileInputStream("ObjectTest.txt"));
      int i=0;
      while(i<3){
          i++;
          //这里我们可以不输出，而是使用一个Object接受，墙砖后可以进行正常操作
          System.out.println(ois.readObject());
      }
  }

8、 总结

文件专属流：

java.io.FileInputStream

java.io.FileOutputStream

java.io.FileReader

java.io.FileWriter

转换流：(将字节流转换成字符流)(桥梁)

java.io.InputStreamReader

java.io.OutputStreamWriter

缓冲流专属：

java.io.BufferedReader

java.io.BufferedWeiter

java.io.BufferInputStream

java.io.BufferOutputStream

数据流专属：(数据)

java.io.DataInputStream

java.io.DataOutputStream

标准输出流：(不需要关流)

java.io.PrintWriter

java.io.PrintStream

  
  public static void main(String[] args)throws Exception {
      System.out.println("123");
      PrintStream pa=System.out;
      ps.println("567");
      System.setOut(new PrintStream(new FileOutputStream("test.log")));
      SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
      Object o=new Object();
      System.out.println(sdf.format(new Date())+"我这这一个时间实例化了一个Object");
      System.out.println(sdf.format(new Date())+"我这炸一个时间有用户登陆了");
      System.out.println(sdf.format(new Date())+"我在这一个时间catch块跑出了一个异常");
  }

对象输出流：(序列化)

java.io.ObjectInputStream

java.io.ObjectOutputStream