1、IO流概述

1.1 IO流概述（百度百科）

  流是一种抽象概念，它代表了数据的无结构化传递。按照流的方式进行输入输出，数据被当成无结构的字节序或字符序列。从流中取得数据的操作称为提取操作，而向流中添加数据的操作称为插入操作。用来进行输入输出操作的流就称为IO流。换句话说，IO流就是以流的方式进行输入输出。
  IO流的数据来源一般有硬盘、内存、键盘、网络等。

1.2 IO流分类

  在Java中I/O流操作的类很多，但是核心体系实际上就只有File、InputStream、OutputStream、Reader、Writer。
  字节流： 操作的数据单元是8位的字节。InputStream、OutputStream作为抽象基类。
  字符流： 操作的数据单元是字符。以Writer、Reader作为抽象基类。
  缓冲流： 是带缓冲区的处理流，它会提供一个缓冲区，缓冲区的作用的主要目的是：避免每次和硬盘打交道，能够提高输入/输出的执行效率。

在这里插入图片描述

在这里插入图片描述

1.3 IO流示例

1.3.1 从磁盘中读取文件并打印（通过文件字节流）

public class FileInputStreamDemo {
	
	public static void main(String[] args) {
		FileInputStream fileInputStream;
		try {
			fileInputStream = new FileInputStream("D:/test.txt");
			int i;
			while((i = fileInputStream.read()) != -1) {
				System.out.print((char) i);
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

1.3.2 从文件、内存、键盘、网络读取IO流

public class DataSourceDemo {
	
	public static void main(String[] args) {
		
		//从文件中读取
		fromFile();
		
		//从内存读取
		fromMemory();
		
		//从键盘读取
		fromKeyBoard();
		
		//从网络读取，网络IO单独补充
		fromInternet();
	}
	
	// 网络IO单独补充
	private static void fromInternet() {
		// todo
	}
	
	private static void fromKeyBoard() {
		try (InputStream inputStream = System.in) {
			int i;
			while((i = inputStream.read()) != -1) {
				System.out.print((char) i);
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
		System.out.println();
	}
	
	public static void fromFile() {
		try (FileInputStream fileInputStream = new FileInputStream("D:/test.txt")) {
			int i;
			while((i = fileInputStream.read()) != -1) {
				System.out.print((char) i);
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
		System.out.println();
	}
	
	public static void fromMemory() {
		try (ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream("Hello World!".getBytes())) {
			int i;
			while((i = byteArrayInputStream.read()) != -1) {
				System.out.print((char) i);
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
		System.out.println();
	}
}

1.3.3 根据用户端输入的路径进行目录的遍历

public class FileDemo {
	
	public static void main(String[] args) {
		try(InputStreamReader inputStreamReader = new InputStreamReader(System.in);
			BufferedReader bufferedReader = new BufferedReader(inputStreamReader)) {
			String path = bufferedReader.readLine();
			File file = new File(path);
			if (file.exists() && file.isDirectory()) {
				fileList(file);
			} else {
				System.out.println("文件路径输入错误");
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	
	private static void fileList(File filePath) {
		File[] files = filePath.listFiles();
		if (files != null) {
			for (File file : files) {
				if (file.isFile()) {
					System.out.println(file.getName());
				} else {
					fileList(file);
				}
			}
		}
	}
}

1.3.4 文件复制

public class InputStreamDemo {
	
	public static void main(String[] args) {
		File file = new File("D:/test.png");
		try(FileInputStream fileInputStream = new FileInputStream(file);
			FileOutputStream fileOutputStream = new FileOutputStream("D:/test_cp.png")) {
			int len;
			// 通过缓冲区提升磁盘读写效率
			byte[] buffer = new byte[1024];
			while((len = fileInputStream.read(buffer)) != -1) {
				fileOutputStream.write(buffer, 0, len);
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

1.3.5 通过缓冲区读取文件内容并打印

public class ReadDemo {
	
	public static void main(String[] args) {

		try(FileInputStream fileInputStream = new FileInputStream("D:/test.txt")) {
			int i;
			byte[] buffer = new byte[3];
			// 读取制定目录的字节，如果read方法没有输入会阻塞
			while((i = fileInputStream.read(buffer)) != -1) {
				System.out.print(new String (buffer,0, i));
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

1.3.6 通过缓冲流复制文件

public class BufferedDemo {
	
	public static void main(String[] args) {
		try (BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream("D:/test.txt"));
			 BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(new FileOutputStream("D:/test_cp.txt"))) {
			int len;
			byte[] bytes = new byte[1024];
			while((len = bufferedInputStream.read(bytes)) != -1) {
				bufferedOutputStream.write(bytes, 0, len);
				bufferedOutputStream.flush();
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

1.3.7 通过字符流读取文件并打印

public class ByteReadDemo {
	
	public static void main(String[] args) {
		try(FileReader fileReader = new FileReader("D:/test.txt")) {
			int i = 0;
			char[] chars = new char[1024];
			while ((i = fileReader.read(chars)) != -1) {
				System.out.println(new String(chars, 0, i));
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

1.3.8 过字节流读取文件，转换为指定编码的字符流并打印

public class StreamConvertDemo {
	
	public static void main(String[] args) {
		try(InputStream inputStream = new FileInputStream("D:/test.txt");
			BufferedInputStream bufferedInputStream = new BufferedInputStream(inputStream);
			InputStreamReader inputStreamReader = new InputStreamReader(bufferedInputStream, "UTF-8");
			BufferedReader bufferedReader = new BufferedReader(inputStreamReader);) {
			int i = 0;
			char[] chars = new char[1024];
			while ((i = bufferedReader.read(chars)) != -1) {
				System.out.println(new String(chars, 0, i));
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

1.3.9 将一个Java对象持久化到磁盘中，再从磁盘读取到内存中并打印

public class SerializeDemo {
	
	public static void main(String[] args) {
		User user = new User("Mic", 18);
		// 序列化
		try(ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("D:/user"))) {
			objectOutputStream.writeObject(user);
		} catch (Exception e) {
			e.printStackTrace();
		}
		
		// 反序列化
		try(ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("D:/user"))) {
			User user1 = (User) objectInputStream.readObject();
			System.out.println(user1);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	static class User implements Serializable {
		
		public User(String name, int age) {
			this.name = name;
			this.age = age;
		}
		
		private String name;
		
		private int age;
		
		public String getName() {
			return name;
		}
		
		public void setName(String name) {
			this.name = name;
		}
		
		public int getAge() {
			return age;
		}
		
		public void setAge(int age) {
			this.age = age;
		}
		
		@Override
		public String toString() {
			return "User{" +
					"name='" + name + '\'' +
					", age=" + age +
					'}';
		}
	}
}

1.4 IO流基本原理在这里插入图片描述

2、网络IO

2.1 网络通信基础知识

2.1.1 网络通信协议分析

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

2.1.2 IO通信原理分析

2.1.2.1 磁盘IO通信原理分析

在这里插入图片描述

2.1.2.2 网络IO通信原理分析

在这里插入图片描述

2.1.3 Socket通信流程

在这里插入图片描述

2.2 网络IO示例实战

2.3 拓展：深入解析零拷贝原理

3、NIO

4.1 XXX

4.2 XXX

4.3 XXX

5、XXX

5.1 XXX

5.2 XXX

5.3 XXX

6、XXX

6.1 XXX

6.2 XXX

6.3 XXX

  

# java # dubbo # 开发语言
Logo
亚马逊云科技技术品牌专区

更多推荐

cover

具身数据启示录：打破物理茧房，六大源泉如何为机器人注入灵魂

avatar 亚马逊云科技技术品牌专区
cover

Spring Cloud Gateway vs Higress：微服务网关技术选型深度解析

avatar 亚马逊云科技技术品牌专区
cover

2026年AI伴学教育一对一培训公司深度横评，为学生家长提供靠谱选型指南

avatar 亚马逊云科技技术品牌专区