Java--IO流

一、流的概念

1、流的概念：Java对流是用对象方式处理的，具体的说，流对象就是数据传输的管道。

2、输入流和输出流

• 读或输入：把数据从外部通过输入流对象传输到内部

内部—可以是内存，可以是数组、变量、对象等

外部：可以是文件、键盘、网络等

• 写或输出：把数据从内部通过输出流对象传输到外部

流一般分为输入流和输出流两类，但这种划分不是绝对的。例如，一个文件，在读取它的数据时，它就是输入流；而在保存数据到文件时，它就是一个输出流

4、文本文件和二进制文件

• 文本文件 ：把内存中的数据以字符的形式存放的文件叫文本文件。键盘和显示器也属于文本文件

优点：可见

缺点：由于文件的数据存储方式和内存不同需要转换，影响效率

• 二进制文件 ：直接把内存中的数据存放在文件中，这样的文件叫二进制文件

优点：由于二进制文件的数据存储方式和内存相同不需要转换，执行效率较高

缺点：不可见

二、字节流

2.1、概念

1、流对象的种类：从整体可以划分为字节流和字符流

• 字节流：一次传输一个字节的数据
• 字符流：一次传输一个字符的数据（需从字节流转换）

2、基类

Java中每一个字节流的基本功能依赖于基本类 InputStream 和 OutputStream ，它们都是抽象类，不能直接使用。

• InputStream类的方法有：

read（）：从流中读入数据

skip（）：跳过流中若干字节数

available() ： 返回流中可用字节数

mark（） ： 在流中标记一个位置

reset（） ： 返回标记过的位置

markSupport（） ： 是否支持标记和复位操作

close（） ： 关闭流

• OutputStream类的方法有：

write() ： 将数据输出到流中

flush（）： 刷空输出流，并将缓冲区中的数据强制送出

close（）：关闭流

2.2、文件流

1、使用代码：

从file1.text读取内容写入到file2.text

import java.io.*;

  public class Filestream
 {
    public static void main(String args[])
    {
        try
        {
             File inFile=new File("file1.txt");
             File outFile=new File("file2.txt");
             FileInputStream fis=new FileInputStream(inFile);
             FileOutputStream fos=new  FileOutputStream(outFile);
	         int c;
             while((c=fis.read())!=-1)
             {System.err.println(c);
             fos.write(c);
             }
             fis.close();
             fos.close();
	    }catch(FileNotFoundException e) {//InputStream用来打开一个输入文件，若要打开文件不存在，会产生异常
           System.out.println("FileStreamsTest: "+e);
	    }catch(IOException e) {//在进行读/写操作时可能会有IO异常发生，必须捕获
	    System.err.println("FileStreamsTest: "+e);
	     }
    }
}

File inFile=new File(“file1.txt”);

创建文件对象

FileInputStream fis=new FileInputStream(inFile);

创建文件输入流，用来打开指定的输入文件。当输入文件不存在时会报异常

FileOutputStream fos=new FileOutputStream(outFile);

创建文件输出流，用来打开指定的输出文件。当输出文件不存在时，会新建这个名字的输出文件

fis.read()

读取输入文件的数据

fos.write©;

将数据写入到文件中

2、随机流

对于InputStream和OutputStream来说，它们的实例都是顺序访问流，即只能进行顺序读/写。而类RandomAccessFile则允许对文件内容同时完成读和写操作，它直接继承object ，并且同时实现了接口DataInput和DataOutput，提供了支持随机文件操作的方法：

• readXXX()或writeXXX()： 如ReadInt(), ReadLine(), WriteChar(), WriteDouble()等。
• int skipBytes(int n)：将指针向下移动若干字节
• length()：返回文件长度
• long getFilePointer()：返回指针当前位置
• void seek(long pos)：将指针调到所需位置

在生成一个随机文件对象时，除了要指明文件对象和文件名之外，还需要指明访问文件的模式。

import java.io.*;
public class random_file
{
    public static void main(String args[])
    {
       int[] data_arr = {12,31,56,23,27,1,43,65,4,99};
        try            //99,4,65,43,1,27,23,56,31,12
         {
          RandomAccessFile randf = new RandomAccessFile("temp.dat","rw");
           for (int i = 0; i < data_arr.length; i++) {
               //将数组元素写到二进制文件
               randf.writeInt(data_arr[i]);
           }

           for(int i=data_arr.length-1; i>=0; i--)
            {
                //调节指针位置  一个元素占用4个字节 ，读的是二进制文件
                randf.seek(i*4);//9*4=36，从最后一个元素开始读，这就是倒着把数组读出来
                System.out.println(randf.readInt());
            }

           //读完后指针指向12
            randf.seek(8); //12  指针调8个字节---2个元素
            System.out.println(randf.readInt());//56
            System.out.println(randf.readInt());//23

            randf.skipBytes(8);//23，跳过八个字节，跳过两个元素
            System.out.println(randf.readInt()); //43
            randf.close();
          }catch (IOException e){
             System.out.println("File access error: "+e);
          }
    }
}

2.3、过滤流

也就是套接流，需要套接其他的流才能使用

• java.io中提供类FilterInputStream和FilterOutputStream分别对其他输入/输出流进行特殊处理，它们在读/写数据的同时可以对数据进行特殊处理。另外还提供了同步机制，使得某一时刻只有一个线程可以访问一个输入/输出流。
  • 要使用过滤流，首先必须把它连接到某个输入/输出流上，通常在构造方法的参数中指定所要连接的流 ：FilterInputStream(InputStream in); FilterOutputStream(OutputStream out);

1、缓冲流

BufferedInputStream 和 BufferedOutputStream

• 为输入和输出流创建和维持缓冲

• 缓冲是一种提高读写效率的机制

• 将缓冲流与文件流相接

• 字节缓冲流采用了装饰器模式来增强InputStream、OutputStream子类对象的功能

例如，通过BufferedInputStream增强FileInputStream的功能

BufferedInputStream bufferedInputStream = new BufferedInputStream(newFileInputStream("input.txt"));

• 字节缓冲流如何提高性能？

主要体现在调用write（）和read（）方法的时候，由于字节缓冲流内部有缓冲区（字节数组），因此，字节缓冲流会先将读取到的字节存放在缓冲区，大幅减少io操作，提高读取效率。

FileInputStream in = new   FileInputStream(“file1.txt”);

FileOutputStream out = new FileOutputStream (“file2.txt”);

//套接。将文件流in套接缓存流，还可以设置缓冲区的大小

BufferedInputStream bin = new BufferedInputStream(in,256) 

BufferedOutputStream bout = new BufferedOutputStream(out,256);

int len;

byte bArray[]=new byte[256];

len=bin.read(bArray);  //len中得到是长度, bArray中得到的是数据

2、数据流

数据流类DataInputStream和DataOutputStream的处理对象除了是字节或字节数组外，还可以实现对文件的不同数据类型的读写。

• 数据流可以通过如下方式建立

FileInputStream fis = new  FileInputStream("file1.txt");
FileOutputStream fos = new  FileOutputStream("file2.txt");
DataInputStream dis = new DataInputStream(fis);
DataOutputStream dos = new DataOutputStream(fos);

可以用readLine()方法读取一行信息。适合于文本文件。

2.4、标准流

1、标准流

java.lang包中的System类管理标准输入/输出流和错误流

• System.in ，为InputStream类对象，用于从标准输入设备中获取输入数据（通常是键盘）
• System.out，为PrintStream类对象，把输出送到缺省的显示设备（通常是显示器）
• System.err，也为PrintStream类对象，把错误信息送到缺省的显示设备

每当main方法被执行，就自动生成上述三个对象

//类 System字段 In “标准”输入流。 
class System{
public static final InputStream in  //“标准”输入流。 
public static final PrintStream out //"标准”输出流 
public static final PrintStream err //“标准”错误流
  
}

System类中，是用静态final修饰，输入流、输出流、错误流

• static：静态变量。可以直接通过类System调用。这就是为什么后面使用可以直接System.in
• final：被final修饰的变量，需要赋值并且一旦赋值不能改变。在这里是如何赋值呢？

创建InputStream对象，通过底层，将对象set进变量in里，所以in里包含InputStream对象

2.5、对象流

1、对象流

• 对象的持续性

能够记录自己的状态以便将来再生的能力，叫对象的持续性

• 对象的串行化（序列化）

对象通过写出描述自己状态的数值来记录自己的过程叫串行化。

• 对象流

能够输入输出对象的流称为对象流。可以将对象串行化后通过输入输出流写入文件或传送到其他地方

只有实现Serializable接口的类才能被串行化，Serializable接口中没有任何方法，当一个类声明实现Seriazable接口时，只是表明该类加入对象串行化协议。

如：

public class Student implements Serializable
{
  int id;
  String name;
  int age;
  String department;

  public Student()
	{System.out.println("无参构造方法被调用");}

  public Student(int id, String name, int age, String department)
  {  System.out.println("有参构造方法被调用");
     this.id = id;
     this.name = name;
     this.age = age;
     this.department = department;
  }

  @Override
  public String toString(){
  	return "id = " + id + " name = " + name+" age = " + age+" department = " + department;
  }
}

Student类实现了Serializable接口 ，表明该类可以被序列化----保存对象的状态

2、序列化

代码如下：

public class TestStudent
{
     public static void main(String[] args){
     	 Student t = new Student(123, "李华", 23, "开发部门");

     	 try{
    	    FileOutputStream fout = new FileOutputStream("student.data");
    	    ObjectOutputStream out = new ObjectOutputStream(fout);

    	    out.writeObject(t);

    	    out.close();
    	    fout.close();
    	}catch(FileNotFoundException e){//文件不存在抛出异常
    	    System.out.println("File Not Found!");
    	}catch(IOException e){//传输过程中io问题抛出异常
    	    System.out.println("I/O Error!");
    	}
     }
}

将把对象的状态保存到网络或者二进制文件中： 条件如下

• 这个对象的类要实现序列化协议（实现Serializable接口）
• 创建类的对象，并给对象的属性赋值。—创建对象的状态
• 先创建一个文件输出流，再套接在对象输出流上。
• 将t所指的对象的状态 ，通过对象输出流，输出到student.txt文件中

序列化就是将对象的状态通过输出流写入到一个二进制文件的过程

3、反序列化

代码如下：

public class TestStudent1
{
     public static void main(String[] args){
     	 try{
    	    FileInputStream fin = new FileInputStream("student.data");
    	    ObjectInputStream in = new ObjectInputStream(fin);

    	    Student t = (Student)in.readObject();
    	    System.out.println("Student : " + t);
    	    in.close();
    	    fin.close();
    	}catch(FileNotFoundException e){
    	    System.out.println("File Not Found!");
    	}catch(ClassNotFoundException e){
    	    System.out.println("ClassNotFoundException!");
    	}catch(IOException e){
    	    System.out.println("I/O Error!");
    	}catch(Exception e){
    	    System.out.println("I/O Error!");
    	}
     }
}

从二进制文件中读取对象的状态（属性值）

• 创建文件输入流，指向存放对象状态的文件，再创建对象输入流套接在文件输入流
• 从流所指的二进制文件中读取对象的状态，再生出对象。
• 这也是创建对象，但是并没有调用构造方法来创建

反序列化就是指从流所指的文件中读取对象的状态

4、注意：

• 串行化只能保存对象的非静态成员变量，而不能保存任何成员方法和静态成员变量，并且保存的只是变量的值，对于变量的任何修饰符都不能保存。
• 对于某些类型的对象，状态是瞬时的，这样的对象无法保存其对象，如Thread对象和流对象。对于这样的变量必须用transient关键字 。加上这个关键字的成员变量都不会被保存。
• 串行化可能涉及将对象存放到磁盘上或在网络上发送数据，这会带来安全问题，所以对于一些需要保密的数据，不应保存在永久介质中，为了保证安全，应在这些变量前加上tranient关键字

5、目前学到的三种创建对象方法：

• 通过new来创建对象–调用构造方法
• 通过反射来创建关联类的对象 --调用无参构造方法
• 通过反序列化来创建对象—不调用构造方法

2.6、管道流

1、管道用来把一个程序、线程和代码块的输出连接到另一个程序、线程和代码块的输入。java.io中提供了类PipedInputStream和PipedOutputStream 作为管道的输入/输出流。

2、实现生产者和消费者模式

/**
 * 用管道模拟生产者和消费者线程
 */
public class ThreadWork {
    public static void main(String[] args) throws IOException {
        //创建管道输出流
        PipedOutputStream pos = new PipedOutputStream();
        //创建管道输入流，并和输出流管道连接
        PipedInputStream pis = new PipedInputStream(pos);

        //创建两个线程
        PipeProducer producer = new PipeProducer(pos, "生产者线程");
        PipeConsumer consumer = new PipeConsumer(pis, "消费者线程");
        producer.start();
        consumer.start();


    }

}

/**
 * 生产者线程,与输出流有关
 */
class PipeProducer extends Thread{
    private PipedOutputStream pos;
    public PipeProducer(PipedOutputStream pos,String name){
        super(name);
        this.pos = pos;

    }

    @Override
    public void run(){
        int i = 0;
        try {
          while (true){
              Thread.sleep(2000);
              if (i==0){
                  i=1;
                  System.out.println(Thread.currentThread().getName()+"生产："+i);
                  pos.write(i);
              }else {
                  pos.close();
                  break;

              }

          }

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

}

/**
 * 消费者线程（与管道输入流）
 */
class PipeConsumer extends Thread{
    private PipedInputStream pis;
    public PipeConsumer(PipedInputStream pis,String name){
        super(name);
        this.pis = pis;
    }

    @Override
    public void run(){
        try{
            while (true){
                int i = pis.read();
                if (i==1){
                    System.out.println(Thread.currentThread().getName()+"消费了"+i);
                    i=0;
                }else {
                    pis.close();
                    break;
                }

            }

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

    }

}

2.7、顺序输入流

将多个不同的输入流统一为一个输入流。

FileInputStream f1,f2;
String s;
f1 = new FileInputStream(“file1.txt”);
f2 = new FileInputStream(“file2.txt”);
SequenceInputStream fs = new SequenceInputStream(f1, f2);
DataInputStream ds = new DataInputStream(fs);
while( (s = ds.readLine()) != null )
   System.out.println(s);

只适用于连接多个文件输入流

三、字符流

为什么I/O操作要分字节流和字符流？

• 字符流是由Java虚拟机将字节转换得到的，这个过程比较耗时
• 如果不知道编码类型用字节流很容易出现乱码

因此直接加入用于字符流处理的类

1、从jdk1.1开始，java.io包中加入了专门用于字符流处理的类，它们是以Reader和Writer为基础派生的一系列类

2、InputStreamReader和OutputStreamWriter 是java.io包中用于处理字符流的最基本的类，用来在字节流和字符流之间作为中介。

3、同样提供了字符流的缓冲流。java.io中也提供了缓冲流BufferedReader和BufferedWriter。其构造方法与BufferedInputStream和BufferedOutputStream相类似。另外，除了read()和write()方法外，它还提供了整行字符处理方法。

class FileTOUnicode 
{
   public static void main(String args[])
   {
        try
        {
          //文件输入流
             FileInputStream fis = new FileInputStream(“file1.txt");
             //字符输入流                                          
             InputStreamReader dis = new InputStreamReader(fis);
             // InputStreamReader dis = new InputStreamReader(System.in);
             BufferedReader reader = new BufferedReader(dis);
             String s;
             while( (s = reader.readLine()) != null )  
             {
                 System.out.println("read: "+s);
             }
             dis.close();
         }catch(IOException e)
         {
             System.out.println(e);
         }
   }//main()
}//class

4、其他字符流

• 对字符数组进行处理：CharArrayReader ， CharArrayWriter
• 对文本文件进行处理：FileReader,FileWriter
• 对字符串进行处理：StringReader ，StringWriter
• 过滤字符流：FilterReader，FilterWriter
• 管道字符流：PipedReader，PipedWriter
• 行处理字符流：LineNumberReader
• 打印字符流：PrintWriter

四、Java IO 设计模式总结

1、装饰器模式

装饰器模式通过组合替代继承来扩展原始类的功能 ，在一些继承关系比较复杂的场景（IO 这一场景各种类的继承关系就比较复杂）更加实用。

如，对于字节流来说，FilterInputStream和FilterOutStream是装饰器的核心，分别用于增强InputStream和OutputStream子类对象的功能

例如，字节缓冲流、对象流等都是用来增强InputStream和OutputStream子类对象的功能

• 通过BufferInputStream（）来增强FileInputStream的功能

BufferedInputStream bufferedInputStream = new BufferedInputStream(newFileInputStream("input.txt"));

IO操作中像这样用到装饰器模式的地方还有很多。

2、适配器模式

适配器（Adapter Pattern）模式 主要用于接口互不兼容的类的协调工作，你可以将其联想到我们日常经常使用的电源适配器。

适配器模式中存在被适配的对象或者类称为 适配者(Adaptee) ，作用于适配者的对象或者类称为适配器(Adapter) 。适配器分为对象适配器和类适配器。类适配器使用继承关系来实现，对象适配器使用组合关系来实现。

• 在IO流中，字符流和字节流的接口不同，但他们之间可以互相转换，他们之间的协调工作就是通过适配器模式来做的。通过适配器，我们可以将字节流对象适配成一个字符流对象 ，这样我们可以直接通过字节流对象来读取或者写入字符数据。

//InputStreamReader是适配器，FileInputStream是被适配的类--适配者
InputStreamReader isr = new InputStreamReader(new FileInputStream(fileName),"UTF-8");

五、小结

1、在Java中有数据传输的地方都用到I/O流(通常是文件,网络,内存和标准输入输出等)。

2、InputStream 和OutputStream是所有字节流的祖先(只有RandomAccessFile类是一个例外 )，read和write是它们最基本的方法，读写单位是字节。

3、Reader 和Writer是所有字符流的祖先，read和write是它们最基本的方法，读写单位是字符。

4、File, File(Input/Output)Stream, RandomAccessFile是处理本地文件的类。

5、Data(Input/Output)Stream是一个过滤流的子类（套接流），借此可以读写各种基本数据 ，在文件和网络中经常使用。如: readByte， writeBoolean等。