概念
流是一组有顺序的，有起点和终点的字节集合，是对数据传输的总称或抽象。即数据在两设备间的传输称为流，流的本质是数据传输，根据数据传输特性将流抽象为各种类，方便更直观的进行数据操作
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();
}
}
BufferedOutputStream为输出流提供缓存，能提供很多IO性能，不用每次都去磁盘或者网络一次读取一个或者几个字节
DataInputStream包装输入流，可以使得输入流直接输入几种基本数据类型，而不是只能输入字节数据
System.in, System.out, System.error(注：Java标准输入、输出、错误输出)
PushBackInputStream可以回退一个已读的流
java7新增在try块中自动关闭流，包括jdbc等
不管输入流还是输出流都要有一个数据源,最常见的一个列子就是实例化一个输入流，向其中写东西，然后输出流，输出到文件或者打印,输入流是read，输出流是write
路径
Object.class.getResource("/").getPath();获取classpath路径
Object.class.getResource("").getPath();获取当前类路径，即包括包
实例源代码 前往下载
