2020.8.1

一、今日学习内容

   1、流和流的分类

     （1）在Java中，每个流都是一个对象。 流通常分为两种:输入流(InputStream) 和输出流(OutputStream)。对于输入流，只要从流当中不停地把字节取出即可;而对于输出流，只要把准备好的字节串传给它即可，如图所示。

          

         java.io包中的stream类根据其操作对象的类型可分为两大类:字符流和字节流。
           a. Java的字节流
               InputStream是所有字节输入流的父类，而OutputStream是所有字节输出流的父类。
           b. Java 的字符流
               Reader是所有读取字符串输入流的父类，而Writer 是所有输出字符串的父类。
          结合开始所说的输入/输出流，出现了一个小框架。
                           字节流                 字符流
             输入流  InputStream          Reader
             输出流  OutputStream       Writer
         字节流和字符流如图所示。

          

         从该图可以看出，在Java中，所有的字节流都是以Stream结尾的，所有的字符流都是以Reader/Writer结尾的。

     (2)字节流和字符流

      Java对于流的操作可以分为字节流和字符流。字节流主要操作字节序列的对象，如对二进制文件、图片及影像文件的操作;字符流主要操作字符序列的对象,如对文本        文件等。

      1.字节流
        (1)输出字节流OutputStream
          I/O中输出字节流的继承图所示，可以看出以下特点。
          #OutputStream 是所有的输出字节流的父类，它是一个抽象类。
          #ByteArrayOutputStream、 FileOutputStream 是两种基本的介质流，它们分别向Byte数组和本地文件中写入数据。ObjectOutputStream 和所有                                          FilterOutputStream 的子类都是装饰流。
          使用字节输出流OutputStream定义如下。

public abstract class OutputStream extends object implements Closeable,Flushable

    在此类中定义了如下的几个常用方法。
   #关闭流: public void close() throws IOException.
   #写一组数据:public void write(byte[] b) throws IOException.
   #写一个数据: public void write(int b) throws IOException。 但是要想将Outputream实例化，且进行文件操作，就要使用FileOutputStream 子类。
   #构造: public FileOutputStream(File file) throws FileNotFoundException.
      示例:使用字节流输出内容

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
public class FileOutStreamDemo {
    public static void main(String[] args)throws IOException {
        out();
    }
    public static void out()throws IOException{
        OutputStream out=new FileOutputStream("D:/Hello.txt");
        String info="Hello Java!";
        byte[] buf=info.getBytes();
        out.write(buf);
        out.close();
    }
}

    

      示例：使用字节流追加内容

             该程序还会有一个问题，如果在关闭前程序出现异常，文件就不能关闭，所以应该将关闭放在finally 里，不管程序有无异常，都应该关闭流，代码修改如下。

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
public class FileOutStreamDemo {
    public static void main(String[] args)throws IOException {
        out();
    }
    public static void out(){
        OutputStream out=null;
        try {
           out=new FileOutputStream("D:/Hello.txt",true);
           String info="Hello PHP!";
           byte[] buf=info.getBytes();
           out.write(buf);
        }catch(IOException e) {
            e.printStackTrace();
        }finally {
            try {
                if(out!=null) out.close();
            }catch(IOException e) {
                e.printStackTrace();
            }
        }
    }
}

  

      (2)输入字节流InputStream
          I/O中输入字节流的继承图所示，可以看出:
         #InputStream 是所有的输入字节流的父类，它是一个抽象类。
         #ByteArrayInputStream、 StringBufferInputStream. FileInputStream 是三种基本的介质流，它们分别从Byte数组、StringBuffer 和本地文件中读取数据。                        ObjectInputStream和所有FilterInputStream的子类都是装饰流。
        用户可以使用InputStream完成输入字节流的操作，此类定义如下。

public abstract class InputStream extends object implements Closeable

         InputStream类中定义的方法如下。
             #关闭: public void closeO throws IOException.
             #读取一个字节: public abstract int read() throws IOException.
             #读取一组内容: public int read(byte[] b) throws IOException.
            读取文件，使用子类FileInputStream。
        示例:使用字节流读文件内容

import java.io.FileInputStream;
import java.io.IOException;
import java.io.OutputStream;
public class FileInputStreamDemo {
    public static void main(String[] args)throws IOException {
        in();
    }
    public static void in() {
        FileInputStream in=null;
        try {
           in=new FileInputStream("D:/Hello.txt");
           byte[] buf=new byte[1024];
           int len=-1;
           while((len=in.read(buf))!=-1) {
               String s=new String(buf,0,len);
               System.out.println(s);
           }
        }catch(IOException e) {
            e.printStackTrace();
        }finally {
            try {
                if(in!=null) in.close();
            }catch(IOException e) {
                e.printStackTrace();
            }
        }
    }
}

    输出结果：Hello Java!Hello PHP!

     2、字符流

       Reader与Writer和其子类都是处理字符流的相关类。字符流可以对流数据以一个字符的长度为单位来处理，并进行适当的字符编码转换处理，- -般字符流都用来操作纯文本文件。
    (1)字符输出流。
    Writer是字符输出流，该类是一个抽象类，所以需要使用子类FileWriter类来操作文件。
   示例:字符输出流写入内容

import java. io. FileWriter;
import java.io. IOException;
public class WriteDemo {
    public static void main(String[] args) throws IOException {
      write() ;
    }
    public static void write() throws IOException{
       FileWriter fw =new FileWriter ("D:/Hello.txt") ;
       fw. write("Hello C++!");
       fw.close() ;
    }
}

     若在文件中追加内容，且原内容不被覆盖，则

import java. io. FileWriter;
import java.io. IOException;
public class WriteDemo {
    public static void main(String[] args) throws IOException {
      write() ;
    }
    public static void write() throws IOException{
       FileWriter fw =new FileWriter ("D:/Hello.txt",true) ;
       fw. write("Hello C++!");
       fw.close() ;
    }
}

    (2)字符输入流

        Reader是一个字符输入流，但它是-个抽象类，所以必须由其子类FileReader来实例化。
        示例:使用字符输入流读取内容

import java. io. FileReader;
import java.io. IOException;
import java. io. Reader;
public class WriteDemo {
    public static void main(String[] args) throws IOException {
     reader() ;
    }
    public static void reader() throws IOException{
      Reader r =new FileReader ("D:/Hello.txt") ;
      char[] buf=new char[1024];
      int len=0;
      while((len=r.read(buf)!=-1){
          String s=new String(buf,0,len);
          System.out.println(s);
      }
      r.close();
   }
}

    输出结果：Hello C++!

    3.字节流与字符流的区别
       字节流与字符流的区别主要体现在以下两点。
       #读写单位不同:字节流以字节(8bit) 为单位，字符流以字符为单位，根据码表映射字符，一次可能读多个字节。
       #处理对象不同:字节流能处理所有类型的数据(如图片、avi等)， 而字符流只能处理字符类型的数据。
       结论:只要是处理纯文本数据，就优先考虑使用字符流，此外，都使用字节流。

二、遇到的问题

    内容较多，不能记得很清楚，对字节流字符流理解的也不是很清楚

三、明日计划

    继续学习第12章的内容