Java基础：阻塞式IO

转载请注明出处：jiq?钦‘s technical Blog

备注：阅读此文之前，建议先看我这篇博文了解阻塞式IO和非阻塞式IO的基本概念。

一、流(Stream)

1、字节流

输入（InputStream）

输出（OutputStream）

2、字符流

输入（Reader）

输出（Writer）

字节流与字符流：

（1）读写单位不同：字节流以字节（8bit）为单位，字符流以字符为单位，根据码表映射字符，一次可能读多个字节。

（2）处理对象不同：字节流能处理所有类型的数据（如图片、avi等），而字符流只能处理字符类型的数据。

（3）字节流在操作的时候本身是不会用到缓冲区的，是文件本身的直接操作的；而字符流在操作的时候下后是会用到缓冲区的，是通过缓冲区来操作流。

（4）设计Reader/Writer继承层次主要是为了国际化，字节流仅支持8位的读写，不能很好处理16位的Unicode字符，java本身的char是16位的，添加字符流就是为了在所有IO操作中都支持Unicode。

建议：尽量尝试使用字符流，一旦无法满足需求，再考虑字节流！！！

装饰器设计模式(Decorator)：

上面的流中，字节流和字符流各自内部的“处理流”可以包装其他“处理流”和“介质流”，而InputStreamReader和OutputStreamWriter可以包装字节流，提供了字节流到字符流的转换功能。

二、输入输出(IO)

1、文件IO

字节流：

public static void main(String[] args)throws IOException {
      String fileName="D:"+File.separator+"hello.txt";
      File f=new File(fileName);
      InputStream in=new FileInputStream(f);
      byte[] b=new byte[1024];
      int count =0;
      int temp=0;
      while((temp=in.read())!=(-1)){
          b[count++]=(byte)temp;
      }
      in.close();
      System.out.println(new String(b));
    }

字符流：

public static void main(String[] args)throws IOException {
      String fileName="D:"+File.separator+"hello.txt";
      File f=new File(fileName);
      char[] ch=new char[100];
      Reader read=new FileReader(f);
      int temp=0;
       int count=0;
      while((temp=read.read())!=(-1)){
          ch[count++]=(char)temp;
      }
      read.close();
      System.out.println("内容为"+new String(ch,0,count));
    }

2、内存IO

public static void main(Stringargs[])throws IOException {
         Stringstr = “Hello,jiyiqin”;
ByteArrayInputStreambInput = new ByteArrayInputStream(str.getBytes());
System.out.println("Convertingcharacters to Upper case " );
for(int y = 0 ;y < 1; y++ ) {
while(( c= bInput.read())!= -1) {
System.out.println(Character.toUpperCase((char)c));
}
bInput.reset();
}
}

3、管道IO

import java.io.InputStream;
import java.io.OutputStream;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;

public class PipedInputStreamTest {
   public static void main(String args[]) {
       PipedInputStream input = new PipedInputStream();
       PipedOutputStream output = new PipedOutputStream();
       try {
           output.connect(input);
           new Thread(new OutputstreamRunnable(output)).start();
           new Thread(new InputstreamRunnable(input)).start();
       } catch (Exception e) {
           e.printStackTrace();
       }
    }
}

//输出管道流线程
class OutputstreamRunnable implementsRunnable {
   private OutputStream out;
   public OutputstreamRunnable(OutputStream output) {
       this.out = output;
    }
   @Override
   public void run() {
       String str = "hello pipe";
       try {
           out.write(str.getBytes());
           out.flush();
           out.close();
       } catch (Exception e) {
           e.printStackTrace();
       }
    }
}

//输入管道流线程
class InputstreamRunnable implementsRunnable {
   private InputStream in;
   public InputstreamRunnable(InputStream in) {
       this.in = in;
    }
   @Override
   public void run() {
       byte[] bs = new byte[1024];
       int len = -1;
       try {
           if ((len = in.read(bs)) != -1) {
                System.out.println(newString(bs, 0, len));
           }
       } catch (Exception e) {
           e.printStackTrace();
       }
    }
}

4、网络IO

即常说的Java套接字(Socket)编程，这是阻塞式的Java网络IO。

服务端代码

public class Server {
   public static void main(String args[]) throws IOException {
      int port = 8888;
      ServerSocket server = new ServerSocket(port);
      Socket socket = server.accept();
      Reader reader = new InputStreamReader(socket.getInputStream());
      char chars[] = new char[64];
      int len;
      StringBuilder sb = new StringBuilder();
      while ((len=reader.read(chars)) != -1) {
         sb.append(new String(chars, 0, len));
      }
      System.out.println("from client: " + sb);
      reader.close();
      socket.close();
      server.close();
   }
}  

 客户端代码

public class Client {
   public static void main(String args[]) throws Exception {
      String host = "127.0.0.1";
      int port = 8888;
      Socket client = new Socket(host, port);
      Writer writer = new OutputStreamWriter(client.getOutputStream());
      writer.write("Hello Server.");
      writer.flush();
      writer.close();
      client.close();
   }
}  

版权声明：本文为博主原创文章，未经博主允许不得转载。