Java-AIO

最新推荐文章于 2024-09-29 07:00:00 发布
最新推荐文章于 2024-09-29 07:00:00 发布
阅读量229 收藏
点赞数 1
分类专栏： 基础知识 Java 文章标签： AIO 异步非阻塞
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qcl108/article/details/114185438
版权

Java AIO

AIO概述

  • AIO(Asynchronous IO)是 Java 1.7之后引入的包. 特点是异步非阻塞, 属 NIO的扩展, 又称 NIO.2
  • AIO采用 Proactor模式, 特点是先由操作系统完成后才通知服务端程序启动线程去处理，一般适用于连接数较多, 且连接时间较长的应用
  • 主要新增 Path接口, Paths和 Files工具类

Path接口

  • java.nio.file.Path代表一个平台无关的路径, 表示目录结构和指定文件的位置
  • 常用方法:
方法说明
boolean isAbsolute()判断是否为绝对路径
Path getRoot()获取根(ex: C:\)
Path getFileName()获取路径指向的文件或目录的名称
Path getParent()获取父级完整路径(如 Path对象为根, 则返回 null)
int getNameCount()获取根后面路径数量(如指定了文件, 则 +1)
boolean startsWith(Path other)判断是否开头为 other
boolean endsWith(Path other)判断是否结束为 other
URI toUri()获取 URI型式的地址(ex: file:///C:/Users)
Path toAbsolutePath()获取绝对路径(如地址含文件, 则包含文件)
boolean equals(Object other)是否为相同
File toFile()将 Path转为 File类对象

Paths工具类

方法说明
static Path get(String first, String… more)用于将多个字符串串连成 Path路径
static Path get(URI uri)获取指定 uri对应的 Path路径

Files工具类

  • java.nio.file.Files用于操作文件或目录的工具类
  • 常用方法:
方法说明
SeekableByteChannel newByteChannel(Path path, OpenOption… options)获取指定文件的读取和写入通道
DirectoryStream<Path> newDirectoryStream(Path dir)打开 dir对应的目录
Path createDirectory(Path dir, FileAttribute<?>… attrs)创建 dir对应的目录
void delete(Path path)删除 Path对应的文件或目录, 如不存在, 则报错
boolean deleteIfExists(Path path)Path对应的文件或目录存在, 则删除
Path copy(Path source, Path target, CopyOption… options)复制文件 source到 target
Path move(Path source, Path target, CopyOption… options)移动文件 src到 dest
boolean isSameFile(Path path, Path path2)判断两个路径或文件是否相等
boolean isHidden(Path path)判断是否是隐藏文件
String probeContentType(Path path)获取 Path对应的 Content Type; 注: path为目录时, 则返回 null
<V extends FileAttributeView> V getFileAttributeView(Path path, Class<V> type, LinkOption… options)返回给定类型的文件或目录属性视图
<A extends BasicFileAttributes> A readAttributes(Path path, Class<A> type, LinkOption… options)获取 Path对应的文件或目录相关属性
Path setAttribute(Path path, String attribute, Object value, LinkOption… options)给 Path对应的文件或目录, 设置属性(如隐藏属性)
UserPrincipal getOwner(Path path, LinkOption… options)获取文件所有者
Path setOwner(Path path, UserPrincipal owner)设置文件所有者
boolean isSymbolicLink(Path path)判断是否是软链接
boolean isDirectory(Path path, LinkOption… options)判断是否是目录
boolean isRegularFile(Path path, LinkOption… options)判断是否是常规文件(常规文件是永久存储在文件系统中的字节序列, 不是则特殊文件包括符号链接和目录)
FileTime getLastModifiedTime(Path path, LinkOption… options)获取文件的上次修改时间
Path setLastModifiedTime(Path path, FileTime time)修改文件的上次修改时间
long size(Path path)获取 Path对应的文件大小
boolean exists(Path path, LinkOption… options)判断文件是否存在
boolean notExists(Path path, LinkOption… options)判断文件是否不存在
boolean isReadable(Path path)判断文件是否可读
boolean isWritable(Path path)判断文件是否可写
boolean isExecutable(Path path)判断是否是可执行文件
Path walkFileTree(Path start, FileVisitor<? super Path> visitor)遍历文件系统(用于遍历包含子目录的目录)
byte[] readAllBytes(Path path)字节形式读取文件到字节数组(一次性读取其全部内容)
List<String> readAllLines(Path path)字符形式读取文件到列表(一次性读取其全部内容)
Path write(Path path, byte[] bytes, OpenOption… options)写入字节数组到文件
Path write(Path path, Iterable<? extends CharSequence> lines, Charset cs, OpenOption… options)写入字符列表到文件(可指定字符编码)
Stream<Path> list(Path dir)遍历文件目录
Stream<Path> walk(Path start, int maxDepth, FileVisitOption… options)遍历目录
Stream<Path> find(Path start, int maxDepth, BiPredicate<Path, BasicFileAttributes> matcher, FileVisitOption… options)遍历目录(需要按文件属性过滤时)
Stream<String> lines(Path path, Charset cs)字符形式读取文件到字符串流(可指定字符编码)
Stream<String> lines(Path path)字符形式读取文件到字符串流

使用例子


	// 获取指定文件的读取和写入通道
	public static void main(String[] args) {
		try (SeekableByteChannel newByteChannel = Files.newByteChannel(
				Paths.get("C:\\Users\\Shawn Jeon\\Pictures\\test\\test2.txt"), StandardOpenOption.READ)
		) {
			// 分配指定大小的缓冲区
			ByteBuffer buf = ByteBuffer.allocate(20);
			int len = 0;
			while ((len = newByteChannel.read(buf)) > 0) {
				// 切换读取模式
				buf.flip();
				// 打印内容
				System.out.print(new String(buf.array(), 0, len));
				// 清空缓冲区
				buf.clear();
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	// 打开 dir对应的目录
	public static void main(String[] args) {
		try (DirectoryStream<Path> newDirectoryStream = Files.newDirectoryStream(
				Paths.get("C:\\Users\\Shawn Jeon\\Pictures")
			)
		) {
			for (Path path: newDirectoryStream) {
				System.out.println(path);
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
//		C:\Users\Shawn Jeon\Pictures\1.jpg
//		C:\Users\Shawn Jeon\Pictures\2.jpg
//		C:\Users\Shawn Jeon\Pictures\Camera Roll
//		C:\Users\Shawn Jeon\Pictures\desktop.ini
//		C:\Users\Shawn Jeon\Pictures\Saved Pictures
//		C:\Users\Shawn Jeon\Pictures\test
	}

	// 创建 dir对应的目录
	public static void main(String[] args) {
		Path dir = Paths.get("C:\\Users\\Shawn Jeon\\Pictures\\test2");
		try {
			Files.createDirectory(dir);
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	// 删除 Path对应的文件或目录, 如不存在, 则报错; 注: 1. 无法删除有内容的目录 2. 无法删除只读文件
	public static void main(String[] args) {
		Path dir = Paths.get("C:\\Users\\Shawn Jeon\\Downloads\\test");
		try {
			Files.delete(dir);
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	// Path对应的文件或目录存在, 则删除; 注: 1. 无法删除有内容的目录 2. 无法删除只读文件
	public static void main(String[] args) {
		Path dir = Paths.get("C:\\Users\\Shawn Jeon\\Downloads\\test\\새 텍스트 문서.txt");
		try {
			Files.deleteIfExists(dir);
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	// 复制文件 source到 target
	public static void main(String[] args) {
		Path path1 = Paths.get("C:\\Users\\Shawn Jeon\\Downloads\\test\\1.txt");
		Path path2 = Paths.get("C:\\Users\\Shawn Jeon\\Downloads\\test\\5.txt");
		try {
			// REPLACE_EXISTING: 替换现有文件(如果存在), COPY_ATTRIBUTES: 复制原文件
			Files.copy(path1, path2, StandardCopyOption.COPY_ATTRIBUTES);
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	// 移动文件 src到 dest
	public static void main(String[] args) {
		Path path1 = Paths.get("C:\\Users\\Shawn Jeon\\Downloads\\test\\1.txt");
		Path path2 = Paths.get("C:\\Users\\Shawn Jeon\\Downloads\\test\\5.txt");
		try {
			// ATOMIC_MOVE: 移动源文件(如果存在, 则替换现有文件)
			Files.move(path1, path2, StandardCopyOption.ATOMIC_MOVE);
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	// 判断两个路径或文件是否相等
	public static void main(String[] args) {
		Path path1 = Paths.get("C:\\Users\\Shawn Jeon\\Downloads\\test\\3.txt");
		Path path2 = Paths.get("C:\\Users\\Shawn Jeon\\Downloads\\test\\4.txt");
		try {
			if (Files.isSameFile(path1, path2)) {
				System.out.println("相等");
			} else {
				System.out.println("不相等");
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	// 判断是否是隐藏文件
	public static void main(String[] args) {
		Path path = Paths.get("C:\\Users\\Shawn Jeon\\Downloads\\test\\5.txt");
		try {
			if (Files.isHidden(path)) {
				System.out.println("是");
			} else {
				System.out.println("否");
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	// 获取 Path对应的 Content Type; 注: path为目录时, 则返回 null
	public static void main(String[] args) {
		Path path = Paths.get("C:\\Users\\Shawn Jeon\\Downloads\\test\\4.txt");
		try {
			System.out.println(Files.probeContentType(path)); // text/plain
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	public static void main(String[] args) {
		Path file = Paths.get("C:\\Users\\Shawn Jeon\\Pictures");
		// 返回给定类型的文件或目录属性视图
		BasicFileAttributeView bf = Files.getFileAttributeView(file, BasicFileAttributeView.class);
		try {
			// 获取 Path对应的文件或目录相关属性
			BasicFileAttributes attr = bf.readAttributes();
			System.out.println("viewName : " + bf.name());
			System.out.println("creationTime: " + attr.creationTime());
			System.out.println("lastAccessTime: " + attr.lastAccessTime());
			System.out.println("lastModifiedTime: " + attr.lastModifiedTime());
			System.out.println("isDirectory: " + attr.isDirectory());
			System.out.println("isOther: " + attr.isOther());
			System.out.println("isRegularFile: " + attr.isRegularFile());
			System.out.println("isSymbolicLink: " + attr.isSymbolicLink());
			System.out.println("size: " + attr.size());
			long currentTime = System.currentTimeMillis();
			FileTime ft = FileTime.fromMillis(currentTime);
			// @param   lastModifiedTime 修改文件的最后修改时间
			// @param   lastAccessTime 最后查看时间
			// @param   createTime 创建时间
			bf.setTimes(ft, null, null);
		} catch (IOException e) {
			e.printStackTrace();
		}
//		viewName : basic
//		creationTime: 2020-11-11T02:25:30.918661Z
//		lastAccessTime: 2021-02-23T06:06:30.983797Z
//		lastModifiedTime: 2021-02-22T13:59:48.910598Z
//		isDirectory: true
//		isOther: false
//		isRegularFile: false
//		isSymbolicLink: false
//		size: 4096
	}

	// 给 Path对应的文件或目录, 设置属性(如隐藏属性)
	public static void main(String[] args) {
		Path file = Paths.get("C:\\Users\\Shawn Jeon\\Downloads\\test\\4.txt");
		try {
			Files.setAttribute(file, "dos:hidden", true);
			// 给文件设置只读属性
			file.toFile().setReadOnly();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	public static void main(String[] args) {
		// 全局规则 glob:
		//		glob:*.java 匹配以java结尾的文件
		//		glob:*.* 匹配包含'.'的文件
		//		glob:*.{java,class} 匹配以java或class结尾的文件
		//		glob:foo.? 匹配以foo开头且一个字符扩展名的文件
		//		glob:/home/*/* 在unix平台上匹配，例如/home/gus/data等
		//		glob:/home/** 在unix平台上匹配，例如/home/gus，/home/gus/data
		//		glob:c:\\\\* 在windows平台上匹配，例如c:foo，c:bar，注意字符串转义
		// 正则规则 regex:
		//		* 匹配零个或多个字符与名称组件，不跨越目录
		//		** 匹配零个或多个字符与名称组件，跨越目录（含子目录）
		//		? 匹配一个字符的字符与名称组件
		//		\ 转义字符，例如\{表示匹配左花括号
		//		[] 匹配方括号表达式中的范围，连字符(-)可指定范围。例如[ABC]匹配"A"、"B"和"C"；[a-z]匹配从"a"到"z"；[abce-g]匹配"a"、"b"、"c"、"e"、"f"、"g"
		//		[!...]匹配范围之外的字符与名称组件，例如[!a-c]匹配除"a"、"b"、"c"之外的任意字符
		//		{}匹配组中的任意子模式，多个子模式用","分隔，不能嵌套

		final String pattern = "regex:.*\\.(java|txt)";
		// final String pattern = "glob:**/*.{java,txt}";
		final PathMatcher pathMatcher = FileSystems.getDefault().getPathMatcher(pattern);
		Path path = Paths.get("C:\\Users\\Shawn Jeon\\Downloads\\test");
		try {
			// 遍历文件系统(用于遍历包含子目录的目录)
			Files.walkFileTree(path, new SimpleFileVisitor<Path>() {
				@Override
				public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) {
					// 查找java和 txt文件
					if (pathMatcher.matches(file)) {
						System.out.println(file);
						// 找到一个文件, 终止遍历
						// return FileVisitResult.TERMINATE;
					}
					return FileVisitResult.CONTINUE;
				}
			});
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	// 字符形式读取文件到列表(一次性读取其全部内容)
	public static void main(String[] args) {
		Path file = Paths.get("C:\\Users\\Shawn Jeon\\Downloads\\test\\5.txt");
		try {
			List<String> content = Files.readAllLines(file, StandardCharsets.UTF_8);
			System.out.println(content);
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	// 遍历文件目录
	public static void main(String[] args) {
		Path dir = Paths.get("C:\\Users\\Shawn Jeon\\Downloads\\test");
		try (Stream<Path> stream = Files.list(dir)) {
			stream.forEach(path -> {
				System.out.println(path);
			});
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	// 字符形式读取文件到字符串流
	public static void main(String[] args) {
		Path file = Paths.get("C:\\Users\\Shawn Jeon\\Downloads\\test\\5.txt");
		try (Stream<String> stream = Files.lines(file, StandardCharsets.UTF_8)) {
			// 打印文件内容行数
			// System.out.println(stream.count());
			stream.forEach(line -> {
				// 遍历内容
				System.out.println(line);
			});
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

如果您觉得有帮助，欢迎点赞哦 ~ 谢谢!!

Shawn Jeon
关注
专栏目录
Java AIO
JustinMars的博客
08-04 545
Java AIO
java中的AIO
weixin_34406061的博客
11-30 591
简介 jdk7中新增了一些与文件(网络)I/O相关的一些api。这些API被称为NIO.2，或称为AIO(Asynchronous I/O)。AIO最大的一个特性就是异步能力，这种能力对socket与文件I/O都起作用。AIO其实是一种在读写操作结束之前允许进行其他操作的I/O处理。AIO是对JDK1.4中提出的同步非阻塞I/O(NIO)...
Java中的NIO与AIO：构建高性能网络应用的实战指南
最新发布
微赚淘客系统开发者博客
09-29 641
今天我们来聊聊Java中的NIO（New I/O）和AIO（Asynchronous I/O），这是构建高性能网络应用的利器。Java NIO引入了面向块（Buffer）、通道（Channel）、选择器（Selector）的I/O操作，允许开发者以非阻塞的方式进行数据读写。AIO是Java 7引入的异步I/O框架，支持完全异步的I/O操作，即读写操作都不会阻塞线程。：当面对高延迟的I/O操作或不希望阻塞线程的场景时，AIO能够提供更加流畅的异步操作体验，例如文件传输、大数据处理等。
java AIO学习
weixin_30430169的博客
09-21 245
转载Reactor and Proactor的内容 系统I/O 可分为阻塞型, 非阻塞同步型以及非阻塞异步型[1,2]. 阻塞型I/O意味着控制权只到调用操作结束了才会回到调用者手里. 结果调用者被阻塞了, 这段时间了做不了任何其它事情. 更郁闷的是,在等待IO结果的时间里,调用者所在线程此时无法腾出手来去响应其它的请求，这真是太浪费资源了。拿read()操作来说吧, 调用...
java aio_【Java】Java AIO使用
weixin_32973973的博客
02-12 388
欢迎关注公众号: nullobject 。文章首发在个人博客 https://www.nullobject.cn，公众号nullobject同步更新。这篇文章主要介绍Java AIO网络编程。1. AIO是什么本文所说的AIO特指Java环境下的AIO。AIO是java中IO模型的一种，作为NIO的改进和增强随JDK1.7版本更新被集成在JDK的nio包中，因此AIO也被称作是NIO2.0。区别于...
JAVA AIO
chengqing3485的博客
07-16 210
AIO 与NIO不同，当进行读写操作时，只须直接调用API的read或write方法即可。这两种方法均为异步的，对于读操作而言，当有流可读取时，操作系统会将可读的流传入read方法的缓冲区，并通知应用程序；对于写操作而言，当操作系统将write方法传递的流写入完毕时，操作系统主动通...
cordova-plugin-fingerprint-aio:
05-12
科尔多瓦插件指纹多合一 对于Android和iOS 该插件提供了一个简单的界面来访问Android 6+和iOS上的指纹API。 特征 检查指纹扫描仪是否可用 指纹认证 Ionic Native支持 后备选项 FaceID支持 :high_voltage: 与配合...
SocketIO-BIO-NIO-AIO.zip
07-16
SocketIO-BIO-NIO-AIO.zip是一个压缩包文件，它包含了一个关于Java中三种不同的I/O模型——BIO（ Blocking I/O）、NIO（Non-blocking I/O）和AIO（Asynchronous I/O）的深入讲解。这些I/O模型是Java进行网络编程时的...
java网络编程源码-java-IO:java网络编程BIO，NIO,AIO源码示例
05-20
在Java中，有三种主要的I/O模型：BIO（Blocking I/O），NIO（Non-blocking I/O）和AIO（Asynchronous I/O）。这些模型各有特点，适用于不同的场景。 1. **BIO（阻塞I/O）** - BIO是最基础的I/O模型，它在Java早期...
coconut-aio-standalone-0.9.jar
03-01
jar包，官方版本，自测可用
coconut-aio-standalone-0.8.jar
03-01
jar包，官方版本，自测可用
Java中单个对象内存图解析
gkkljy的博客
12-13 293
执行下图代码，执行过程中内存解析 内存共分为三块，栈、堆、方法区 首先，会将类的字节码文件加载进方法区，但是有两个类，谁先加载呢，肯定是带main方法的类先加载，main方法里含有程序的入口，TestStudent类中只有一个主方法，所以主方法也会加载进方法区，同时，主方法会被虚拟机自动调用执行，加载进栈内存 然后主方法声明了一个Student类型的对象，但方法区此时没有Student类，所以会把Student类字节码文件加载进方法区，同时将该类的成员变量和成员方法都加载进方法区 使用new创建对象，
java aio_java中的AIO
weixin_39571179的博客
02-16 151
简介jdk7中新增了一些与文件(网络)I/O相关的一些api。这些API被称为NIO.2，或称为AIO(Asynchronous I/O)。AIO最大的一个特性就是异步能力，这种能力对socket与文件I/O都起作用。AIO其实是一种在读写操作结束之前允许进行其他操作的I/O处理。AIO是对JDK1.4中提出的同步非阻塞I/O(NIO)的进一步增强。关于NIO,之前的一篇文章可以看看：java中的...
java IO模型：AIO（Asynchronous I/O）
学亮编程手记
11-03 197
AIO 也就是 NIO 2。Java 7 中引入了 NIO 的改进版 NIO 2，它是 异步 IO 模型。 异步 IO 是基于事件和回调机制实现的，也就是应用操作之后会直接返回，不会堵塞在那里，当后台处理完成，操作系统会通知相应的线程进行后续的操作。 目前来说 AIO 的应用还不是很广泛。Netty 之前也尝试使用过 AIO，不过又放弃了。 这是因为，Netty 使用了 AIO 之后，在 Linux 系统上的性能并没有多少提升。
java aio_JavaAIO编程
weixin_29306011的博客
02-19 201
Asynchronous IO： 异步非阻塞的编程方式与 NIO 不同，当进行读写操作时，只须直接调用 API 的 read 或 write 方法即可。这两种 方法均为异步的，对于读操作而言，当有流可读取时，操作系统会将可读的流传入 read 方 法的缓冲区，并通知应用程序；对于写操作而言，当操作系统将 write 方法传递的流写入完 毕时，操作系统主动通知应用程序。即可以理解为，read/wri...
《Java I/O 模型》Java AIO
华仔仔的博客
05-08 739
《Java I/O 模型》专栏文章索引 👉《Java I/O 模型》Java BIO 👉《Java I/O 模型》Java NIO 📜在之前的两篇博客中，我们分别学习了传统的 Java BIO 和当今使用比较多的 Java NIO，那么最后一个阶段再简单了解一下 Java AIO 吧（由于种种原因，目前 Java AIO 使用的并不是很多，因此暂且简单的介绍一下）。 📙Java AIO(Asychronous I/O) 即 Java 异步非阻塞 I/O，JDK 1.7 开始支持，它是对 JDK1.4 .
java当中什么是AIO
Flying_Fish_roe的博客
09-06 889
AIO，全称为Asynchronous IO（异步输入输出），是Java中的一种处理I/O操作的方式，尤其在处理高并发、大量I/O请求时非常有效。AIO是Java NIO.2的一部分，是Java 7中引入的，用于改进NIO（Non-blocking IO，非阻塞输入输出）中的一些局限性。
java aio 客户端_java 异步IO-java AIO-java AIO 通信-嗨客网
weixin_28687331的博客
02-23 208
Java的AIO教程AIO 全程 Asynchronous I/O，它是异步的，客户端发起请求之后不需要等待服务端响应可以做其他的事情，然后服务端业务逻辑处理完之后会将处理结果通知客户端。客户端这个时候会到指定的缓冲区获取数据。Java的AIO描述与 NIO 不同的地方在于，Channel 对应的接口是异步的，主要涉及到的类：AsynchronousServerSocketChannel(服务器接...
Smart-Socket开源Java AIO框架的深度应用
资源摘要信息:"smart-socket是一个开源的Java AIO框架。在Java中，AIO（Asynchronous Non-blocking I/O）是指异步非阻塞的I/O模型，是一种高效的I/O处理方式。传统的BIO（Blocking I/O）模型在处理大量并发连接时，...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值