第十三周Java作业-流

1.流的分类

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

2.字节流InputStream和OutputStream的子类

(1)AudioInputStream :音频输入流是具有指定音频格式和长度的输入流。

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

(2)ByteArrayInputStream&ByteArrayOutputStream

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); 
     }
   }
}

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()));
 }
}

(3)FileInputStream(FileReader)& FileOutputStream(FileWriter) 
A FileInputStream从文件系统中的文件获取输入字节。
FileInputStream用于读取诸如图像数据的原始字节流。

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);} }
}

3.字节流与字符流的转化

输入字节流转为字符流需要用到inputstreamReader的构造方法：
InputStreamReader(InputStream in)

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

4.过滤流

(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.对象的序列化和反序列化

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

使用ObjectInputStream类和ObjectOutputStream类

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

7.文件的读写

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