java BIO详解

作者: rockjh | 来源:发表于2017-12-15 16:43 被阅读0次

java BIO详解
BIO
BIO、NIO、AIO整理
java BIO通信模型详解
Java IO 解读
java BIO和NIO
BIO,NIO,AIO 总结
BIO,NIO,AIO 总结
初识NIO之Java小Demo
Nginx高性能原因

概念

流是一组有顺序的，有起点和终点的字节集合，是对数据传输的总称或抽象。即数据在两设备间的传输称为流，流的本质是数据传输，根据数据传输特性将流抽象为各种类，方便更直观的进行数据操作

IO类概述表

IO类概述表.png

常见流

RandomAccessFile 跳跃读文件,原理是调用一个native方法移动指向当前操作字节数组指针的位置,所以一般对于流的操作我们就要按照顺序读写，就可以获得完整的文件

package com.rockjh.jdk.io;

import java.io.IOException;
import java.io.RandomAccessFile;

/**
 * @author rockjh 【rockjh@aliyun.com】
 * @Description: 随机读写文件操作demo
 * @Date 2017/12/14 15:52
 **/
public class RandomAccessFileDemo {

    /**
     *从这个类我们可以知道，在底层一直有一个pos指向当前正在读或者写的位置，所以一般对于流的操作我们就要按照顺序执行
     * @param args
     * @throws IOException
     */
    public static void main(String[] args){
        byte[] value= new byte[4];
        try {
            //获取resource路径
            String path=RandomAccessFileDemo.class.getResource("/").getPath();
            RandomAccessFile randomAccessFile = new RandomAccessFile(path+"RandomAccessFileDemo.txt","r");
            //移动阅读的指针,注意汉字在不同编码里面占的字节数不一样，一般是2-4字节
            randomAccessFile.skipBytes(3);
            randomAccessFile.read(value);
        } catch (IOException e) {
            e.printStackTrace();
        }
        System.out.println(new String(value));
    }

}

管道流主要是为多个线程提供通信,一个输入管道，一个输出管道，一边输入一边输出

package com.rockjh.jdk.io;


import java.io.IOException;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;

/**
 * @author rockjh 【rockjh@aliyun.com】
 * @Description:
 * @Date 2017/12/14 16:42
 **/
public class PipeStreamDemo {
    public static void main(String[] args) throws IOException {
        PipedOutputStream pipedOutputStream=new PipedOutputStream();
        PipedInputStream pipedInputStream=new PipedInputStream(pipedOutputStream);
        Thread thread1=new Thread(() -> {
            try {
                pipedOutputStream.write("hello world".getBytes("utf-8"));
            } catch (IOException e) {
                e.printStackTrace();
            }
        },"thread1");
        Thread thread2=new Thread(()->{

            try {
                byte[] value=new byte[100];
                //一直等待读取状态为wait，直到有值
                pipedInputStream.read(value);
                System.out.println(new String(value));
            } catch (IOException e) {
                e.printStackTrace();
            }
        },"thread2");
        thread1.start();
        thread2.start();
    }
}

FileInputStream文件流

package com.rockjh.jdk.io;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.OutputStreamWriter;

/**
 * @author rockjh 【rockjh@aliyun.com】
 * @Description: 文件类demo
 * @Date 2017/12/14 21:16
 **/
public class FileDemo {

    public static void main(String[] args){
        try {
            File file=new File(FileDemo.class.getResource("/").getPath()+"fileDemo.txt");
            if(!file.exists()){
                file.createNewFile();
            }
            OutputStreamWriter output=new FileWriter(file);
            char[] value=new char[]{'世','界','你','好'};
            output.write(value);
            output.flush();
            System.out.println(file.isDirectory());
            System.out.println(file.list());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

ByteArrayOutputStream允许我们以字节的形式获取值toByteArray()方法
ObjectOutputStream主要是对象序列化存储的一个东西，他需要一个将值输出在构造参数中的流中，相当于是一个包装流吧

package com.rockjh.jdk.io;

import com.rockjh.jdk.bean.People;

import java.io.*;

/**
 * @author rockjh 【rockjh@aliyun.com】
 * @Description: 对象流，序列化对象
 * @Date 2017/12/14 21:30
 **/
public class ObjectStreamDemo {

    public static void main(String[] args){
        //对象序列化和反序列化
        try {
            People people=new People("rockjh",23,"18280193473");
            ObjectOutputStream output = new ObjectOutputStream(new FileOutputStream(ObjectStreamDemo.class.getResource("").getPath()+"object.data"));
            output.writeObject(people);
            output.flush();
            ObjectInputStream input = new ObjectInputStream(new FileInputStream(ObjectStreamDemo.class.getResource("").getPath()+"object.data"));
            people = (People) input.readObject();
            System.out.println(people);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }


        try {
            //对象转byte，byte转对象
            People people=new People("rockjh",23,"18280193473");
            System.out.println((People)byteToObj(objToByte(people)));
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

    /**
     * 字节转对象
     * @param bytes
     * @param <T>
     * @return
     * @throws IOException
     * @throws ClassNotFoundException
     */
    private static <T> T byteToObj(byte[] bytes) throws IOException, ClassNotFoundException {
        ByteArrayInputStream byteArrayInputStream=new ByteArrayInputStream(bytes);
        ObjectInputStream inputStream=new ObjectInputStream(byteArrayInputStream);
        T t= (T) inputStream.readObject();
        return t;
    }

    /**
     * 字节转对象
     * @param obj
     * @param <T>
     * @return
     * @throws IOException
     * @throws ClassNotFoundException
     */
    private static <T> byte[] objToByte(T obj) throws IOException {
        ByteArrayOutputStream byteArrayOutputStream=new ByteArrayOutputStream();
        ObjectOutputStream outputStream=new ObjectOutputStream(byteArrayOutputStream);
        outputStream.writeObject(obj);
        return byteArrayOutputStream.toByteArray();
    }
}