概念

同步: 线程在发起调用时, 需要等待任务处理结果, 才能继续干别的事情


用户去收快递, 快递小哥哥不在, 等在这里, 直到快递小哥哥回来, 给一个结果


异步: 线程在处理任务时, 不需要等待任务结果, 当任务完成后会主动通知线程


用户去收快递, 快递小哥哥不在, 贴个纸条, 快递小哥哥回来看到, 主动给用户打电话, 告知快递结果


阻塞: 在读取处理套接字时, 线程将会被挂起, 直到数据读取完成


去收快递, 快递还没到, 就等在那里, 什么事情也干不了, 直到收到快递为止


非阻塞: 在读取套接字时, 无论有无数据, 函数会立即返回


去收快递, 快递还没到, 先去干别的事情, 等会再来看看

同步阻塞IO
Java中提供的标准IO输入输出, 同步IO, 一个数据流即需要一个线程去读取, 此时, 线程将会等待数据流准备时间, 如果未准备好, 则需要一直阻塞, 可以采取线程池的方式对该读取方式进行优化
@Test
fun testBlockingIO() {
    val serverSocket = ServerSocket(9000)
    println("server: 服务端启动,等待连接...")
    // 启动客户端线程
    Thread {
        println("client: 开始连接服务端...")
        // 指定服务端地址及端口
        val socket = Socket("localhost", 9000)
        val input = DataInputStream(socket.getInputStream())
        val output = DataOutputStream(socket.getOutputStream())
        println("client: 处理3秒钟")
        Thread.sleep(3000)
        println("client: 发送消息")
        output.writeUTF("hello server!")
        output.flush()
        println("client: 接收数据[${input.readUTF()}]")\
    }.start()
    // 服务器阻塞5秒钟, 等待客户端连接
    val socket = serverSocket.accept()
    println("server: 有客户端连接了")
    val input = DataInputStream(socket.getInputStream())
    val output = DataOutputStream(socket.getOutputStream())
    println("server: 接收数据[${input.readUTF()}]")
    println("server: 服务处理5秒钟...")
    Thread.sleep(5000L)
    println("server: 发送消息")
    output.writeUTF("hello client!")
    output.flush()
}

运行结果
server: 服务端启动,等待连接...
client: 开始连接服务端...
server: 有客户端连接了
client: 处理3秒钟
client: 发送消息
server: 接收数据[hello server!]
server: 服务处理5秒钟...
server: 发送消息
client: 接收数据[hello client!]

上述程序, 在执行 readLine() 读取的时候, 当还未传输完数据时, 线程均处于等待状态, 直到有数据过来
有同学可能在写IO操作的时候, 会遇到读取不到数据的状况, 一直阻塞, 解决办法可以有如下几种:

中断输入流, 即 socket.shutdownOutput(), 此时, 从该socket里读取任何内容都是-1, 即认为达到流的结尾, 程序返回. 此种方法固然可以解决这个问题, 但是却造成socket只通讯了一次就关闭了, 无法实现持续的通讯
利用结尾字符标记的方式, 如示例代码中, 读取采用readLine(), readLine() 当读取到 \n 字符会直接返回, 所以在发送的时候在结尾增加了\n字符, 这时即可实现循环消息读取
原理同上, 使用 DataInputStream和DataOutputStream, 在写入的时候使用writeUTF(), 读取的时候使用readUTF()

同步非阻塞IO
示例代码如下, 与普通IO最大的区别在于, 当去读取IO数据时, 无论数据有没有准备好, 会立即返回, 线程需要不断的轮询去查看socket是否准备好, 相对于同步阻塞IO, 线程不用等在那里等待IO就绪, 但同时浪费了大量cpu的轮询时间
@Test
fun testNonBlockingIO(){
    // 服务端
    val channel = DatagramChannel.open().apply {
        configureBlocking(false) // 非阻塞
        bind(InetSocketAddress(9000)) // 绑定端口
    }
    Thread {
        Thread.sleep(5000)
        val datagramChannel = DatagramChannel.open().apply {
            connect(InetSocketAddress("localhost", 9000))
        }
        println("client: 发送数据了")
        datagramChannel.write(ByteBuffer.wrap("hello nio server".toByteArray()))
    }.start()
    while(true){
        val byteBuffer = ByteBuffer.allocate(1024)
        if(channel.receive(byteBuffer) !== null ) {
            val length = byteBuffer.position()
            byteBuffer.flip()
            val data = ByteArray(length).apply {
                System.arraycopy(byteBuffer.array(), 0, this, 0, length)
            }
            println("server: 接收到数据 - [${String(data)}]")
            break;
        } else {
            println("server: 没有读取到数据, 休眠3秒再试试")
            Thread.sleep(3000)
        }
    }
}

运行结果
server: 没有读取到数据, 休眠3秒再试试
server: 没有读取到数据, 休眠3秒再试试
client: 发送数据了
server: 接收到数据 - [hello nio server]
server: 没有读取到数据, 休眠3秒再试试

IO多路复用
I/O多路复用是通过一种机制，可以监视多个描述符，一旦某个描述符就绪（一般是读就绪或者写就绪），能够通知程序进行相应的读写操作
Java中NIO中的几个部件: Channel(通道), Buffer(缓冲区), Selector(监视器)

client与服务端通过Channel.Socket 进行连接, 数据传送至 Buffer区域, 当该区域可读时, 监视器捕获该事件, 读取并处理数据(当selector注册为 OP_READ)
与同步非阻塞IO的最大区别在于, 线程不用不断的轮询去查看io是否就绪, 而是改为等待在那里, 当io就绪后, 主动通知线程去处理, 节省了cpu轮询时间; 代码上主要引入了Selector(监视器)
废话不多说, 示例代码为 udp 通讯的 nio 实现:
@Test
fun testSelectorSocket(){
    // 服务端
    val channel = DatagramChannel.open().apply {
        configureBlocking(false) // 非阻塞
        socket().reuseAddress = true  // 地址重用
        bind(InetSocketAddress(9000)) // 绑定端口
    }
    val selector = Selector.open()
    // 注册为 OP_READ 事件
    channel.register(selector, SelectionKey.OP_READ)
    // 启动发包线程
    Thread {
        for(i in 0..10) {

            val datagramChannel = DatagramChannel.open().apply {
                connect(InetSocketAddress("localhost", 9000))
            }
            datagramChannel.write(ByteBuffer.wrap("hello nio server $i".toByteArray()))
            val byteBuffer = ByteBuffer.allocate(1024)
            if (datagramChannel.receive(byteBuffer) !== null) {
                val length = byteBuffer.position()
                byteBuffer.flip()
                val data = ByteArray(length).apply {
                    System.arraycopy(byteBuffer.array(), 0, this, 0, length)
                }

                println("client: 接收到数据 - [${String(data)}]")
            }
            Thread.sleep(2000L * i * 2)
        }
    }.start()
    // 服务端监听
    while(true) {
        // 当有可读取的通道之前,该方法会一直阻塞, 阻塞超过5秒钟, 执行其他操作, 不设置则一直阻塞
        if(selector.select(5000) > 0) {
            val iterator = selector.selectedKeys().iterator()
            iterator.forEach {
                if(it.isValid && it.isReadable){
                    val datagramChannel = it.channel() as DatagramChannel
                    val byteBuffer = ByteBuffer.allocate(1024)
                    var socketAddress: SocketAddress? = null
                    if(datagramChannel.receive(byteBuffer).let { socketAddress = it; it } !== null) {
                        // 数据读取到bytebuffer后, position指向结尾处
                        val length = byteBuffer.position()
                        // position将会指向数据的起始位置
                        byteBuffer.flip()
                        val data = ByteArray(length).apply {
                            System.arraycopy(byteBuffer.array(), 0, this, 0, length)
                        }

                        println("server: 接收到数据 - [${String(data)}]")

                        datagramChannel.send(ByteBuffer.wrap("hello nio client".toByteArray()), socketAddress)
                    }
                }
                iterator.remove()
            }
        }
        println("处理完一轮了, 再去看看有没有消息")
    }
}

运行结果
server: 接收到数据 - [hello nio server 0]
处理完一轮了, 再去看看有没有消息
client: 接收到数据 - [hello nio client]
server: 接收到数据 - [hello nio server 1]
处理完一轮了, 再去看看有没有消息
client: 接收到数据 - [hello nio client]
server: 接收到数据 - [hello nio server 2]
处理完一轮了, 再去看看有没有消息
client: 接收到数据 - [hello nio client]
处理完一轮了, 再去看看有没有消息
...

上述例子中, 服务端会对接入的socket进行监听, 当socket就绪并且可读时, 则select()方法会返回, 在本例中, 设置了select(5000)超时时间
AIO(Asynchronous IO) 异步非阻塞IO
主要融合了Java的Future模式, 提供了回调的方式, 当调用阻塞操作时, 启用子线程去处理, 处理完成后, 回调后续的业务操作, 注意, 此时的线程不再是之前主线程, 如果想保持在主线程中执行后续的业务逻辑, 则可以使用 future.get() 方式, 使得主线程阻塞直到任务完成
示例代码如下:
@Test
fun testAIO() {
    val channel = AsynchronousServerSocketChannel.open().apply {
        bind(InetSocketAddress(9000)) // 绑定端口
    }
    // 异步处理 accept 事件
    class AcceptHandler(serverSocketChannel: AsynchronousServerSocketChannel)
        : CompletionHandler<AsynchronousSocketChannel, Nothing?> {
        override fun completed(socketChannel: AsynchronousSocketChannel, attachment: Nothing?) {
            println("server: 有client接入了 - $socketChannel")
            // 或使用 write(ByteArray byteArray, A attachment, CompletionHandler<Long,? super A> handler); 异步触发消息发送完毕事件
            socketChannel.write(ByteBuffer.wrap("hello client!".toByteArray())).get()
        }
        override fun failed(exc: Throwable?, attachment: Nothing?) {
        }
    }
    channel.accept(null, AcceptHandler(channel))

    // AIO Client
    val byteBuffer = ByteBuffer.allocate(1024)
    val socketChannel = AsynchronousSocketChannel.open().apply {
        connect(InetSocketAddress("localhost", 9000)).get()
    }
    // 可指定超时时间, 使用 CompletionHandler 异步获取执行结果
    socketChannel.read(byteBuffer).get()
    val length = byteBuffer.position()
    byteBuffer.flip()
    val data = ByteArray(length)
    System.arraycopy(byteBuffer.array(), 0, data, 0, length)
    println("client: 接收到数据 - ${String(data)}")
}

也可指定线程池处理运行回调业务:
...
val channelGroup = AsynchronousChannelGroup
                .withThreadPool(Executors.newFixedThreadPool(20))
AsynchronousSocketChannel.open(channelGroup)  
...   

最后
io是计算机世界中一个重要概念, 关系着系统的性能以及吞吐量, 本文对java中的几种IO模式进行了简单总结, 不是很全面, 包括涉及的socket和多线程相关的知识, 后续慢慢整理出来, 有什么理解错误的地方, 欢迎大家拍砖
为了方便运行, 示例代码均在一个函数内, 使用kotlin语言编写

文章目录
java中IO流分为几种？
1、IO流概念
2、IO流分类
3、IO流具体分类
按操作方式分类
按操作对象分类

java中IO流分为几种？
1、IO流概念
流是从一端到另一端，连接了源头和目的地。

IO流可以理解为连接程序与文件/数组/网络连接/数据库。
2、IO流分类
（1）按流向分类：

输入流

输出流

（2）按处理数据不同分类：

字节流：二进制，可以处理一切文件，包括：纯文本、doc、音频、视频等。

字符流：文本文件，只能处理纯文本。

（3）按功能不同分类：

节点流：包裹源头。

处理流：增强功能，提高性能。
3、IO流具体分类

按操作方式分类

按操作对象分类


一般操作流的步骤：

（1）创建源

（2）选择流

（3）操作流（读取|写出）

（4）释放资源
推荐相关文章：

IO流实现文件的读取与写出，文件、文件夹的拷贝

 


 

一.什么是IO



      Java中I/O操作主要是指使用Java进行输入，输出操作. Java所有的I/O机制都是基于数据流进行输入输出，这些数据流表示了字符或者字节数据的流动序列。Java的I/O流提供了读写数据的标准方法。任何Java中表示数据源的对象都会提供以数据流的方式读写它的数据的方法。  

       Java.io是大多数面向数据流的输入/输出类的主要软件包。此外，Java也对块传输提供支持，在核心库 java.nio中采用的便是块IO。

　　流IO的好处是简单易用，缺点是效率较低。块IO效率很高，但编程比较复杂。 

      Java IO模型  :

      Java的IO模型设计非常优秀，它使用Decorator模式，按功能划分Stream，您可以动态装配这些Stream，以便获得您需要的功能。例如，您需要一个具有缓冲的文件输入流，则应当组合使用FileInputStream和BufferedInputStream。


 

二.数据流的基本概念


        数据流是一串连续不断的数据的集合，就象水管里的水流，在水管的一端一点一点地供水，而在水管的另一端看到的是一股连续不断的水流。数据写入程序可以是一段、一段地向数据流管道中写入数据，这些数据段会按先后顺序形成一个长的数据流。对数据读取程序来说，看不到数据流在写入时的分段情况，每次可以读取其中的任意长度的数据，但只能先读取前面的数据后，再读取后面的数据。不管写入时是将数据分多次写入，还是作为一个整体一次写入，读取时的效果都是完全一样的。 

      “流是磁盘或其它外围设备中存储的数据的源点或终点。”

    在电脑上的数据有三种存储方式，一种是外存，一种是内存，一种是缓存。比如电脑上的硬盘，磁盘，U盘等都是外存，在电脑上有内存条，缓存是在CPU里面的。外存的存储量最大，其次是内存，最后是缓存，但是外存的数据的读取最慢，其次是内存，缓存最快。这里总结从外存读取数据到内存以及将数据从内存写到外存中。对于内存和外存的理解，我们可以简单的理解为容器，即外存是一个容器，内存又是另外一个容器。那又怎样把放在外存这个容器内的数据读取到内存这个容器以及怎么把内存这个容器里的数据存到外存中呢？

     在Java类库中，IO部分的内容是很庞大的，因为它涉及的领域很广泛:

         标准输入输出，文件的操作，网络上的数据流，字符串流，对象流，zip文件流等等，java中将输入输出抽象称为流，就好像水管，将两个容器连接起来。将数据冲外存中读取到内存中的称为输入流，将数据从内存写入外存中的称为输出流。

    流是一个很形象的概念，当程序需要读取数据的时候，就会开启一个通向数据源的流，这个数据源可以是文件，内存，或是网络连接。类似的，当程序需要写入数据的时候，就会开启一个通向目的地的流。


总结的基本概念如下：


1) 数据流：

    一组有序，有起点和终点的字节的数据序列。包括输入流和输出流。

  

2) 输入流（Input  Stream）：

      程序从输入流读取数据源。数据源包括外界(键盘、文件、网络…)，即是将数据源读入到程序的通信通道

     

 3) 输出流：

    程序向输出流写入数据。将程序中的数据输出到外界（显示器、打印机、文件、网络…）的通信通道。

         

采用数据流的目的就是使得输出输入独立于设备。

Input  Stream不关心数据源来自何种设备（键盘，文件，网络）

Output  Stream不关心数据的目的是何种设备（键盘，文件，网络）

4) 数据流分类：

流序列中的数据既可以是未经加工的原始二进制数据，也可以是经一定编码处理后符合某种格式规定的特定数据。因此Java中的流分为两种：
 1)  字节流：数据流中最小的数据单元是字节
 2)  字符流：数据流中最小的数据单元是字符， Java中的字符是Unicode编码，一个字符占用两个字节。

 

 


三. 标准I/O



      Java程序可通过命令行参数与外界进行简短的信息交换，同时，也规定了与标准输入、输出设备，如键盘、显示器进行信息交换的方式。而通过文件可以与外界进行任意数据形式的信息交换。

1. 命令行参数

public class TestArgs {
	public static void main(String[] args) {
		for (int i = 0; i < args.length; i++) {
			System.out.println("args[" + i + "] is <" + args[i] + ">");
		}
	}
}

运行命令：java Java C VB

运行结果：

args[0] is <Java>

args[1] is <C>

args[2] is <VB>

 

2. 标准输入，输出数据流

java系统自带的标准数据流：java.lang.System:

java.lang.System 
public final class System  extends Object{ 
   static  PrintStream  err;//标准错误流（输出）
   static  InputStream  in;//标准输入(键盘输入流)
   static  PrintStream  out;//标准输出流(显示器输出流)
}


注意：

（1）System类不能创建对象，只能直接使用它的三个静态成员。

（2）每当main方法被执行时,就自动生成上述三个对象。


1) 标准输出流 System.out

   System.out向标准输出设备输出数据，其数据类型为PrintStream。方法：

      Void print(参数)

      Void println(参数)

2)标准输入流 System.in

    System.in读取标准输入设备数据（从标准输入获取数据，一般是键盘），其数 据类型为InputStream。方法：

        int read()  //返回ASCII码。若,返回值=-1，说明没有读取到任何字节读取工作结束。

         int read(byte[] b)//读入多个字节到缓冲区b中返回值是读入的字节数

例如：


import java.io.*;
public class StandardInputOutput {
	public static void main(String args[]) {
		int b;
		try {
			System.out.println("please Input:");
			while ((b = System.in.read()) != -1) {
				System.out.print((char) b);
			}
		} catch (IOException e) {
			System.out.println(e.toString());
		}
	}
}


等待键盘输入，键盘输入什么，就打印出什么：



 

3)标准错误流

   System.err输出标准错误，其数据类型为PrintStream。可查阅API获得详细说明。

    标准输出通过System.out调用println方法输出参数并换行，而print方法输出参数但不换行。println或print方法都通 过重载实现了输出基本数据类型的多个方法，包括输出参数类型为boolean、char、int、long、float和double。同时，也重载实现 了输出参数类型为char[]、String和Object的方法。其中，print（Object）和println（Object）方法在运行时将调 用参数Object的toString方法。

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class StandardInputOutput {
	public static void main(String args[]) {
		String s;
		// 创建缓冲区阅读器从键盘逐行读入数据
		InputStreamReader ir = new InputStreamReader(System.in);
		BufferedReader in = new BufferedReader(ir);
		System.out.println("Unix系统: ctrl-d 或 ctrl-c 退出"
				+ "\nWindows系统: ctrl-z 退出");
		try {
			// 读一行数据，并标准输出至显示器
			s = in.readLine();
			// readLine()方法运行时若发生I/O错误，将抛出IOException异常
			while (s != null) {
				System.out.println("Read: " + s);
				s = in.readLine();
			}
			// 关闭缓冲阅读器
			in.close();
		} catch (IOException e) { // Catch any IO exceptions.
			e.printStackTrace();
		}
	}
}

 


四.java.IO层次体系结构



     在整个Java.io包中最重要的就是5个类和一个接口。5个类指的是File、OutputStream、InputStream、Writer、Reader；一个接口指的是Serializable.掌握了这些IO的核心操作那么对于Java中的IO体系也就有了一个初步的认识了

      Java I/O主要包括如下几个层次，包含三个部分：

   1.流式部分――IO的主体部分；

   2.非流式部分――主要包含一些辅助流式部分的类，如：File类、RandomAccessFile类和FileDescriptor等类；

   3.其他类--文件读取部分的与安全相关的类，如：SerializablePermission类，以及与本地操作系统相关的文件系统的类，如：FileSystem类和Win32FileSystem类和WinNTFileSystem类。

   主要的类如下：

     1. File（文件特征与管理）：用于文件或者目录的描述信息，例如生成新目录，修改文件名，删除文件，判断文件所在路径等。

     2. InputStream（二进制格式操作）：抽象类，基于字节的输入操作，是所有输入流的父类。定义了所有输入流都具有的共同特征。

     3. OutputStream（二进制格式操作）：抽象类。基于字节的输出操作。是所有输出流的父类。定义了所有输出流都具有的共同特征。

     Java中字符是采用Unicode标准，一个字符是16位，即一个字符使用两个字节来表示。为此，JAVA中引入了处理字符的流。

     4. Reader（文件格式操作）：抽象类，基于字符的输入操作。

     5. Writer（文件格式操作）：抽象类，基于字符的输出操作。

     6. RandomAccessFile（随机文件操作）：它的功能丰富，可以从文件的任意位置进行存取（输入输出）操作。

 

     Java中IO流的体系结构如图：

     


 



 

五. 非流式文件类--File类




在Java语言的java.io包中，由File类提供了描述文件和目录的操作与管理方法。但File类不是InputStream、OutputStream或Reader、Writer的子类，因为它不负责数据的输入输出，而专门用来管理磁盘文件与目录。

 

作用：File类主要用于命名文件、查询文件属性和处理文件目录。
public    class   File   extends Object 
    implements Serializable,Comparable
{}


 
File类共提供了三个不同的构造函数，以不同的参数形式灵活地接收文件和目录名信息。构造函数：
1）File (String   pathname)   

     例:File  f1=new File("FileTest1.txt"); //创建文件对象f1，f1所指的文件是在当前目录下创建的FileTest1.txt
2）File (String  parent  ,  String child)

     例:File f2=new  File(“D:\\dir1","FileTest2.txt") ;//  注意：D:\\dir1目录事先必须存在，否则异常
3）File (File    parent  , String child)

     例:File  f4=new File("\\dir3");

          File  f5=new File(f4,"FileTest5.txt");  //在如果 \\dir3目录不存在使用f4.mkdir()先创建

        一个对应于某磁盘文件或目录的File对象一经创建， 就可以通过调用它的方法来获得文件或目录的属性。    

       1）public boolean exists( ) 判断文件或目录是否存在

       2）public boolean isFile( ) 判断是文件还是目录 

       3）public boolean isDirectory( ) 判断是文件还是目录

       4）public String getName( ) 返回文件名或目录名

       5）public String getPath( ) 返回文件或目录的路径。

       6）public long length( ) 获取文件的长度 

       7）public String[ ] list ( ) 将目录中所有文件名保存在字符串数组中返回。 

       File类中还定义了一些对文件或目录进行管理、操作的方法，常用的方法有：

       1） public boolean renameTo( File newFile );    重命名文件

       2） public void delete( );   删除文件

       3）  public boolean mkdir( ); 创建目录

 

例子：


 

import java.io.File;
import java.io.IOException;
public class TestFile {
	public static void main(String args[]) throws IOException {
		File dir = new File("\\root");
		File f1 = new File(dir, "fileOne.txt");
		File f2 = new File(dir, "fileTwo.java");
		// 文件对象创建后，指定的文件或目录不一定物理上存在
		if (!dir.exists())
			dir.mkdir();
		if (!f1.exists())
			f1.createNewFile();
		if (!f2.exists())
			f2.createNewFile();
		System.out.println("f1's AbsolutePath=  " + f1.getAbsolutePath());
		System.out.println("f1 Canread=" + f1.canRead());
		System.out.println("f1's len= " + f1.length());
		String[] FL;
		int count = 0;
		FL = dir.list();
		for (int i = 0; i < FL.length; i++) {
			count++;
			System.out.println(FL[i] + "is in \\root");
		}
		System.out.println("there are" + count + "file in //root");
	}

}

 

说明：File类的方法:

(1) exists()测试磁盘中指定的文件或目录是否存在

(2) mkdir()创建文件对象指定的目录（单层目录）

(3) createNewFile()创建文件对象指定的文件

(4) list()返回目录中所有文件名字符串


 

六. Java.IO流类库




1. io流的四个基本类

      java.io包中包含了流式I/O所需要的所有类。在java.io包中有四个基本类：InputStream、OutputStream及Reader、Writer类，它们分别处理字节流和字符流：

基本数据流的I/O



			
输入/输出
			
			

			
字节流
			
			

			
字符流
			
		

			
输入流
			
			

			
Inputstream
			
			

			
Reader
			
		

			
输出流
			
			

			
OutputStream
			
			

			
Writer
			
		

 

IO框架：

 

    

 

 Java中其他多种多样变化的流均是由它们派生出来的:









      JDK1.4版本开始引入了新I/O类库，它位于java.nio包中，新I/O类库利用通道和缓冲区等来提高I/O操作的效率。

      在java.io包中， java.io.InputStream 表示字节输入流， java.io.OutputStream表示字节输出流，处于java.io包最顶层。这两个类均为抽象类，也就是说它们不能被实例化，必须生成子类之后才能实现一定的功能。

 

2. io流的具体分类

一、按I/O类型来总体分类：

     1. Memory 1）从/向内存数组读写数据: CharArrayReader、 CharArrayWriter、ByteArrayInputStream、ByteArrayOutputStream

                   2）从/向内存字符串读写数据 StringReader、StringWriter、StringBufferInputStream

     2.Pipe管道  实现管道的输入和输出（进程间通信）: PipedReader、PipedWriter、PipedInputStream、PipedOutputStream

     3.File 文件流。对文件进行读、写操作 ：FileReader、FileWriter、FileInputStream、FileOutputStream

     4. ObjectSerialization 对象输入、输出 ：ObjectInputStream、ObjectOutputStream

     5.DataConversion数据流 按基本数据类型读、写（处理的数据是Java的基本类型（如布尔型，字节，整数和浮点数））：DataInputStream、DataOutputStream

     6.Printing 包含方便的打印方法 ：PrintWriter、PrintStream

     7.Buffering缓冲  在读入或写出时，对数据进行缓存，以减少I/O的次数：BufferedReader、BufferedWriter、BufferedInputStream、BufferedOutputStream

     8.Filtering 滤流，在数据进行读或写时进行过滤：FilterReader、FilterWriter、FilterInputStream、FilterOutputStream过

     9.Concatenation合并输入 把多个输入流连接成一个输入流 ：SequenceInputStream

    10.Counting计数  在读入数据时对行记数 ：LineNumberReader、LineNumberInputStream

    11.Peeking Ahead 通过缓存机制，进行预读 ：PushbackReader、PushbackInputStream

    12.Converting between Bytes and Characters 按照一定的编码/解码标准将字节流转换为字符流，或进行反向转换（Stream到Reader,Writer的转换类）：InputStreamReader、OutputStreamWriter

二、按数据来源（去向）分类： 

1、File（文件）： FileInputStream, FileOutputStream, FileReader, FileWriter 

2、byte[]：ByteArrayInputStream, ByteArrayOutputStream 

3、Char[]: CharArrayReader, CharArrayWriter 

4、String: StringBufferInputStream, StringReader, StringWriter 

5、网络数据流：InputStream, OutputStream, Reader, Writer 

 


 

七. 字节流InputStream/OutputStream



 1. InputStream抽象类 

      InputStream 为字节输入流，它本身为一个抽象类，必须依靠其子类实现各种功能，此抽象类是表示字节输入流的所有类的超类。 继承自InputStream  的流都是向程序中输入数据的，且数据单位为字节（8bit）；

InputStream是输入字节数据用的类，所以InputStream类提供了3种重载的read方法.Inputstream类中的常用方法： 

　　（1） public abstract int read( )：读取一个byte的数据，返回值是高位补0的int类型值。若返回值=-1说明没有读取到任何字节读取工作结束。

　　（2） public int read(byte b[ ])：读取b.length个字节的数据放到b数组中。返回值是读取的字节数。该方法实际上是调用下一个方法实现的 

　　（3） public int read(byte b[ ], int off, int len)：从输入流中最多读取len个字节的数据，存放到偏移量为off的b数组中。 

　　（4） public int available( )：返回输入流中可以读取的字节数。注意：若输入阻塞，当前线程将被挂起，如果InputStream对象调用这个方法的话，它只会返回0，这个方法必须由继承InputStream类的子类对象调用才有用， 

　　（5） public long skip(long n)：忽略输入流中的n个字节，返回值是实际忽略的字节数, 跳过一些字节来读取 

　　（6） public int close( ) ：我们在使用完后，必须对我们打开的流进行关闭. 

         主要的子类：

        

         1） FileInputStream把一个文件作为InputStream，实现对文件的读取操作     

　　  2） ByteArrayInputStream：把内存中的一个缓冲区作为InputStream使用 

　　  3） StringBufferInputStream：把一个String对象作为InputStream 

　　  4） PipedInputStream：实现了pipe的概念，主要在线程中使用 

　　  5） SequenceInputStream：把多个InputStream合并为一个InputStream 

 

 2．OutputStream抽象类 

　　OutputStream提供了3个write方法来做数据的输出，这个是和InputStream是相对应的。 

　　1. public void write(byte b[ ])：将参数b中的字节写到输出流。 

　　2. public void write(byte b[ ], int off, int len) ：将参数b的从偏移量off开始的len个字节写到输出流。 

　　3. public abstract void write(int b) ：先将int转换为byte类型，把低字节写入到输出流中。 

　　4. public void flush( ) : 将数据缓冲区中数据全部输出，并清空缓冲区。 

　　5. public void close( ) : 关闭输出流并释放与流相关的系统资源。 

 

       主要的子类：

        

      1) ByteArrayOutputStream：把信息存入内存中的一个缓冲区中 

      2) FileOutputStream：把信息存入文件中 

      3) PipedOutputStream：实现了pipe的概念，主要在线程中使用 

      4) SequenceOutputStream：把多个OutStream合并为一个OutStream 

流结束的判断：方法read()的返回值为-1时；readLine()的返回值为null时。

3. 文件输入流： FileInputStream类

      FileInputStream可以使用read()方法一次读入一个字节，并以int类型返回，或者是使用read()方法时读入至一个byte数组，byte数组的元素有多少个，就读入多少个字节。在将整个文件读取完成或写入完毕的过程中，这么一个byte数组通常被当作缓冲区，因为这么一个byte数组通常扮演承接数据的中间角色。



 

 

作用：以文件作为数据输入源的数据流。或者说是打开文件，从文件读数据到内存的类。

使用方法(1)    

   File  fin=new File("d:/abc.txt"); 

  FileInputStream in=new FileInputStream( fin);

 

使用方法(2)

   FileInputStream  in=new  FileInputStream(“d: /abc.txt”);

程序举例：

将InputFromFile.java的程序的内容显示在显示器上



 

import java.io.IOException;
import java.io.FileInputStream;
;
public class TestFile {
	public static void main(String args[]) throws IOException {
		try{	
		       FileInputStream rf=new   FileInputStream("InputFromFile.java");
		       int n=512;   byte  buffer[]=new  byte[n];   
		       while((rf.read(buffer,0,n)!=-1)&&(n>0)){
		           System.out.println(new String(buffer) );
		        }
		        System.out.println();
		        rf.close();
		} catch(IOException  IOe){	    
		      System.out.println(IOe.toString());
		}

	}

}

 

4.文件输出流:FileOutputStream类

　  作用：用来处理以文件作为数据输出目的数据流；或者说是从内存区读数据入文件

      FileOutputStream类用来处理以文件作为数据输出目的数据流；一个表示文件名的字符串，也可以是File或FileDescriptor对象。 

　　创建一个文件流对象有两种方法： 

　　方式1： 

　　 File   f=new  File (“d:/myjava/write.txt ");

        FileOutputStream  out= new FileOutputStream (f);

　　方式2： 

　　FileOutputStream out=new FileOutputStream(“d:/myjava/write.txt "); 

　　方式3：构造函数将 FileDescriptor()对象作为其参数。 

　　FileDescriptor() fd=new FileDescriptor(); 

　　FileOutputStream f2=new FileOutputStream(fd); 

　　方式4：构造函数将文件名作为其第一参数，将布尔值作为第二参数。 

　　FileOutputStream f=new FileOutputStream("d:/abc.txt",true); 

　　注意： （1）文件中写数据时，若文件已经存在，则覆盖存在的文件；（2）的读/写操作结束时，应调用close方法关闭流。 

 


程序举例：使用键盘输入一段文章，将文章保存在文件write.txt中



import java.io.IOException;
import java.io.FileOutputStream;
public class TestFile {
	public static void main(String args[]) throws IOException {
		try {
			System.out.println("please Input from      Keyboard");
			int count, n = 512;
			byte buffer[] = new byte[n];
			count = System.in.read(buffer);
			FileOutputStream wf = new FileOutputStream("d:/myjava/write.txt");
			wf.write(buffer, 0, count);
			wf.close(); // 当流写操作结束时，调用close方法关闭流。
			System.out.println("Save to the write.txt");
		} catch (IOException IOe) {
			System.out.println("File Write Error!");
		}
	}

}

5. FileInputStream流和FileOutputStream的应用


利用程序将文件file1.txt 拷贝到file2.txt中。
import java.io.File;
import java.io.IOException;
import java.io.FileOutputStream;
import java.io.FileInputStream;

public class TestFile {
	public static void main(String args[]) throws IOException {
		try {
			File inFile = new File("copy.java");
			File outFile = new File("copy2.java");
			FileInputStream finS = new FileInputStream(inFile);
			FileOutputStream foutS = new FileOutputStream(outFile);
			int c;
			while ((c = finS.read()) != -1) {
				foutS.write(c);
			}
			finS.close();
			foutS.close();
		} catch (IOException e) {
			System.err.println("FileStreamsTest: " + e);
		}
	}

}



 


6. 缓冲输入输出流 BufferedInputStream/ BufferedOutputStream
        

 

      


       计算机访问外部设备非常耗时。访问外存的频率越高，造成CPU闲置的概率就越大。为了减少访问外存的次数，应该在一次对外设的访问中，读写更多的数据。为此，除了程序和流节点间交换数据必需的读写机制外，还应该增加缓冲机制。缓冲流就是每一个数据流分配一个缓冲区，一个缓冲区就是一个临时存储数据的内存。这样可以减少访问硬盘的次数,提高传输效率。

BufferedInputStream: BufferedInputStream比FileInputStream多了一个缓冲区。它提供了一个缓冲数组，每次调用read方法的时候，它首先尝试从缓冲区里读取数据，若读取失败（缓冲区无可读数据），则选择从物理数据源（譬如文件）读取新数据（这里会尝试尽可能读取多的字节）放入到缓冲区中，最后再将缓冲区中的内容部分或全部返回给用户.由于从缓冲区里读取数据远比直接从物理数据源（譬如文件）读取速度快。BufferedInputStream的默认缓冲区大小是8192字节。当每次读取的数据量很小时，FileInputStream每次都是从硬盘读入，而BufferedInputStream大部分是从缓冲区读入。读取内存速度比读取硬盘速度快得多，因此BufferedInputStream效率高。

例如：BUFFER_SIZE < 8192时候，BufferedInputStream性能是很高。

BufferedInputStream  bufferedInput = new BufferedInputStream(new FileInputStream(fileA));
byte[] buffer = new byte[BUFFER_SIZE];
int len;
while ((len = bufferedInput.read(buffer)) > 0){
    System.out.println(new String(buffer, 0, len));
}

BUFFER_SIZE > 8192时候, FileInputStream和BufferedInputStream两者效率就没有明显差别了。

BufferedOutputStream :执行wirte时先写入缓冲区，待缓冲区写满后，系统再写入输出设备。

 


1）将文件读入内存：


将BufferedInputStream与FileInputStream相接

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

  BufferedInputStream bin = new  BufferedInputStream( in); 

2）将内存写入文件：

将BufferedOutputStream 与 FileOutputStream相接:

String fileB = "/Users/huangguisu/b.txt";

FileOutputStream out = new FileOutputStream(fileB);

BufferedOutputStream bOut = new BufferedOutputStream(out);

byte[] buffer = {0x1,0x2,0x3};

bOut.write(buffer);

bOut.flush();

bOut.close();

3）键盘输入流读到内存

将BufferedReader与标准的数据流相接 

 InputStreamReader sin = new InputStreamReader (System.in) ；

BufferedReader bin = new       BufferedReader(sin);

import java.io.*;

public class ReadWriteToFile {
	public static void main(String args[]) throws IOException {
		InputStreamReader sin = new InputStreamReader(System.in);
		BufferedReader bin = new BufferedReader(sin);
		FileWriter out = new FileWriter("myfile.txt");
		BufferedWriter bout = new BufferedWriter(out);
		String s;
		while ((s = bin.readLine()).length() > 0) {
			bout.write(s, 0, s.length());
		}

	}
}

程序说明：

从键盘读入字符，并写入到文件中BufferedReader类的方法：String readLine()

作用：读一行字符串，以回车符为结束。

BufferedWriter类的方法：bout.write(String s,offset,len)

作用：从缓冲区将字符串s从offset开始，len长度的字符串写到某处。

 

 


八. 字符流Writer/Reader



        Java中字符是采用Unicode标准，一个字符是16位，即一个字符使用两个字节来表示。为此，JAVA中引入了处理字符的流。

1. Reader抽象类

    用于读取字符流的抽象类。子类必须实现的方法只有 read(char[], int, int) 和 close()。但是，多数子类将重写此处定义的一些方法，以提供更高的效率和/或其他功能。

       

        1) FileReader :与FileInputStream对应  

           主要用来读取字符文件，使用缺省的字符编码，有三种构造函数： 

　　    (1）将文件名作为字符串 ：FileReader f = new FileReader(“c:/temp.txt”); 

　　    (2）构造函数将File对象作为其参数。 

　　            File f=new file(“c:/temp.txt”); 

　　            FileReader f1=new FileReader(f); 

　　   (3)  构造函数将FileDescriptor对象作为参数 

　　          FileDescriptor() fd = new FileDescriptor() 

　　          FileReader f2=new FileReader(fd); 

               (1) 用指定字符数组作为参数：CharArrayReader(char[]) 

               (2) 将字符数组作为输入流:CharArrayReader(char[], int, int) 

　         读取字符串，构造函数如下： public StringReader(String s); 

        2) CharArrayReader：与ByteArrayInputStream对应  

　　3) StringReader : 与StringBufferInputStream对应 

　　4) InputStreamReader 

　　      从输入流读取字节，在将它们转换成字符:Public inputstreamReader(inputstream is); 

　　5) FilterReader: 允许过滤字符流 

　　      protected filterReader(Reader r); 

　　6) BufferReader :接受Reader对象作为参数，并对其添加字符缓冲器，使用readline()方法可以读取一行。 

　　   Public BufferReader(Reader r); 

      主要方法：

      (1)  public int read() throws IOException; //读取一个字符，返回值为读取的字符 

　　(2)  public int read(char cbuf[]) throws IOException; /*读取一系列字符到数组cbuf[]中，返回值为实际读取的字符的数量*/ 

　　(3)  public abstract int read(char cbuf[],int off,int len) throws IOException; 

　　/*读取len个字符，从数组cbuf[]的下标off处开始存放，返回值为实际读取的字符数量，该方法必须由子类实现*/ 

2. Writer抽象类

     写入字符流的抽象类。子类必须实现的方法仅有 write(char[], int, int)、flush() 和 close()。但是，多数子类将重写此处定义的一些方法，以提供更高的效率和/或其他功能。 其子类如下：

    

      1） FileWrite: 与FileOutputStream对应  

　　将字符类型数据写入文件，使用缺省字符编码和缓冲器大小。 

　　Public FileWrite(file f); 

　　2)  chararrayWrite:与ByteArrayOutputStream对应 ,将字符缓冲器用作输出。 
　　    Public CharArrayWrite(); 
　　3) PrintWrite:生成格式化输出 
　　    public PrintWriter(outputstream os); 
　　4) filterWriter:用于写入过滤字符流 
　　    protected FilterWriter(Writer w); 
　　5) PipedWriter：与PipedOutputStream对应   

      6) StringWriter：无与之对应的以字节为导向的stream  

      主要方法：

　　(1)  public void write(int c) throws IOException； //将整型值c的低16位写入输出流 
　　(2)  public void write(char cbuf[]) throws IOException； //将字符数组cbuf[]写入输出流 
　　(3)  public abstract void write(char cbuf[],int off,int len) throws IOException； //将字符数组cbuf[]中的从索引为off的位置处开始的len个字符写入输出流 
　　(4)  public void write(String str) throws IOException； //将字符串str中的字符写入输出流 
　　(5)  public void write(String str,int off,int len) throws IOException； //将字符串str 中从索引off开始处的len个字符写入输出流 
　　(6)  flush( ) //刷空输出流，并输出所有被缓存的字节。 
　　(7)close()    关闭流 public abstract void close() throws IOException

 

 

3 .InputStream与Reader差别 OutputStream与Writer差别

 

InputStream和OutputStream类处理的是字节流，数据流中的最小单位是字节(8个bit)

Reader与Writer处理的是字符流，在处理字符流时涉及了字符编码的转换问题

import java.io.*;
public class EncodeTest {
    private static void readBuff(byte [] buff) throws IOException {
       ByteArrayInputStream in =new ByteArrayInputStream(buff);
        int data;
        while((data=in.read())!=-1)   System.out.print(data+"  ");
        System.out.println();     in.close();     }

   public static void main(String args[]) throws IOException {
       System.out.println("内存中采用unicode字符编码：" );
       char   c='好';
       int lowBit=c&0xFF;     int highBit=(c&0xFF00)>>8;
       System.out.println(""+lowBit+"   "+highBit);
       String s="好";
       System.out.println("本地操作系统默认字符编码：");
       readBuff(s.getBytes());
       System.out.println("采用GBK字符编码：");
       readBuff(s.getBytes("GBK"));
       System.out.println("采用UTF-8字符编码：");      
       readBuff(s.getBytes("UTF-8"));      }
}




Reader类能够将输入流中采用其他编码类型的字符转换为Unicode字符，然后在内存中为其分配内存

Writer类能够将内存中的Unicode字符转换为其他编码类型的字符，再写到输出流中。

 

4、BufferedInputStream 和BufferedReader区别

首先虽然都作为一个包装类，但是BufferedReader针对字符流，BufferedInputStream针对字节流

BufferedInputStream在实现的时候是在自身read方法中提供缓存，是一次取1024或更多字节然后再慢慢读，一个个的返回，它并没有实现读一行的方法

BufferedReader在实现时通过提供一个readLine方法，使用数组或者stringBuilder存储一行数据，并一次性返回

 


九. FileWriter类(字符输出流类)


构造方法：FileWriter fw = new FileWriter(String fileName);//创建字符输出流类对象和已存在的文件相关联。文件不存在的话，并创建。

               如： FileWriter fw = new FileWriter("C:\\1.txt");

                 FileWriter fw = new FileWriter(String fileName,boolean append);//创建字符输出流类对象和已存在的文件相关联,并设置该该流对文件的操作是否为续写。

               如：FileWriter fw = new FileWriter("C:\\1.txt",ture); //表示在fw对文件再次写入时，会在该文件的结尾续写，并不会覆盖掉。

主要方法： 

        void write(String str)   //写入字符串。当执行完此方法后，字符数据还并没有写入到目的文件中去。此时字符数据会保存在缓冲区中。此时在使用刷新方法就可以使数据保存到目的文件中去。

        viod flush()                //刷新该流中的缓冲。将缓冲区中的字符数据保存到目的文件中去。

        viod close()               //关闭此流。在关闭前会先刷新此流的缓冲区。在关闭后，再写入或者刷新的话，会抛IOException异常。


十. 如何选择IO流


 
1、确定是数据源和数据目的（输入还是输出）


              源:输入流 InputStream Reader

              目的:输出流 OutputStream Writer

2、明确操作的数据对象是否是纯文本

             是:字符流Reader，Writer

             否:字节流InputStream，OutputStream

3、明确具体的设备。

       是硬盘文件：File++：

              读取：FileInputStream,, FileReader,

               写入：FileOutputStream，FileWriter

      是内存用数组

              是byte[]：ByteArrayInputStream, ByteArrayOutputStream

              是char[]：CharArrayReader, CharArrayWriter

              是String：StringBufferInputStream(已过时，因为其只能用于String的每个字符都是8位的字符串), StringReader, StringWriter

              是网络用Socket流： 输入socket.getOutputStream()      输出socket.getInputStream()

             是键盘：用System.in（是一个InputStream对象）读取，用System.out（是一个OutoutStream对象）打印

4、是否需要转换流

            是，就使用转换流，从Stream转化为Reader，Writer：InputStreamReader，OutputStreamWriter 

5、是否需要缓冲提高效率

        是就加上Buffered：BufferedInputStream, BufferedOuputStream, BuffereaReader, BufferedWriter

   

6、是否需要格式化输出

 

例如：将一个文件中数据存储到另一个文件中。JAVA的文件读取主要有字节流读取和字符流读取两种方式，字节流可以既可以操作文本文件，也可以操作非文本文件，如一些二进制数据（图片，视频，对象），而字符流只能操作文本。
     

将一个文件中数据存储到另一个文件中：

1） 数据源和数据目的：读取流，InputStream/Reader  输出：OutputStream/Writer
2）是否纯文本：是！可以选择Reader Writer和InputStream/OutputStream。 
3）设备：是硬盘文件。Reader体系中可以操作文件的对象是 FileReader FileWriter。

              FileReader fr = new FileReader("a.txt");  

              FileWriter fw = new FileWriter("b.txt"); 
4）是否需要提高效率：是，加Buffer
             BufferedReader bfr = new BufferedReader(new FileReader("a.txt");  );  
             BufferedWriter bfw = new BufferedWriter(new FileWriter("b.txt");  ); 

package com.javademo.demo.io;
import java.io.*;

public class IoFileDemo {
    private static int BUFFER_SIZE = 1024;
    public static void main(String[] args) throws Exception {
        IoFileDemo  ioFileDemo = new IoFileDemo();
        String  fileA = "/Users/huangguisu/a.txt";
        String  fileB = "/Users/huangguisu/b.txt";
        ioFileDemo.copyFileWithBufferStream(fileA, fileB);

    }

    /**
     * 字符流读取：只能操作文本文件
     * @param srcFile
     * @throws IOException
     */
    public String readFile(String srcFile)  throws IOException {
        FileReader fr = new FileReader(srcFile);//读取流
        //不要直接用String直接拼接文本。。效率太低，每次要new新对象，用StringBuilder，StringBuffer都可以
        StringBuffer sb = new StringBuffer();
        char[] buf = new char[10];
        int len;
        //读取文件并把它存入buf中，用len返回读到字符的个数，一直读到结尾
        while ((len = fr.read(buf)) != -1) {
            //buf字符数组里仍有空白没有读入的位置，所以不要直接new String(buf);
            String str = new String(buf,0,len);
            sb.append(str);
        }
        fr.close();
        return  sb.toString();

    }

    /**
     * 字符流读取和写入：只能操作文本
     * @param srcFile
     * @param dstFile
     * @throws IOException
     */
    public void copyFileWithString(String srcFile, String dstFile)  throws IOException {
        FileReader fr = new FileReader(srcFile);//读取流
        FileWriter fw = new FileWriter(dstFile);//输出流
        char[] buf = new char[10];
        int len;
        //读取文件并把它存入buf中，用len返回读到字符的个数，一直读到结尾
        while ((len = fr.read(buf)) != -1) {
            //buf字符数组里仍有空白没有读入的位置，所以不要直接fw.write(buf);可以直接使用fw.write(buf, 0, len);
            String str = new String(buf,0,len);
            fw.write(str);
        }
        fr.close();
        fw.close();

    }

    /**
     * 使用buffer读取和写入字符流：：只能操作文本
     * @param srcFile
     * @param dstFile
     * @throws IOException
     */
    public void copyFileWithBufferedString(String srcFile, String dstFile)  throws IOException {
        FileReader fr = new FileReader(srcFile);//读取流
        FileWriter fw = new FileWriter(dstFile);//输出流
        //使用Buffer提高效率
        BufferedReader bfr = new BufferedReader(fr);
        BufferedWriter bfw = new BufferedWriter(fw);

        String str = null;
        int j = 1;
        while ((str = bfr.readLine()) != null) {
            System.out.println("第" + j + "行内容：" + str);
            bfw.write(str);
            bfw.newLine();//跨平台的换行符
            j++;
        }
        bfr.close();
        bfw.close();
        fr.close();
        fw.close();


    }

    /**
     * 例:将一个二进制数据（图片，视频，对象）文件中数据存储到另一个文件中，只能用xxxStream.
     * 当然也可以读取文本文件。
     * 字节输入流和输出流
     * @param srcFile
     * @param dstFile
     * @throws IOException
     */
    public void copyFileWithStream(String srcFile, String dstFile)  throws IOException {
        FileInputStream finS = new FileInputStream(srcFile);
        FileOutputStream foutS = new FileOutputStream(dstFile);
        int c;
        while ((c = finS.read()) != -1) {
            foutS.write(c);
        }
        //或者
        /*
        byte[] buffer = new byte[1024];
        int len;
        while ((len = finS.read(buffer)) > 0){
            foutS.write(buffer, 0, len);
            len.flush();
        }
        */
        finS.close();
        foutS.close();
    }

    /**
     * 使用Buffer
     * @param srcFile
     * @param dstFile
     * @throws IOException
     */
    public void copyFileWithBufferStream(String srcFile, String dstFile) throws IOException{
        FileInputStream finS = new FileInputStream(srcFile);
        FileOutputStream foutS = new FileOutputStream(dstFile);
        BufferedInputStream  bufferedInput = new BufferedInputStream(finS);
        BufferedOutputStream bufferedOutput = new BufferedOutputStream(foutS);
        byte[] buffer = new byte[BUFFER_SIZE];
        int len;
        while ((len = bufferedInput.read(buffer)) > 0){
            bufferedOutput.write(buffer, 0, len);
            bufferedOutput.flush();
        }

        bufferedInput.close();
        bufferedOutput.close();
        finS.close();
        foutS.close();
    }

    /**
     * BufferedReader则是比InputStreamReader更高级,它封裝了StreamReader类,一次读取取一行的字符
     * @param srcFile
     * @param dstFile
     * @throws IOException
     */
    public void copyFileWithBufferStream2(String srcFile, String dstFile)  throws IOException {
        FileInputStream finS = new FileInputStream(srcFile);
        FileOutputStream foutS = new FileOutputStream(dstFile);

        InputStreamReader inputStreamReader = new InputStreamReader(finS,"utf8");
        OutputStreamWriter outputStreamWriter = new  OutputStreamWriter(foutS, "utf8");
        BufferedReader brRead = new BufferedReader(inputStreamReader);
        BufferedWriter brWriter = new BufferedWriter(outputStreamWriter);
        String line = null;
        while((line= brRead.readLine()) != null){
            System.out.println(line);
            brWriter.write(line);
            brWriter.newLine();//跨平台的换行符
            brWriter.flush();//刷新流
        }
        brRead.close();
        brWriter.close();
        finS.close();
        foutS.close();

    }


}


 

7、网络（socket）数据交互：

package com.javademo.demo.socket;

import java.io.*;
import java.net.Socket;

public class SocketClient {
    public static void main(String args[]) throws Exception{
        //1、创建客户端Socket，指定服务器地址和端口
        Socket socket = new Socket("127.0.0.1",10000);
        //2、获取输出流，向服务器端发送信息：由Socket对象得到输出流
        OutputStream output = socket.getOutputStream();//字节输出流
        //构造PrintWriter对象：将输出流包装成打印流
        PrintWriter printWriter = new PrintWriter(output);
        printWriter.write("{'user':'hgs'}");
        printWriter.flush();


        //3、获取输入流，并读取服务器端的响应信息：由Socket对象得到输入流
        InputStream inputStream = socket.getInputStream();
        //构造相应的BufferedReader对象
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
        String info = null;
        while((info = bufferedReader.readLine()) != null){
            System.out.println("Hello,我是客户端，服务器说："+info);
        }

        //4、由系统标准输入设备构造BufferedReader对象
        BufferedReader stdIn = new BufferedReader( new InputStreamReader(System.in));
        String readline;
        readline= stdIn.readLine(); //从系统标准输入读入一字符串
        //若从标准输入读入的字符串为 "ok"则停止循环
        while(!readline.equals("ok")){
            //将从系统标准输入读入的字符串输出到Server
            printWriter.println(readline);
            //刷新输出流，使Server马上收到该字符串
            printWriter.flush();
            //在系统标准输出上打印读入的字符串
            System.out.println("Client:"+readline);
            //从Server读入一字符串，并打印到标准输出上
            System.out.println("Server:"+bufferedReader.readLine());
            readline = stdIn.readLine(); //从系统标准输入读入一字符串
        }

    }
}

 


11. IOException异常类的子类


1.public class  EOFException ：

   非正常到达文件尾或输入流尾时，抛出这种类型的异常。

2.public class FileNotFoundException：

   当文件找不到时，抛出的异常。

3.public class InterruptedIOException：

   当I/O操作被中断时，抛出这种类型的异常。





 


感谢您的支持，我会继续努力的! 扫码打赏，你说多少就多少


         

 

 

 

很多朋友在学习NIO的时候感觉比较吃力，对里面一些概念不是很明朗，本文杜撰了一个大嘴开饭店的故事，来类比Java IO模型的演变，帮助理解几种模型的功能和特点，IO分为磁盘IO和网络IO，本文讨论的都是网络IO。

爪哇村的大嘴做得一手好菜，原本是和平饭店的厨子，对吃的东西悟性很高，工作之余喜欢研究各种创新菜，最近自创一道麻辣小龙虾，顾客们吃后反响强烈，于是，大嘴想自立门户，专门开店经营小龙虾。

说干就干，为了方便抓虾，大嘴将饭店开在了河边，并取名“河底捞”。大嘴虽然姓大，但是野心其实并不大，起初，只是想采取日式料理的做法，店里就他自己一个人，晚上抓虾，白天做成麻辣小龙虾，服务客人。

计划赶不上变化，饭店开张没几天，来吃小龙虾的人越来越多，到饭点时间，大嘴一个人根本忙不过来，实在没办法，于是大嘴找到隔壁张三、李四和王五的老婆，对这3个人讲，到饭点时到他店里来帮忙，主要是帮他当服务员，负责给客人点餐，上菜，结账，清理桌子。大嘴说，来了客人，我就叫你们仨，服务完客人，你们各回各家。于是，我们的BIO通信模型登场了：

来一个客人（Web Brower1），大嘴（Acceptor）就去隔壁叫张三（New Thread1），服务完客人，张三就回家。

来两个客人（Web Brower2），大嘴就去隔壁叫李四（New Thread2），服务完客人，李四就回家。

来三个客人（Web Brower3），大嘴就去隔壁叫王五的老婆（New Thread3），服务完客人，王五的老婆就回家。

大嘴的偶像是米其林3星厨师小野二郎，经营理念就是一个服务员全程服务好一个客人（connection per thread），客人上桌后，服务员就要站在旁边服务，直到客人用餐完毕。美味的小龙虾和良好的用餐体验，吸引越来越多的村民来大嘴店里用餐。随着客户端数量不断增加，BIO通信模型的问题显露无疑：每一个新客户端接入时，服务端必须创建一个新的线程处理新接入的客户端链路，一个线程只能处理一个客户端连接，在高性能服务领域，需要面对成千上万个客户端并发连接，这种模型无法满足高性能、高并发接入场景。采用这种模型，要想满足客人用餐需求，再多来一个客人，大嘴得临时叫上赵六，孙七，周八，吴九，郑十，大嘴能叫过来帮忙的邻居就这么几位，叫完就没有了。后面来的客人，大嘴只好让他们回家，改天再来。

这样下去显然不行，大嘴又找到隔壁张三、李四和王五的老婆，对这3个人讲：以后我不叫你们了，你们每天直接来我店里上班，换上“河底捞”的统一服装，朝九晚五，我给你们开固定工资，这样就节省了你们来来回回的时间，一开始张三和李四不是特别愿意，说要在家陪老婆，但是很快被王五的老婆说服了。于是有了采用线程池和任务队列的“伪异步IO模型”。

当有新客户端接入时，将客户端的Socket封装成一个Task，投递到后端线程池中进行处理，线程池维护一个消息队列和N个活跃线程，对消息队列中的任务进行处理。由于线程池可以设置消息队列的大小和最大线程数，因此，资源是可控的，无论多少个客户端并发访问，也不会导致资源耗尽和宕机。



没客人时，张三、李四和王五的老婆都在店里待命，新来了客人，他们仨陆续上去服务，服务完，继续在店里待命，店门口放了5个凳子，供客人等候。这样改进之后，用户体验有了一定提升，但3个服务员在客人用餐时，还是全程陪在桌旁为其服务，用过餐的都夸“河底捞”的服务好。尤其是钱大爷，特别满意“河底捞”的服务，钱大爷爱喝酒，每次用餐要4个小时，王五的老婆在旁边一会上菜，一会倒酒，一会递热毛巾，基本上一天就服务钱大爷这一个客人。当钱大爷这类人来用餐时，外面排队的5个凳子早早就坐满了人，并且后面再来的客人，大嘴只能劝他们改日再来。

这就是这种“伪异步IO模型”典型的问题，当可用线程都被故障服务器阻塞时，后续所有的IO消息都将在队列中排队，线程池采用阻塞队列实现，当队列积满后，后续入队的操作将被阻塞，前端只有一个Accept线程接收客户端接入，它被阻塞在线程池的同步阻塞队列之后，新的客户端请求将被拒绝，客户端会发生大量连接超时。

大嘴很快意识到，“伪异步IO模型”依然极大地限制了客流量，导致后面来的客人怨声载道，村里的林捕头每天下班过来，想要吃一顿小龙虾，发现门口已经排满了人，根本吃不上。林捕头放出风声，说大嘴长期在河边抓虾，可能会破坏村里的生态环境。于是大嘴紧急召集张三、李四和王五的老婆开会，讨论如何让林捕头能够排上队，吃上小龙虾。

张三曾经在爪哇村村委会干过一段时间码农，他说他知道有一种NIO模型（非阻塞IO），和现在店里的情况很像。几乎所有的网络连接都会经过“读取请求内容—>解码—>计算处理—>编码—>回复”，类似于店里“接待—>找桌—>点菜—>上菜—>结账—>收拾桌子”，每开一个桌子，我们称为开了一个channel，每个桌上放一个灯，当客人有点菜、上菜、结账等服务需求时，点亮灯，我们会有一个全局的管理者selector，会不断地在各个channel轮询（polling），检测是否有灯点亮，如果有灯亮，则通知专门的服务员来进行服务。这就是IO多路复用，IO多路复用可同时监听多个描述符（socket），一旦某个描述符就绪（一般是读就绪或者写就绪），能够通知程序进行相应的读写操作，IO多路复用避免阻塞在IO上，原本为多线程来接收多个连接的消息变为单线程保存多个socket的状态后轮询处理。

这种机制也叫做反应器模式（Reactor），Reactor负责响应IO事件（accept，read，send），当检测到一个新的事件，将其发送给相应的Handler去处理。Reactor为单个线程，需要处理accept连接，同时发送请求到Handler中。由于只有单个线程，所以Handler中的业务需要能够快速处理完。



于是，大嘴安排张三专职点菜传菜，李四负责上菜结账，王五的老婆负责其他on call的特殊服务，大嘴则负责盯着各个桌上的灯是否亮着，有灯点亮就叫相应的服务员过来处理。这样改进后，效果显著，虽然饭店已经人满为患，门口竟然没有排队的，生意越来越红火。

改进流程后，服务效率显著提高，店里的客流量继续增长，三个服务员每天忙得不可开交，但对于来个十桌八桌客人，三个服务员基本可以轻松应付。不过在某些情况下，会突然出现人手急剧短缺的情况，这种情况在林捕头就餐时经常发生。林捕头有选择困难症，每次点菜时，要考虑半个小时，并且不让服务员离开，因为他有很多问题向服务员咨询。结账时，因为要拿去衙门报销，需要开发票，又需要服务员帮忙写发票抬头，打印，最后还不忘找服务员要停车票。

这个问题正好就是NIO模型的缺点，这种模型由于IO在阻塞时会一直等待，因此在用户负载增加时，性能下降的非常快。server导致阻塞的原因有：

1、serversocket的accept方法，阻塞等待client连接，直到client连接成功。

2、线程从socket inputstream读入数据，会进入阻塞状态，直到全部数据读完。

3、线程向socket outputstream写入数据，会阻塞直到全部数据写完

既然能发现缺点，就有相应的解决办法，聊过非阻塞IO后， 再来看看异步IO（AIO）。 IO方面的概念很多，阻塞性与异步性是其关键概念。简单而言，凡是需要由应用程序将数据读写到应用程序内存中的IO，都是同步IO，比如上面的BIO与NIO。相对的，凡是由OS来完成读写的，就是异步IO。这个说法有些迷惑，举例而言，在NIO中，当应用程序检测到某个Channel有可读数据时，必须显式发起一个read请求。而在异步IO中，应用程序仅仅需要告诉OS，我需要什么数据，并提供给OS一个Buffer和一个回调。OS会自己检测Channel的可读性，当发现其可读，会自动将数据复制到Buffer中，并通知应用程序任务完成。异步IO的典型实现是NodeJS。显然，由于将任务进一步下发到了OS，应用程序的可伸缩性及性能会大大增强。并且，比起非阻塞的NIO，异步IO编程更加容易一些, 性能也基本上总是优于它。

有了这一理论基础，可以继续讲大嘴的故事。

不到一年，小龙虾生意一发不可收拾，店里的营收越来越可观，王五的老婆也用上了iPhoneX和ipad pro，但王五的老婆一直想买一辆BMW，在得知ipad里面有很多点餐的APP后，她对大嘴说：其实咱们店只需要一个服务员就可以了，张三和李四完全是多余的，把他们俩的钱给我，我一个人可以服务所有客人。大嘴表示怀疑：咱们店一天接待几十桌客人，你一个人怎么忙得过来？

王五的老婆说，咱们店里所有的工作分为两类：

1.马上就能干完的，例如接待，找座，下单，清理桌子等

2.需要等别人干完才能干的活，比如点菜（需要顾客想好吃什么），上菜（需要后厨做好），结账（需要顾客确认账单、买单）等。

对于第1类工作，我马上干活，对于第2类工作，我也不会等待，我只要告诉别人，你弄完了告诉我一声，我会接着干，然后马上去做第1类工作。比如点菜，我只要给客人一个ipad，给完ipad我就立刻离开，客人点完餐后叫我，我只要点确认下单即可。结账时，我只要给客人一张带二维码的消费清单小票，我就立刻离开，客人确认完消费清单，自己扫描二维码进行支付，结账完毕后，叫我过来确认即可，我顺便把桌子打扫了，如果顾客需要发票，可以去前台凭小票自助打印，不需要服务员参与。

王五的老婆说的这一套，正是jdk7引入的NIO2模型，又叫异步IO（AIO）。为了说明异步IO，用计算机视角再回顾一下店里的服务流程：

服务员：线程

顾客：http请求

后厨做菜，客人吃饭：耗时的IO操作

后厨大喊一声上菜：这是一个长时间IO操作完成后所发出的事件

客人说结账：另外一个长时间IO操作完成后所发出的事件

第一类工作(迎客，找座，下单) : 在服务器端的业务逻辑代码，能够快速执行。

第二类工作(上菜，结账) : 同样是能快速执行的代码，但是他们需要等待那些耗时的IO 操作完成才能开始，确切的来说，收到了系统发出的事件以后才开始执行。在AIO中实际上是在回调函数中来执行的：

下面是AIO服务模式的伪代码：



后厨处理（）这个函数接受两个参数，一个是事件名，另外一个是匿名的回调函数，事件发生，回调函数才会执行。客人吃饭（）函数也是类似。

王五的老婆接着说，我的秘诀就是不等待，耗时的操作全部使用异步方式，别人做完了再通知我。大嘴听了目瞪口呆，原来饭店可以这样开，一旦拥有这种服务效率，明年利润再翻一番不是问题，后年可以赴港交所上市了。

总结上述几种IO模型，将其功能和特性进行对比：



虽然AIO有很多优势，但并不意味着所有Java网络编程都必须选择AIO，具体选择什么IO模型或者框架，还是要基于业务的实际应用场景和性能诉求，如果客户端并发连接数不多，服务器的负载也不重，则完全没必要选择AIO做服务器，毕竟AIO编程难度相对BIO来说更大。