JAVA作业10（20201205）

1.Java中流的分类有哪些？

流动方向: 分为输入流（InputStream:System.in)和输出流 (PrintStream:System.out)

读取类型: 分为字节流（InputStream:System.in)和字符流 (字符流对象:new InputStreamReader(System.in))

发生源头: 分为节点流(直接操作目标设备对应的流,如文件流，标准输入输出流)和过滤流类(继承带有关键字Filter的流用于包装操作节点流，方便读写各种类型的数据)

2.字节流InputStream和OutputStream的子类分别有哪些？请举例说明其使用场景。与其对应的字符流分别有哪些？

(1).AudioInputStream :音频输入流是具有指定音频格式和长度的输入流。
e.g. 获取音频输入流的方式：

  AudioInputStream a = NULL;
  a = AudioSystem.getAudioInputStream(new File(fileName));//获取音频输入流

(2).ByteArrayInputStream&ByteArrayOutputStream :A ByteArrayInputStream包含一个内部缓冲区，其中包含可以从流中读取的字节。 内部计数器跟踪read方法要提供的下一个字节。
关闭ByteArrayInputStream没有任何效果。 在关闭流之后，可以调用此类中的方法，而不生成IOException 。
该类实现了将数据写入字节数组的输出流。 当数据写入缓冲区时，缓冲区会自动增长。 数据可以使用toByteArray()和toString() 。
关闭ByteArrayOutputStream没有任何效果。 该流中的方法可以在流关闭后调用，而不生成IOException 。
e.g.

import java.io.*;
public class ByteArrayStream {
     
   public static void main(String[] args){
     
     byte[] b = "hello".getBytes(); 
     ByteArrayInputStream bais = new ByteArrayInputStream(b); 
     int n =0;
     while((n = bais.read())!=-1){
     
        System.out.print((char)n); //hello
     }
   }
}


import java.io.*;
public class ByteArrayStream {
     
 public static void main(String[] args){
     
  byte[] b = "hello".getBytes(); 
  ByteArrayOutputStream baos = new ByteArrayOutputStream();
  baos.write(b, 0, b.length);
  System.out.println(new String(baos.toByteArray()));
 }
}

e.g. https://www.runoob.com/java/java-bytearrayinputstream.html

(3).FileInputStream(FileReader)& FileOutputStream(FileWriter) :
A FileInputStream从文件系统中的文件获取输入字节。 什么文件可用取决于主机环境。
FileInputStream用于读取诸如图像数据的原始字节流。 要阅读字符串，请考虑使用FileReader 。
文件输出流是用于将数据写入到输出流File或一个FileDescriptor 。 文件是否可用或可能被创建取决于底层平台。 特别是某些平台允许一次只能打开一个文件来写入一个FileOutputStream （或其他文件写入对象）。 在这种情况下，如果所涉及的文件已经打开，则此类中的构造函数将失败。
FileOutputStream用于写入诸如图像数据的原始字节流。 对于写入字符流，请考虑使用FileWriter 。
e.g.

package chap14_2;
import java.io.*;
public class OpenFile {
     
    public static void main(String args[]) throws IOException{
     
        try{
                                             //创建文件输入流对象
            FileInputStream  rf = new FileInputStream("OpenFile.java");
            int n=512,c=0;
            byte buffer[] = new byte[n];
            while ((c=rf.read(buffer,0,n))!=-1 ){
        //读取输入流
                System.out.print(new String(buffer,0,c));
            }            
            rf.close();                            //关闭输入流
        }
        catch (FileNotFoundException ffe){
     
            System.out.println(ffe);}
        catch (IOException ioe){
     
            System.out.println(ioe);
        }
    }
}

import java.io.*;
public class Write1 {
     
    public static void main(String args[]){
     
        try{
     
            System.out.print("Input: ");
            int count,n=512;
            byte buffer[] = new byte[n];
            count = System.in.read(buffer);        //读取标准输入流
            FileOutputStream  wf = new FileOutputStream("Write1.txt");
                                                   //创建文件输出流对象
            wf.write(buffer,0,count);              //写入输出流
            wf.close();                            //关闭输出流
            System.out.println("Save to Write1.txt!");
        }
        catch (FileNotFoundException ffe){
     
            System.out.println(ffe);}
        catch (IOException ioe){
     
            System.out.println(ioe);} }
}

(4).FilterInputStream(FilterReader)&FilterOutputStream(FilterWriter) :
FilterInputStream包含一些其他输入流，它用作其基本的数据源，可能会沿途转换数据或提供附加功能。 FilterInputStream本身简单地覆盖了所有InputStream的方法， InputStream版本将所有请求传递给包含的输入流。 FilterInputStream的FilterInputStream可以进一步覆盖这些方法中的一些，并且还可以提供附加的方法和领域。
这个类是过滤输出流的所有类的超类。 这些流位于已经存在的输出流（ 底层输出流） 之上 ，它使用它作为数据的基本接收器，但是可能沿着数据方向转换或提供附加功能。
类FilterOutputStream本身就简单地覆盖了所有OutputStream的方法， OutputStream版本将所有请求传递给底层输出流。 FilterOutputStream的FilterOutputStream可以进一步覆盖这些方法中的一些，并提供其他方法和字段。
注：不能访问 FilterInputStream 的构造方法，它是受保护的构造方法,但可以使用它的子类
FilterInputStream filter=new BufferedInputStream(fis);
(5).ObjectInputStream&ObjectOutputStream :序列化和反序列化，见问题5
(6).PipedInputStream(PipedReader)&PipedOutputStream(PipedWriter) :
管道输入流应连接到管道输出流; 管道输入流然后提供写入管道输出流的任何数据字节。 典型地，数据被从一个读PipedInputStream对象由一个线程并且数据被写入到对应的PipedOutputStream通过一些其它线程。 不建议尝试从单个线程使用这两个对象，因为它可能会使线程死锁。 管道输入流包含一个缓冲区，在读取操作中将读取操作与限制内的操作相分离。 的管道被认为是broken如果正在提供的数据字节到连接的管道输出流中的线程不再存活。
管道输出流可以连接到管道输入流以创建通信管道。 管道输出流是管道的发送端。 典型地，数据被写入到一个PipedOutputStream由一个线程对象和数据被从连接读取PipedInputStream通过一些其它线程。 不建议尝试从单个线程使用这两个对象，因为它可能会使线程死锁。 管被说成是broken如果从连接读取数据字节的螺纹管道输入流不再存活。
e.g.

import java.io.IOException;  
import java.io.PipedInputStream;  
import java.io.PipedOutputStream;  
public class PipedStream {
     
public static void main(String[] args) throws IOException {
       
      PipedInputStream in = new PipedInputStream();  
      PipedOutputStream out = new PipedOutputStream();  
      in.connect(out);  
      new Thread(new Input(in)).start();  
      new Thread(new Output(out)).start();  
    }  
} 

class Input implements Runnable{
        
    private PipedInputStream in;  
    public Input(PipedInputStream in) {
        
        this.in = in;  
    }  
    
    public void run() {
       
        byte []buf = new byte[1024];  
        int len;  
        try {
       
            len = in.read(buf);  
            String s = new String(buf,0,len);  
            System.out.println("in "+s);  
            in.close();  
        } catch (IOException e) {
       
              e.printStackTrace();  
        }   
    }  
  
      
} 
class Output implements Runnable{
       
private PipedOutputStream out;   
    public Output(PipedOutputStream out)   
    {
        
        this.out = out;  
    }  
    public void run() {
       
      try {
       
          out.write("hello".getBytes());  
      } 
      catch (IOException e) {
              
            e.printStackTrace();  
        }     
          
    }  
 
}

(7).PrintStream(PrintWriter) :见问题4
(8).DataInputStream&DataOutputStream :见问题4
(9).StringBufferInputStream ：已弃用
(10).BufferedInputStream(BufferedReader)&BufferedOutputStream(BufferedWriter) ：见问题4
(11).LineNumberInputStream(LineNumberReader) ：这个类是一个输入流过滤器，它提供了跟踪当前行号的附加功能。行是以回车符（’\r’）、换行符（’\n’）或紧跟换行符的回车字符结尾的字节序列。在所有三种情况下，行尾字符都作为一个换行符返回。行号从0开始，当读取返回换行符时，行号递增1。
(12).PushbackInputStream ：回退流
(13).SequenceInputStream ：A SequenceInputStream表示其他输入流的逻辑级联。 它从一个有序的输入流集合开始，从第一个读取到文件的结尾，然后从第二个文件读取，依此类推，直到最后一个输入流达到文件的结尾。

3.字节流与字符流的转化是怎样的？Java对此提供了哪些支持？
输入字节流转为字符流需要用到inputstreamReader的构造方法：
InputStreamReader(InputStream in)

输出字符流转为字节流用到OutputStreamWriter或PrintWriter的构造方法：
OutputStreamWriter(OutputStream out)
PrintWriter(OutputStream out)

4.Java中的过滤流（流的装配）有什么作用？请举例说明常用的过滤流。

(1).BufferedInputStream&BufferedOutputStream， 缓存作用，用于装配文件磁盘、网络设备、终端等读写开销大的节点流，提高读写性能

import java.io.*;
public class inDataSortMaxMinIn {
      
    public static void main(String args[]) {
     
     try{
     
        BufferedReader keyin = new BufferedReader(new 
                                     InputStreamReader(System.in)); 
        String c1;
        int i=0;
        int[] e = new int[10];   
        while(i<10){
     
           try{
     
               c1 = keyin.readLine();
               e[i] = Integer.parseInt(c1);
               i++;
            }  
            catch(NumberFormatException ee){
     
                   System.out.println("请输入正确的数字！");
            }
       }
    }
    catch(Exception e){
     
        System.out.println("系统有错误");
 }}}

(2).DataInputStream和DataOutputStream
可从字节流中写入、读取Java基本数据类型，不依赖于机器的具体数据类型，方便存储和恢复数据

import java.io.*;
public class DataStream {
     
  public static void main(String[] args)throws Exception{
     
   try {
     
    DataOutputStream dos = new DataOutputStream(new BufferedOutputStream(new 
                                          FileOutputStream("test.txt")));
    dos.writeInt(3);//写入整型
        dos.writeDouble(3.14);//写入浮点型
    dos.writeUTF(“hello”);//写入字符串
    dos.close();

    DataInputStream dis = new DataInputStream(new BufferedInputStream(new 
                                          FileInputStream("test.txt")));
    System.out.println(dis.readInt()); //读取整型，输出3
    System.out.println(dis.readDouble()); //读取浮点型，输出3.14
    System.out.println(dis.readUTF()); //读取字符串，输出hello
    dis.close();
   } catch (FileNotFoundException e) {
     
         e.printStackTrace();
    }
  }
}

(3).PrintWriter
可以向该字符流中写入Java基本数据类型，用于包装输出字符流类对象
局限性：没有对应的输入流类用于恢复写入的Java基本类型数据

import java.io.*;
public class PrintWrit {
     
  public static void main(String[] args)throws Exception{
     
    PrintWriter out = new PrintWriter(new BufferedWriter(new 
                                    FileWriter("foo.txt")));
//等价于PrintWriter out = new PrintWriter(“foo.txt”); //JDK5引入，简化编码，仍然具有缓存功能
    out.println(“hello”); //写入字符串
    out.println(3); //写入整型
    out.close(); //关闭流，系统自动将缓冲区内容flush
  }  
}

5.什么是对象的序列化和反序列化？Java对此提供了哪些支持？

序列化&反序列化 :将实现了Seriallizable接口的对象转换成一个字节序列，并能够在以后将这个字节序列完全恢复为原来的对象。

使用ObjectInputStream类和ObjectOutputStream类
e.g.

import java.io.*;
 public class Student implements Serializable {
      //序列化
    int number=1;
    String name;
    Student(int number,String n1) {
     
        this.number = number;
        this.name = n1;
    }
public static void main(String arg[]) {
     
        String fname = "Student.obj"; //文件名
        Student s1 = new Student(1,"Wang");
        s1.save(fname);
        s1.display(fname);
}



void save(String fname) {
     
    try{
     
            FileOutputStream fout = new FileOutputStream(fname);
            ObjectOutputStream out = new ObjectOutputStream(fout);
            out.writeObject(this);               //对象序列化
            out.close();
    }
    catch (FileNotFoundException fe){
     }
    catch (IOException ioe){
     }
}
void display(String fname) {
     
     try{
     
            FileInputStream fin = new FileInputStream(fname);
            ObjectInputStream in = new ObjectInputStream(fin);
            Student u1 = (Student)in.readObject();  //对象反序列化
            System.out.println(u1.getClass().getName()+"  "+
                                 u1.getClass().getInterfaces()[0]);
            System.out.println("  "+u1.number+"  "+u1.name);
            in.close();
     }
     catch (FileNotFoundException fe){
     }
     catch (IOException ioe){
     }
     catch (ClassNotFoundException ioe) {
     }
}

6.Java的File类表示什么？有什么作用？

File类是文件（或目录）路径名字的抽象表示,
可对文件进行相关的操作

7.Java对文件的读写分别提供了哪些支持？

读：FileInputStream，FileReader
写：FileOutputStream，FileWriter
提供对文件的随机访问支持：RandomAccessFile