IO流小总结
1.IO流总述
IO流以内存为核心，进内存为Input，出内存为Output。
1.1划分
按照大小划分：字符流，字节流。
按照出入内存划分：InputStream，OutputStream
1.2明确IO流的功能
1.明确要操作的数据是数据源还是数据目的(要读还是要写)
数据源：InputStream，Reader
数据目的：OutputStream，Writer
2.明确要用什么类
字节流：InputStream，OutputStream
字符流（中文，视频等）：Reader，Writer
3.明确是否需要额外功能
需要转换：转换流InputStreamReader，OutputStreamWriter
需要高效：缓冲流Bufferedxxx
对象序列化—— ObjectInputStream、ObjectOutputStream
2.File类概述
IO流，也就是输入输出流，从文件出发到文件结束，至始至终都离不开文件，所以IO流还得从文件File类讲起。
2.1File类的一些基本操作
public class FileDemo {
public static void main(String[] args) throws Exception {
File file = new File("D:\\ab.txt");//在d盘创键一个文件夹
file.createNewFile();//创建文件
System.out.println("是否是文件夹:"+file.isDirectory());
System.out.println("是否是文件:"+file.isFile());
System.out.println(file.isHidden());//判断是否隐藏
System.out.println(new Date(file.lastModified()));//创建日期
System.out.println(file.getTotalSpace()/1024/1024/1024+"G");//该盘符的总内存
System.out.println(file.getFreeSpace()/1024/1024/1024+"G");//该盘符的剩余内存
File f =new File("E:\\");//定位到e盘
File[]fs= f.listFiles();//取出对象
for (File file2 : fs) {
System.out.println(file2.getName());
}
}
}
2.2 文件的递归调用显示内容
public class FileDemo02 {
static int count = 0;
public static void main(String[] args) {
File file = new File("C:\\");//定位到c盘
find(file);
System.out.println("图片的数量是："+count+"张");
}
public static void find(File file) {
if(file!=null&&file.isFile()) {//是文件
String fileName = file.getName();
if(fileName.endsWith(".jpg")||fileName.endsWith(".png")) {
count++;
System.out.println(fileName);
}
// System.out.println(file.getName());
}
//文件夹
File fs[] = file.listFiles();
if(fs!=null) {
for (File file2 : fs) {
find(file2);//反复调用
}
}
}
}
3.输入流和输出流
3.1输入流
读取文件夹中的文件
public class InputStreamDemo {
public static void main(String[] args) {
/*
* 寻找路径
*/
String path =Thread.currentThread().getContextClassLoader().getResource("").getPath();//获得根的路径
System.out.println(path);//我们要找的是src
path=path.substring(0,path.length()-4);//去掉bin
System.out.println(path);
String fileName = path+"src/io/file/FileDemo02.java";//找到了我们要找的文件路径
System.out.println(fileName);
/*
* 包装
*/
try(InputStream in =new FileInputStream(fileName);//字节输入流
InputStreamReader r =new InputStreamReader(in); //转化流，因为有中文，我们要转换为字符流
) {
//输出内容
int n =0;
while((n=r.read())!=-1) {
System.out.print((char) n);
}
}catch(Exception e) {
e.printStackTrace();
}
}
}
我们在使用输入流时，一般使用InputStream in =new FileInputStream()；
3.2输出流（一般要配合缓存）
输出流和输入流略微有所不同。当数据进入内存时，读取速度往往很快。然后当数据要出内存时，内存要到达硬盘等设备时，硬盘读取速度较慢，我们往往需要缓存。
首先我们来感受一下输出流到底有什么用。
public class WriterDemo {
public static void main(String[] args) throws Exception {
Writer out =new FileWriter("E:\\outw.txt",false);
out.write("abcdefghijklmn");
out.flush();
out.close();
}
}
public class OutputStreamDemo {
public static void main(String[] args) throws Exception {
OutputStream out = new FileOutputStream("E:\\out.txt",true);//false为删除，true为尾部追加
out.write('b');
out.flush();
out.close();
}
}
这两个程序的作用时在我们创建的一个文本中添加（write）内容，特别要注意true和false，如果不写默认为false。
下面这个示例是关于缓存的使用
byte[] buffer = new byte[1024];//缓存
完整代码
public class CopyDemo {
public static void main(String[] args) throws Exception {
InputStream in = new FileInputStream("D:\\java2\\20220129\\video\\2022-01-29.mp4");
OutputStream out = new FileOutputStream("E:\\copyMovie.mp4");
long s1 =System.currentTimeMillis();
byte[] buffer = new byte[1024];//缓存
while(in.read(buffer)!=-1) {
out.write(buffer);//边读边写
}
long s2 =System.currentTimeMillis();
System.out.println("拷贝耗时："+(s2-s1)+"ms");
out.close();
in.close();
}
}
4.序列化和反序列化（ObjectOutputStream和ObjectInputStream）
序列化：一个java对象做一下“交换”，变成字节序列，这样一来方便持久化存储到磁盘，避免程序运行结束后对象就从内存里消失，另外变换成字节序列也更便于网络运输和传输。
反序列化：把字节序列恢复为原先的java对象。
序列化和反序列化的条件：该类必须实现java.io.Serializable 接口，Serializable 是一个标记接口，不实现此接口的类将不会使任何状态序列化或反序列化，会抛出NotSerializableException 。该类的所有属性必须是可序列化的。如果有一个属性不需要可序列化的，则该属性必须注明是瞬态的，使用transient 关键字修饰。（如hashmap中的某些属性就不可序列化）。
下面我们直接看代码
这是我们创建的Car类，实现Serializable接口
public class Car implements Serializable{
private static final long serialVersionUID = 1L;//uid即为版本号，每次序列化和反序列化的版本号必须一致
private int id;
private String brand;
private String color;
private double price;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getBrand() {
return brand;
}
public void setBrand(String brand) {
this.brand = brand;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
public Car(int id, String brand, String color, double price) {
super();
this.id = id;
this.brand = brand;
this.color = color;
this.price = price;
}
public Car() {
}
@Override
public String toString() {
return "Car [id=" + id + ", brand=" + brand + ", color=" + color + ", price=" + price + "]";
}
}
序列化，将内容暂时存放在car.dat中
public class ObjectOutputStreamDemo {
public static void main(String[] args) throws Exception {
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("E:\\car.dat"));//创建一个输出流
Car c =new Car(1, "bmw", "红色", 120000.00);
out.writeObject(c);//序列化
out.close();
}
}
反序列化
ublic class ObjectInputStreamDemo {
public static void main(String[] args) throws Exception {
ObjectInputStream in = new ObjectInputStream(new FileInputStream("E:\\car.dat"));
Car car = (Car) in.readObject();//反序列化
System.out.println(car);
}
}
5.nio
bio：我们通常使用的是这种bio（同步阻塞）：线程发起IO请求，不管内核是否准备好IO操作，从发起请求起，线程一直阻塞，直到操作完成。
nio（同步不阻塞）：线程发起IO请求，立即返回；内核在做好IO操作的准备之后，通过调用注册的回调函数通知线程做IO操作，线程开始阻塞，直到操作完成。（将单项变成多项）。
我们完成nio需要三个组件
- buffer：缓存区实际上是一块可以写入数据，然后从中读取数据的内存。这块内存被包装为NIO Buffer对象，并提供一组方法，用来方便访问该内存。
- Channe：通道表示打开到IO设备（例如：文件等）的连接。若需要使用NIO，需要获取连接IO设备的通道以及用于容纳数据的缓存区。然后操作缓存区，对数据进行处理。相较于Stream更加高效，可以异步双向处理，但是必须和buffer一起使用。
-Select：Select允许单线程处理多个通道（Channe）。
public class nioDemo {
public static void main(String[] args) throws Exception {
//获得地址
String path = Thread.currentThread().getContextClassLoader().getResource("").getPath();
System.out.println(path);
path =path.substring(0, path.length()-4);
System.out.println(path);
String fileName = path+"src/io/file/FileDemo02.java";
RandomAccessFile raf = new RandomAccessFile(fileName, "rw");//rw表示可读可写
FileChannel inChannel =raf.getChannel();//获得写通道
ByteBuffer buffer = ByteBuffer.allocate(64);//缓存
int n =0;
while((n=inChannel.read(buffer))!=-1) {
buffer.flip();//移动到缓存的第一个位置
while(buffer.hasRemaining()) {//判断是否有数据
System.out.print((char)buffer.get());
}
buffer.clear();
}
raf.close();
}
}