Java基础--------（6）IO流InputStream和OutputStream

一、概念

流是一种抽象概念，它代表了数据的无结构化传递。按照流的方式进行输入输出，数据被当成无结构的字节序或字符序列。从流中取得数据的操作称为提取操作，而向流中添加数据的操作称为插入操作。用来进行输入输出操作的流就称为IO流。换句话说，IO流就是以流的方式进行输入输出。

二、三种分类方式

按流的方向分为：输入流和输出流
按流的数据单位不同分为：字符流(Reader、Writer)  字节流(InputStream、OutputStream)
按流的功能不同分为：节点流和处理流

java.io.InputStream
抽象类，定义了输入流的读取字节方法，所有的字节输入流都继承自它。
java.io.OutputStream
抽象类，则是定义了输出流的输出字节方法，所有的字节输出流都继承自它。
java.io.Reader
抽象类，定义了输入流的读取字符方法，所有的字符输入流都继承自它。
java.io.Writer
抽象类，定义了输出流的输出字符方法，所有的字符输出流都继承自它。

三、流对象

1. FileInputStream 和FileOutputStream

   FileInputStream可以从文件系统中的文件获取输入字节。 什么文件可用取决于主机环境。
   FileOutputStream 文件输出流是用于将数据写入到输出流File或一个FileDescriptor 。 文件是否可用或可能被创建取决于底层平台。

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * 通过文件流复制文件
 */
public class FileInputStreamDemo{

    public static void main(String[] args) {
        //File file = new File("."+File.separator+"10G.rar");
        //File file2 = new File("."+File.separator+"b.rar");
        File file = new File("."+File.separator+"demo.txt");//通过file连接文件
        File file2 = new File("."+File.separator+"demo2.txt");
        if(!file2.exists()){
            try {
                file2.createNewFile();
            } catch (IOException e1) {
                e1.printStackTrace();
            }
        }else{
            file2.delete();
        }

        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            fis = new FileInputStream(file);//将file转为文件输入流
            fos = new FileOutputStream(file2);
            System.out.println(file.length());
            byte[] b = new byte[102400];
            int count = 0;
            int by=0;
            long start = System.currentTimeMillis();
            while((by=fis.read(b))!=-1){//将数据读取到byte数组中
                count++;
                fos.write(b,0,by);//写入数据
            }
            long end = System.currentTimeMillis();
            System.out.println(count+"次");
            System.out.println(file2.length());
            System.out.println("所用时间"+(end-start));

        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            if(fis!=null)
            try {
                    fis.close();//关流
                } catch (IOException e) {
                    e.printStackTrace();
                }
            if(fos!=null)
                try {
                    fos.close();//关流
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
        }

    }
}

2.PipedInputStream 和 PipedOutputStream
管道流是用来在多个线程之间进行信息传递的Java的流，管道输出流可以连接到管道输入流以创建通信管道，而且并不建议尝试从单个线程使用这两个对象，因为它可能会使线程死锁。

pos = new PipedOutputStream(); //创建未连接的输出流
pis = new PipedInputStream(pos);//创建连接的输入流

如果是单线程使用，read这个同步方法会导致线程死锁

pis.read(b2,0,b2.length);//该方法会阻塞,直到至少有1字节可用，或者已经检测到流的结束，或者抛出异常

3.FilterInputStream 和 FilterOutputStream
Filter流用于封装其它的输入流，并为它们提供额外的功能，主要的子类有

LineNumberInputStream（已弃用）
DataInputStream（数据输入流）

允许应用程序以独立于机器的方式从底层输入流读取原始Java数据类型。 应用程序使用数据输出流来写入稍后可以被数据输入流读取的数据。
DataInputStream对于多线程访问来说不一定是安全的。 线程安全是可选的

BufferedInputStream（缓冲输入流）
当创建BufferedInputStream时，将创建一个内部缓冲区数组。 当从流中读取或跳过字节时，内部缓冲区将根据需要从所包含的输入流中重新填充，一次有多个字节。 mark操作会记住输入流中的一点，并且reset操作会导致从最近的mark操作之后读取的所有字节在从包含的输入流中取出新的字节之前重新读取。

PushbackInputStream(回退流)
它能允许我们我们读取流中数据，后再将它们返回（回推）到流中。可以获取来自输入流的内容而不对它们进行破坏。

4.ByteArrayInputStream 和 ByteArrayOutputStream

字节数组流，它包含一个内部缓冲区，该缓冲区包含从流中读取的字节

5.SequenceInputStream 和 SequenceOutputStream

SequenceInputStream表示其他输入流的逻辑级联。 它从一个有序的输入流集合开始，从第一个读取到文件的结尾，然后从第二个文件读取，依此类推，直到最后一个输入流达到文件的结尾。

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.SequenceInputStream;

import com.sun.xml.internal.messaging.saaj.util.ByteInputStream;


public class SequenceInputStreamDemo {

    public static void main(String[] args) {
        FileInputStream s1=null;
        ByteInputStream s2=null;
        try {
            s1 = new FileInputStream("."+File.separator+"demo.txt");
            String str="哈哈哈哈";
            byte[] b = str.getBytes();
            s2 = new ByteInputStream(b,b.length);
            FileOutputStream fos =  new  FileOutputStream("."+File.separator+"4.txt" ); 
            SequenceInputStream sis = new SequenceInputStream(s1, s2);
             byte [] buf =  new byte [ 1024 ];   
                int  len =  0 ;  
                while ((len = sis.read(buf))!= - 1 ){  
                    fos.write(buf,0,len);  
                }  
            s1.close();
            s2.close();
            fos.close();

        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}

5.ObjectInputStream 和 ObjectOutputStream

对象流，ObjectOutputStream将Java对象的原始数据类型和图形写入OutputStream。 可以使用ObjectInputStream读取（重构）对象。 可以通过使用流的文件来实现对象的持久存储。 如果流是网络套接字流，则可以在另一个主机上或另一个进程中重构对象。 ObjectInputStream用于恢复先前序列化的对象。 其他用途包括使用套接字流在主机之间传递对象，或者在远程通信系统中进行封送和解组参数和参数。
ObjectInputStream只能从流中读取支持java.io.Serializable或java.io.Externalizable接口的对象。

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class ObjectInputStreamDemo {

    public static void main(String[] args) {


        FileOutputStream fos = null;
        ObjectOutputStream oos = null;
        FileInputStream fis = null;
        ObjectInputStream ois = null;
        try {
            Aoo a = new Aoo("小明",20,"太原");

            fos = new FileOutputStream("."+File.separator+"Object.txt");
            oos = new ObjectOutputStream(fos);
            oos.writeObject(a);

            fis = new FileInputStream("."+File.separator+"Object.txt");
            ois = new ObjectInputStream(fis);
            Aoo a1 = (Aoo) ois.readObject();
            System.out.println(a1);

            fos.close();
            fis.close();
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
}