小师妹学IO系列文章集合-附PDF下载
原创
java中最最让人激动的部分就是IO和NIO了。IO的全称是input output，是java程序跟外部世界交流的桥梁，IO指的是java.io包中的所有类，他们是从java1.0开始就存在的。NIO叫做new IO，是在java1.4中引入的新一代IO。
IO的本质是什么呢？它和NIO有什么区别呢？我们该怎么学习IO和NIO呢？
本系列将会借助小师妹的视角，详细讲述学习java IO的过程，希望大家能够喜欢。
小师妹何许人也？姓名不详，但是勤奋爱学，潜力无限，一起来看看吧。
本文的例子https://github.com/ddean2009/learn-java-io-nio
文章太长，大家可以直接下载本文PDF：下载链接java-io-all-in-one.pdf
第一章 IO的本质
IO的本质
IO的作用就是从外部系统读取数据到java程序中，或者把java程序中输出的数据写回到外部系统。这里的外部系统可能是磁盘，网络流等等。
因为对所有的外部数据的处理都是由操作系统内核来实现的，对于java应用程序来说，只是调用操作系统中相应的接口方法，从而和外部数据进行交互。
所有IO的本质就是对Buffer的处理，我们把数据放入Buffer供系统写入外部数据，或者从系统Buffer中读取从外部系统中读取的数据。如下图所示：
用户空间也就是我们自己的java程序有一个Buffer，系统空间也有一个buffer。所以会出现系统空间缓存数据的情况，这种情况下系统空间将会直接返回Buffer中的数据，提升读取速度。
DMA和虚拟地址空间
在继续讲解之前，我们先讲解两个操作系统中的基本概念，方便后面我们对IO的理解。
现代操作系统都有一个叫做DMA（Direct memory access）的组件。这个组件是做什么的呢？
一般来说对内存的读写都是要交给CPU来完成的，在没有DMA的情况下，如果程序进行IO操作，那么所有的CPU时间都会被占用，CPU没法去响应其他的任务，只能等待IO执行完成。这在现代应用程序中是无法想象的。
如果使用DMA，则CPU可以把IO操作转交给其他的操作系统组件，比如数据管理器来操作，只有当数据管理器操作完毕之后，才会通知CPU该IO操作完成。现代操作系统基本上都实现了DMA。
虚拟地址空间也叫做（Virtual address space），为了不同程序的互相隔离和保证程序中地址的确定性，现代计算机系统引入了虚拟地址空间的概念。简单点讲可以看做是跟实际物理地址的映射，通过使用分段或者分页的技术，将实际的物理地址映射到虚拟地址空间。
对于上面的IO的基本流程图中，我们可以将系统空间的buffer和用户空间的buffer同时映射到虚拟地址空间的同一个地方。这样就省略了从系统空间拷贝到用户空间的步骤。速度会更快。
同时为了解决虚拟空间比物理内存空间大的问题，现代计算机技术一般都是用了分页技术。
分页技术就是将虚拟空间分为很多个page，只有在需要用到的时候才为该page分配到物理内存的映射，这样物理内存实际上可以看做虚拟空间地址的缓存。
虚拟空间地址分页对IO的影响就在于，IO的操作也是基于page来的。
比较常用的page大小有：1,024, 2,048, 和 4,096 bytes。
IO的分类
IO可以分为File/Block IO和Stream I/O两类。
对于File/Block IO来说，数据是存储在disk中，而disk是由filesystem来进行管理的。我们可以通过filesystem来定义file的名字，路径，文件属性等内容。
filesystem通过把数据划分成为一个个的data blocks来进行管理。有些blocks存储着文件的元数据，有些block存储着真正的数据。
最后filesystem在处理数据的过程中，也进行了分页。filesystem的分页大小可以跟内存分页的大小一致，或者是它的倍数，比如 2,048 或者 8,192 bytes等。
并不是所有的数据都是以block的形式存在的，我们还有一类IO叫做stream IO。
stream IO就像是管道流，里面的数据是序列被消费的。
IO和NIO的区别
java1.0中的IO是流式IO，它只能一个字节一个字节的处理数据，所以IO也叫做Stream IO。
而NIO是为了提升IO的效率而生的，它是以Block的方式来读取数据的。
Stream IO中，input输入一个字节，output就输出一个字节，因为是Stream，所以可以加上过滤器或者过滤器链，可以想想一下web框架中的filter chain。在Stream IO中，数据只能处理一次，你不能在Stream中回退数据。
在Block IO中，数据是以block的形式来被处理的，因此其处理速度要比Stream IO快，同时可以回退处理数据。但是你需要自己处理buffer，所以复杂程度要比Stream IO高。
一般来说Stream IO是阻塞型IO，当线程进行读或者写操作的时候，线程会被阻塞。
而NIO一般来说是非阻塞的，也就是说在进行读或者写的过程中可以去做其他的操作，而读或者写操作执行完毕之后会通知NIO操作的完成。
在IO中，主要分为DataOutPut和DataInput，分别对应IO的out和in。
DataOutPut有三大类，分别是Writer，OutputStream和ObjectOutput。
看下他们中的继承关系：
DataInput也有三大类，分别是ObjectInput，InputStream和Reader。
看看他们的继承关系：
ObjectOutput和ObjectInput类比较少，这里就不列出来了。
统计一下大概20个类左右，搞清楚这20个类的用处，恭喜你java IO你就懂了！
对于NIO来说比较复杂一点，首先，为了处理block的信息，需要将数据读取到buffer中，所以在NIO中Buffer是一个非常中要的概念，我们看下NIO中的Buffer：
从上图我们可以看到NIO中为我们准备了各种各样的buffer类型使用。
另外一个非常重要的概念是channel，channel是NIO获取数据的通道：
NIO需要掌握的类的个数比IO要稍稍多一点，毕竟NIO要复杂一点。
就这么几十个类，我们就掌握了IO和NIO，想想都觉得兴奋。
总结
后面的文章中，我们会介绍小师妹给你们认识，刚好她也在学java IO，后面的学习就跟她一起进行吧，敬请期待。
第二章 try with和它的底层原理
简介
小师妹是个java初学者，最近正在学习使用java IO，作为大师兄的我自然要给她最给力的支持了。一起来看看她都遇到了什么问题和问题是怎么被解决的吧。
IO关闭的问题
这一天，小师妹一脸郁闷的问我：F师兄，我学Java IO也有好多天了，最近写了一个例子，读取一个文件没有问题，但是读取很多个文件就会告诉我：”Can’t open so many files“，能帮我看看是什么问题吗？
更多内容请访问www.flydean.com
小师妹的要求当然不能拒绝，我立马响应：可能打开文件太多了吧，教你两个命令，查看最大文件打开限制。
一个命令是 ulimit -a
第二个命令是
ulimit -n
256看起来是你的最大文件限制太小了，只有256个，调大一点就可以了。
小师妹却说：不对呀F师兄，我读文件都是一个一个读的，没有同时开这么多文件哟。
好吧，看下你写的代码吧：
BufferedReader bufferedReader = null;
try {
String line;
bufferedReader = new BufferedReader(new FileReader("trywith/src/main/resources/www.flydean.com"));
while ((line = bufferedReader.readLine()) != null) {
log.info(line);
}
} catch (IOException e) {
log.error(e.getMessage(), e);
}看完代码，问题找到了，小师妹，你的IO没有关闭，应该在使用之后，在finally里面把你的reader关闭。
下面这段代码就行了：
BufferedReader bufferedReader = null;
try {
String line;
bufferedReader = new BufferedReader(new FileReader("trywith/src/main/resources/www.flydean.com"));
while ((line = bufferedReader.readLine()) != null) {
log.info(line);
}
} catch (IOException e) {
log.error(e.getMessage(), e);
} finally {
try {
if (bufferedReader != null){
bufferedReader.close();
}
} catch (IOException ex) {
log.error(ex.getMessage(), ex);
}
}小师妹道了一声谢，默默的去改代码了。
使用try with resource
过了半个小时 ，小师妹又来找我了，F师兄，现在每段代码都要手动添加finally，实在是太麻烦了，很多时候我又怕忘记关闭IO了，导致程序出现无法预料的异常。你也知道我这人从来就怕麻烦，有没有什么简单的办法，可以解决这个问题呢？
那么小师妹你用的JDK版本是多少？
小师妹不好意思的说：虽然最新的JDK已经到14了，我还是用的JDK8.
JDK8就够了，其实从JDK7开始，Java引入了try with resource的新功能，你把使用过后要关闭的resource放到try里面，JVM会帮你自动close的，是不是很方便，来看下面这段代码：
try (BufferedReader br = new BufferedReader(new FileReader("trywith/src/main/resources/www.flydean.com")))
{
String sCurrentLine;
while ((sCurrentLine = br.readLine()) != null)
{
log.info(sCurrentLine);
}
} catch (IOException e) {
log.error(e.getMessage(), e);
}try with resource的原理
太棒了，小师妹非常开心，然后又开始问我了：F师兄，什么是resource呀？为什么放到try里面就可以不用自己close了？
resource就是资源，可以打开个关闭，我们可以把实现了java.lang.AutoCloseable接口的类都叫做resource。
先看下AutoCloseable的定义：
public interface AutoCloseable {
void close() throws Exception;
}AutoCloseable定义了一个close()方法，当我们在try with resource中打开了AutoCloseable的资源，那么当try block执行结束的时候，JVM会自动调用这个close（）方法来关闭资源。
我们看下上面的BufferedReader中close方法是怎么实现的：
public void close() throws IOException {
synchronized (lock) {
if (in == null)
return;
in.close();
in = null;
cb = null;
}
}自定义resource
小师妹恍然大悟：F师兄，那么我们是不是可以实现AutoCloseable来创建自己的resource呢？
当然可以了，我们举个例子，比如给你解答完这个问题，我就要去吃饭了，我们定义这样一个resource类：
public class CustResource implements AutoCloseable {
public void helpSister(){
log.info("帮助小师妹解决问题！");
}
@Override
public void close() throws Exception {
log.info("解决完问题，赶紧去吃饭！");
}
public static void main(String[] args) throws Exception {
try( CustResource custResource= new CustResource()){
custResource.helpSister();
}
}
}运行输出结果：
[main] INFO com.flydean.CustResource - 帮助小师妹解决问题！
[main] INFO com.flydean.CustResource - 解决完问题，赶紧去吃饭！总结
最后，小师妹的问题解决了，我也可以按时吃饭了。
第三章 File文件系统
简介
小师妹又遇到难题了，这次的问题是有关文件的创建，文件权限和文件系统相关的问题，还好这些问题的答案都在我的脑子里面，一起来看看吧。
文件权限和文件系统
早上刚到公司，小师妹就凑过来神神秘秘的问我：F师兄，我在服务器上面放了一些重要的文件，是非常非常重要的那种，有没有什么办法给它加个保护，还兼顾一点隐私？
更多内容请访问www.flydean.com
什么文件这么重要呀？不会是你的照片吧，放心没人会感兴趣的。
小师妹说：当然不是，我要把我的学习心得放上去，但是F师兄你知道的，我刚刚开始学习，很多想法都不太成熟，想先保个密，后面再公开。
看到小师妹这么有上进心，我老泪纵横，心里很是安慰。那就开始吧。
你知道，这个世界上操作系统分为两类，windows和linux（unix）系统。两个系统是有很大区别的，但两个系统都有一个文件的概念，当然linux中文件的范围更加广泛，几乎所有的资源都可以看做是文件。
有文件就有对应的文件系统，这些文件系统是由系统内核支持的，并不需要我们在java程序中重复造轮子，直接调用系统的内核接口就可以了。
小师妹：F师兄，这个我懂，我们不重复造轮子，我们只是轮子的搬运工。那么java是怎么调用系统内核来创建文件的呢？
创建文件最常用的方法就是调用File类中的createNewFile方法，我们看下这个方法的实现：
public boolean createNewFile() throws IOException {
SecurityManager security = System.getSecurityManager();
if (security != null) security.checkWrite(path);
if (isInvalid()) {
throw new IOException("Invalid file path");
}
return fs.createFileExclusively(path);
}方法内部先进行了安全性检测，如果通过了安全性检测就会调用FileSystem的createFileExclusively方法来创建文件。
在我的mac环境中，FileSystem的实现类是UnixFileSystem：
public native boolean createFileExclusively(String path)
throws IOException;看到了吗？UnixFileSystem中的createFileExclusively是一个native方法，它会去调用底层的系统接口。
小师妹：哇，文件创建好了，我们就可以给文件赋权限了，但是windows和linux的权限是一样的吗？
这个问题问得好，java代码是跨平台的，我们的代码需要同时在windows和linux上的JVM执行，所以必须找到他们权限的共同点。
我们先看一下windows文件的权限：
可以看到一个windows文件的权限可以有修改，读取和执行三种，特殊权限我们先不用考虑，因为我们需要找到windows和linux的共同点。
再看下linux文件的权限：
ls -al www.flydean.com
-rw-r--r-- 1 flydean staff 15 May 14 15:43 www.flydean.com上面我使用了一个ll命令列出了www.flydean.com这个文件的详细信息。 其中第一列就是文件的权限了。
linux的基本文件权限可以分为三部分，分别是owner，group，others，每部分和windows一样都有读，写和执行的权限，分别用rwx来表示。
三部分的权限连起来就成了rwxrwxrwx，对比上面我们的输出结果，我们可以看到www.flydean.com这个文件对owner自己是可读写的，对Group用户是只读的，对other用户也是只读的。
你要想把文件只对自己可读，那么可以执行下面的命令：
chmod 600 www.flydean.com小师妹立马激动起来：F师兄，这个我懂，6用二进制表示就是110，600用二进制表示就是110000000，刚刚好对应rw——-。
对于小师妹的领悟能力，我感到非常满意。
文件的创建
虽然我们已经不是孔乙己时代了，不需要知道茴字的四种写法，但是多一条知识多一条路，做些充足的准备还是非常有必要的。
小师妹，那你知道在java中有哪几种文件的创建方法呢？
小师妹小声道：F师兄，我只知道一种new File的方法。
我满意的抚摸着我的胡子，显示一下自己高人的气场。
之前我们讲过了，IO有三大类，一种是Reader/Writer，一种是InputStream/OutputStream,最后一种是ObjectReader/ObjectWriter。
除了使用第一种new File之外，我们还可以使用OutputStream来实现，当然我们还要用到之前讲到try with resource特性，让代码更加简洁。
先看第一种方式：
public void createFileWithFile() throws IOException {
File file = new File("file/src/main/resources/www.flydean.com");
//Create the file
if (file.createNewFile()){
log.info("恭喜，文件创建成功");
}else{
log.info("不好意思，文件创建失败");
}
//Write Content
try(FileWriter writer = new FileWriter(file)){
writer.write("www.flydean.com");
}
}再看第二种方式：
public void createFileWithStream() throws IOException
{
String data = "www.flydean.com";
try(FileOutputStream out = new FileOutputStream("file/src/main/resources/www.flydean.com")){
out.write(data.getBytes());
}
}第二种方式看起来比第一种方式更加简介。
小师妹：慢着，F师兄，JDK7中NIO就已经出现了，能不能使用NIO来创建文件呢？
这个问题当然难不到我：
public void createFileWithNIO() throws IOException
{
String data = "www.flydean.com";
Files.write(Paths.get("file/src/main/resources/www.flydean.com"), data.getBytes());
List<String> lines = Arrays.asList("程序那些事", "www.flydean.com");
Files.write(Paths.get("file/src/main/resources/www.flydean.com"),
lines,
StandardCharsets.UTF_8,
StandardOpenOption.CREATE,
StandardOpenOption.APPEND);
}NIO中提供了Files工具类来实现对文件的写操作，写的时候我们还可以带点参数，比如字符编码，是替换文件还是在append到文件后面等等。
代码中文件的权限
小师妹又有问题了：F师兄，讲了半天，还没有给我讲权限的事情啦。
别急，现在就讲权限：
public void fileWithPromission() throws IOException {
File file = File.createTempFile("file/src/main/resources/www.flydean.com","");
log.info("{}",file.exists());
file.setExecutable(true);
file.setReadable(true,true);
file.setWritable(true);
log.info("{}",file.canExecute());
log.info("{}",file.canRead());
log.info("{}",file.canWrite());
Path path = Files.createTempFile("file/src/main/resources/www.flydean.com", "");
log.info("{}",Files.exists(path));
log.info("{}",Files.isReadable(path));
log.info("{}",Files.isWritable(path));
log.info("{}",Files.isExecutable(path));
}上面我们讲过了，JVM为了通用，只能取windows和linux都有的功能，那就是说权限只有读写和执行权限，因为windows里面也可以区分本用户或者其他用户，所以是否是本用户的权限也保留了。
上面的例子我们使用了传统的File和NIO中的Files来更新文件的权限。
总结
好了，文件的权限就先讲到这里了。
第四章 文件读取那些事
简介
小师妹最新对java IO中的reader和stream产生了一点点困惑，不知道到底该用哪一个才对，怎么读取文件才是正确的姿势呢？今天F师兄现场为她解答。
字符和字节
小师妹最近很迷糊：F师兄，上次你讲到IO的读取分为两大类，分别是Reader，InputStream，这两大类有什么区别吗？为什么我看到有些类即是Reader又是Stream？比如：InputStreamReader?
小师妹，你知道哲学家的终极三问吗？你是谁？从哪里来？到哪里去？
F师兄，你是不是迷糊了，我在问你java，你扯什么哲学。
小师妹，其实吧，哲学是一切学问的基础，你知道科学原理的英文怎么翻译吗？the philosophy of science，科学的原理就是哲学。
你看计算机中代码的本质是什么？代码的本质就是0和1组成的一串长长的二进制数，这么多二进制数组合起来就成了计算机中的代码，也就是JVM可以识别可以运行的二进制代码。
更多内容请访问www.flydean.com
小师妹一脸崇拜：F师兄说的好像很有道理，但是这和Reader，InputStream有什么关系呢？
别急，冥冥中自有定数，先问你一个问题，java中存储的最小单位是什么？
小师妹：容我想想，java中最小的应该是boolean，true和false正好和二进制1，0对应。
对了一半，虽然boolean也是java中存储的最小单位，但是它需要占用一个字节Byte的空间。java中最小的存储单位其实是字节Byte。不信的话可以用之前我介绍的JOL工具来验证一下：
[main] INFO com.flydean.JolUsage - java.lang.Boolean object internals:
OFFSET SIZE TYPE DESCRIPTION VALUE
0 12 (object header) N/A
12 1 boolean Boolean.value N/A
13 3 (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 3 bytes external = 3 bytes total上面是装箱过后的Boolean，可以看到虽然Boolean最后占用16bytes，但是里面的boolean只有1byte。
byte翻译成中文就是字节，字节是java中存储的基本单位。
有了字节，我们就可以解释字符了，字符就是由字节组成的，根据编码方式的不同，字符可以有1个，2个或者多个字节组成。我们人类可以肉眼识别的汉字呀，英文什么的都可以看做是字符。
而Reader就是按照一定编码格式读取的字符，而InputStream就是直接读取的更加底层的字节。
小师妹：我懂了，如果是文本文件我们就可以用Reader，非文本文件我们就可以用InputStream。
孺子可教，小师妹进步的很快。
按字符读取的方式
小师妹，接下来F师兄给你讲下按字符读取文件的几种方式，第一种就是使用FileReader来读取File，但是FileReader本身并没有提供任何读取数据的方法，想要真正的读取数据，我们还是要用到BufferedReader来连接FileReader，BufferedReader提供了读取的缓存，可以一次读取一行：
public void withFileReader() throws IOException {
File file = new File("src/main/resources/www.flydean.com");
try (FileReader fr = new FileReader(file); BufferedReader br = new BufferedReader(fr)) {
String line;
while ((line = br.readLine()) != null) {
if (line.contains("www.flydean.com")) {
log.info(line);
}
}
}
}每次读取一行，可以把这些行连起来就组成了stream，通过Files.lines，我们获取到了一个stream，在stream中我们就可以使用lambda表达式来读取文件了，这是谓第二种方式：
public void withStream() throws IOException {
Path filePath = Paths.get("src/main/resources", "www.flydean.com");
try (Stream<String> lines = Files.lines(filePath))
{
List<String> filteredLines = lines.filter(s -> s.contains("www.flydean.com"))
.collect(Collectors.toList());
filteredLines.forEach(log::info);
}
}第三种其实并不常用，但是师兄也想教给你。这一种方式就是用工具类中的Scanner。通过Scanner可以通过换行符来分割文件，用起来也不错：
public void withScanner() throws FileNotFoundException {
FileInputStream fin = new FileInputStream(new File("src/main/resources/www.flydean.com"));
Scanner scanner = new Scanner(fin,"UTF-8").useDelimiter("\n");
String theString = scanner.hasNext() ? scanner.next() : "";
log.info(theString);
scanner.close();
}按字节读取的方式
小师妹听得很满足，连忙催促我：F师兄，字符读取方式我都懂了，快将字节读取吧。
我点了点头，小师妹，哲学的本质还记得吗？字节就是java存储的本质。掌握到本质才能勘破一切虚伪。
还记得之前讲过的Files工具类吗？这个工具类提供了很多文件操作相关的方法，其中就有读取所有bytes的方法，小师妹要注意了，这里是一次性读取所有的字节！一定要慎用，只可用于文件较少的场景，切记切记。
public void readBytes() throws IOException {
Path path = Paths.get("src/main/resources/www.flydean.com");
byte[] data = Files.readAllBytes(path);
log.info("{}",data);
}如果是比较大的文件，那么可以使用FileInputStream来一次读取一定数量的bytes：
public void readWithStream() throws IOException {
File file = new File("src/main/resources/www.flydean.com");
byte[] bFile = new byte[(int) file.length()];
try(FileInputStream fileInputStream = new FileInputStream(file))
{
fileInputStream.read(bFile);
for (int i = 0; i < bFile.length; i++) {
log.info("{}",bFile[i]);
}
}
}Stream读取都是一个字节一个字节来读的，这样做会比较慢，我们使用NIO中的FileChannel和ByteBuffer来加快一些读取速度：
public void readWithBlock() throws IOException {
try (RandomAccessFile aFile = new RandomAccessFile("src/main/resources/www.flydean.com", "r");
FileChannel inChannel = aFile.getChannel();) {
ByteBuffer buffer = ByteBuffer.allocate(1024);
while (inChannel.read(buffer) > 0) {
buffer.flip();
for (int i = 0; i < buffer.limit(); i++) {
log.info("{}", buffer.get());
}
buffer.clear();
}
}
}小师妹：如果是非常非常大的文件的读取，有没有更快的方法呢？
当然有，记得上次我们讲过的虚拟地址空间的映射吧：
我们可以直接将用户的地址空间和系统的地址空间同时map到同一个虚拟地址内存中，这样就免除了拷贝带来的性能开销：
public void copyWithMap() throws IOException{
try (RandomAccessFile aFile = new RandomAccessFile("src/main/resources/www.flydean.com", "r");
FileChannel inChannel = aFile.getChannel()) {
MappedByteBuffer buffer = inChannel.map(FileChannel.MapMode.READ_ONLY, 0, inChannel.size());
buffer.load();
for (int i = 0; i < buffer.limit(); i++)
{
log.info("{}", buffer.get());
}
buffer.clear();
}
}寻找出错的行数
小师妹：好赞！F师兄你讲得真好，小师妹我还有一个问题：最近在做文件解析，有些文件格式不规范，解析到一半就解析失败了，但是也没有个错误提示到底错在哪一行，很难定位问题呀，有没有什么好的解决办法？
看看天色已经不早了，师兄就再教你一个方法，java中有一个类叫做LineNumberReader，使用它来读取文件可以打印出行号，是不是就满足了你的需求：
public void useLineNumberReader() throws IOException {
try(LineNumberReader lineNumberReader = new LineNumberReader(new FileReader("src/main/resources/www.flydean.com")))
{
//输出初始行数
log.info("Line {}" , lineNumberReader.getLineNumber());
//重置行数
lineNumberReader.setLineNumber(2);
//获取现有行数
log.info("Line {} ", lineNumberReader.getLineNumber());
//读取所有文件内容
String line = null;
while ((line = lineNumberReader.readLine()) != null)
{
log.info("Line {} is : {}" , lineNumberReader.getLineNumber() , line);
}
}
}总结
今天给小师妹讲解了字符流和字节流，还讲解了文件读取的基本方法，不虚此行。
第五章 文件写入那些事
简介
小师妹又对F师兄提了一大堆奇奇怪怪的需求，要格式化输出，要特定的编码输出，要自己定位输出，什么？还要阅后即焚？大家看F师兄怎么一一接招吧。
字符输出和字节输出
小师妹：F师兄，上次你的IO讲到了一半，文件读取是基本上讲完了，但是文件的写入还没有讲，什么时候给小师妹我再科普科普？
小师妹：F师兄，你知道我这个人一直以来都是勤奋好学的典范，是老师们眼中的好学生,同学们心中的好榜样,父母身边乖巧的好孩子。在我永攀科学高峰的时候，居然发现还有一半的知识没有获取，真是让我扼腕叹息，F师兄，快快把知识传给我吧。
小师妹你的请求，师兄我自当尽力办到，但是我怎么记得上次讲IO文件读取已经过了好几天了，怎么今天你才来找我。
小师妹红着脸：F师兄，这不是使用的时候遇到了点问题，才想找你把知识再复习一遍。
那先把输出类的结构再过一遍：
上面就是输出的两大系统了：Writer和OutputStream。
Writer主要针对于字符，而Stream主要针对Bytes。
Writer中最最常用的就是FileWriter和BufferedWriter,我们看下一个最基本写入的例子：
public void useBufferedWriter() throws IOException {
String content = "www.flydean.com";
File file = new File("src/main/resources/www.flydean.com");
FileWriter fw = new FileWriter(file);
try(BufferedWriter bw = new BufferedWriter(fw)){
bw.write(content);
}
}BufferedWriter是对FileWriter的封装，它提供了一定的buffer机制，可以提高写入的效率。
其实BufferedWriter提供了三种写入的方式：
public void write(int c)
public void write(char cbuf[], int off, int len)
public void write(String s, int off, int len)第一个方法传入一个int，第二个方法传入字符数组和开始读取的位置和长度，第三个方法传入字符串和开始读取的位置和长度。是不是很简单，完全可以理解？
小师妹：不对呀，F师兄，后面两个方法的参数，不管是char和String都是字符我可以理解，第一个方法传入int是什么鬼？
小师妹，之前跟你讲的道理是不是都忘记的差不多了，int的底层存储是bytes,char和String的底层存储也是bytes，我们把int和char做个强制转换就行了。我们看下是怎么转换的：
public void write(int c) throws IOException {
synchronized (lock) {
ensureOpen();
if (nextChar >= nChars)
flushBuffer();
cb[nextChar++] = (char) c;
}
}还记得int需要占用多少个字节吗？4个，char需要占用2个字节。这样强制从int转换到char会有精度丢失的问题，只会保留低位的2个字节的数据，高位的两个字节的数据会被丢弃，这个需要在使用中注意。
看完Writer，我们再来看看Stream：
public void useFileOutputStream() throws IOException {
String str = "www.flydean.com";
try(FileOutputStream outputStream = new FileOutputStream("src/main/resources/www.flydean.com");
BufferedOutputStream bufferedOutputStream= new BufferedOutputStream(outputStream)){
byte[] strToBytes = str.getBytes();
bufferedOutputStream.write(strToBytes);
}
}跟Writer一样，BufferedOutputStream也是对FileOutputStream的封装，我们看下BufferedOutputStream中提供的write方法：
public synchronized void write(int b)
public synchronized void write(byte b[], int off, int len)比较一下和Writer的区别，BufferedOutputStream的方法是synchronized的，并且BufferedOutputStream是直接对byte进行操作的。
第一个write方法传入int参数也是需要进行截取的，不过这次是从int转换成byte。
格式化输出
小师妹：F师兄，我们经常用的System.out.println可以直接向标准输出中输出格式化过后的字符串，文件的写入是不是也有类似的功能呢？
肯定有，PrintWriter就是做格式化输出用的：
public void usePrintWriter() throws IOException {
FileWriter fileWriter = new FileWriter("src/main/resources/www.flydean.com");
try(PrintWriter printWriter = new PrintWriter(fileWriter)){
printWriter.print("www.flydean.com");
printWriter.printf("程序那些事 %s ", "非常棒");
}
}输出其他对象
小师妹：F师兄，我们看到可以输出String，char还有Byte，那可不可以输出Integer,Long等基础类型呢？
可以的，使用DataOutputStream就可以做到：
public void useDataOutPutStream()
throws IOException {
String value = "www.flydean.com";
try(FileOutputStream fos = new FileOutputStream("src/main/resources/www.flydean.com")){
DataOutputStream outStream = new DataOutputStream(new BufferedOutputStream(fos));
outStream.writeUTF(value);
}
}DataOutputStream提供了writeLong,writeDouble,writeFloat等等方法，还可以writeUTF！
在特定的位置写入
小师妹：F师兄，有时候我们不需要每次都从头开始写入到文件，能不能自定义在什么位置写入呢？
使用RandomAccessFile就可以了：
public void useRandomAccess() throws IOException {
try(RandomAccessFile writer = new RandomAccessFile("src/main/resources/www.flydean.com", "rw")){
writer.seek(100);
writer.writeInt(50);
}
}RandomAccessFile可以通过seek来定位，然后通过write方法从指定的位置写入。
给文件加锁
小师妹：F师兄，最后还有一个问题，怎么保证我在进行文件写的时候别人不会覆盖我写的内容，不会产生冲突呢？
FileChannel可以调用tryLock方法来获得一个FileLock锁，通过这个锁，我们可以控制文件的访问。
public void useFileLock()
throws IOException {
try(RandomAccessFile stream = new RandomAccessFile("src/main/resources/www.flydean.com", "rw");
FileChannel channel = stream.getChannel()){
FileLock lock = null;
try {
lock = channel.tryLock();
} catch (final OverlappingFileLockException e) {
stream.close();
channel.close();
}
stream.writeChars("www.flydean.com");
lock.release();
}
}总结
今天给小师妹将了好多种文件的写的方法，够她学习一阵子了。
第六章 目录还是文件
简介
目录和文件傻傻分不清楚，目录和文件的本质到底是什么？在java中怎么操纵目录，怎么遍历目录。本文F师兄会为大家一一讲述。
linux中的文件和目录
小师妹：F师兄，我最近有一个疑惑，java代码中好像只有文件没有目录呀，是不是当初发明java的大神，一步小心走了神？
F师兄:小师妹真勇气可嘉呀，敢于质疑权威是从小工到专家的最重要的一步。想想F师兄我，从小没人提点，老师讲什么我就信什么，专家说什么我就听什么:股市必上一万点，房子是给人住的不是给人炒的,原油宝当然是小白理财必备产品….然后，就没有然后了。
更多内容请访问www.flydean.com
虽然java中没有目录的概念只有File文件，而File其实是可以表示目录的：
public boolean isDirectory()File中有个isDirectory方法，可以判断该File是否是目录。
File和目录傻傻分不清楚，小师妹，有没有联想到点什么？
小师妹：F师兄，我记得你上次讲到Linux下面所有的资源都可以看做是文件，在linux下面文件和目录的本质是不是一样的？
对的，在linux下面文件是一等公民，所有的资源都是以文件的形式来区分的。
什么扇区，逻辑块，页之类的底层结构我们就不讲了。我们先考虑一下一个文件到底应该包含哪些内容。除了文件本身的数据之外，还有很多元数据的东西，比如文件权限，所有者，group，创建时间等信息。
在linux系统中，这两个部分是分开存储的。存放数据本身的叫做block，存放元数据的叫做inode。
inode中存储了block的地址，可以通过inode找到文件实际数据存储的block地址，从而进行文件访问。考虑一下大文件可能占用很多个block，所以一个inode中可以存储多个block的地址，而一个文件通常来说使用一个inode就够了。
为了显示层级关系和方便文件的管理，目录的数据文件中存放的是该目录下的文件和文件的inode地址，从而形成了一种一环套一环，圆环套圆环的链式关系。
上图列出了一个通过目录查找其下文件的环中环布局。
我想java中目录没有单独列出来一个类的原因可能是参考了linux底层的文件布局吧。
目录的基本操作
因为在java中目录和文件是公用File这个类的，所以File的基本操作目录它全都会。
基本上，目录和文件相比要多注意下面三类方法：
public boolean isDirectory()
public File[] listFiles()
public boolean mkdir() 为什么说是三类呢？因为还有几个和他们比较接近的方法，这里就不一一列举了。
isDirectory判断该文件是不是目录。listFiles列出该目录下面的所有文件。mkdir创建一个文件目录。
小师妹:F师兄，之前我们还以目录的遍历要耗费比较长的时间，经过你一讲解目录的数据结构，感觉listFiles并不是一个耗时操作呀，所有的数据都已经准备好了，直接读取出来就行。
对，看问题不要看表面，要看到隐藏在表面的本质内涵。你看师兄我平时不显山露水，其实是真正的中流砥柱，堪称公司优秀员工模范。
小师妹:F师兄，那平时也没看上头表彰你啥的？哦，我懂了，一定是老板怕表彰了你引起别人的嫉妒，会让你的好好大师兄的形象崩塌吧，看来老板真的懂你呀。
目录的进阶操作
好了小师妹，你懂了就行，下面F师兄给你讲一下目录的进阶操作，比如我们怎么拷贝一个目录呀？
小师妹，拷贝目录简单的F师兄，上次你就教我了：
cp -rf一个命令的事情不就解决了吗？难道里面还隐藏了点秘密？
咳咳咳，秘密倒是没有，小师妹，我记得你上次说要对java从一而终的，今天师兄给你介绍一个在java中拷贝文件目录的方法。
其实Files工具类里已经为我们提供了一个拷贝文件的优秀方法：
public static Path copy(Path source, Path target, CopyOption... options)使用这个方法，我们就可以进行文件的拷贝了。
如果想要拷贝目录，就遍历目录中的文件，循环调用这个copy方法就够了。
小师妹：且慢，F师兄，如果目录下面还有目录的，目录下还套目录的情况该怎么处理？
这就是圈套呀，看我用个递归的方法解决它：
public void useCopyFolder() throws IOException {
File sourceFolder = new File("src/main/resources/flydean-source");
File destinationFolder = new File("src/main/resources/flydean-dest");
copyFolder(sourceFolder, destinationFolder);
}
private static void copyFolder(File sourceFolder, File destinationFolder) throws IOException
{
//如果是dir则递归遍历创建dir，如果是文件则直接拷贝
if (sourceFolder.isDirectory())
{
//查看目标dir是否存在
if (!destinationFolder.exists())
{
destinationFolder.mkdir();
log.info("目标dir已经创建: {}",destinationFolder);
}
for (String file : sourceFolder.list())
{
File srcFile = new File(sourceFolder, file);
File destFile = new File(destinationFolder, file);
copyFolder(srcFile, destFile);
}
}
else
{
//使用Files.copy来拷贝具体的文件
Files.copy(sourceFolder.toPath(), destinationFolder.toPath(), StandardCopyOption.REPLACE_EXISTING);
log.info("拷贝目标文件: {}",destinationFolder);
}
}基本思想就是遇到目录我就遍历，遇到文件我就拷贝。
目录的腰疼操作
小师妹：F师兄，假如我想删除一个目录中的文件，或者我们想统计一下这个目录下面到底有多少个文件该怎么做呢？
虽然这些操作有点腰疼，还是可以解决的，Files工具类中有个方法叫做walk，返回一个Stream对象，我们可以使用Stream的API来对文件进行处理。
删除文件：
public void useFileWalkToDelete() throws IOException {
Path dir = Paths.get("src/main/resources/flydean");
Files.walk(dir)
.sorted(Comparator.reverseOrder())
.map(Path::toFile)
.forEach(File::delete);
}统计文件：
public void useFileWalkToSumSize() throws IOException {
Path folder = Paths.get("src/test/resources");
long size = Files.walk(folder)
.filter(p -> p.toFile().isFile())
.mapToLong(p -> p.toFile().length())
.sum();
log.info("dir size is: {}",size);
}总结
本文介绍了目录的一些非常常见和有用的操作。
第七章 文件系统和WatchService
简介
小师妹这次遇到了监控文件变化的问题，F师兄给小师妹介绍了JDK7 nio中引入的WatchService，没想到又顺道普及了一下文件系统的概念，万万没想到。
监控的痛点
小师妹：F师兄最近你有没有感觉到呼吸有点困难，后领有点凉飕飕的，说话有点不顺畅的那种？
没有啊小师妹，你是不是秋衣穿反了？
小师妹：不是的F师兄，我讲的是心里的感觉，那种莫须有的压力，还有一丝悸动缠绕在心。
别绕弯子了小师妹，是不是又遇到问题了。
更多内容请访问www.flydean.com
小师妹：还是F师兄懂我，这不上次的Properties文件用得非常上手，每次修改Properties文件都要重启java应用程序，真的是很痛苦。有没有什么其他的办法呢？
办法当然有，最基础的办法就是开一个线程定时去监控属性文件的最后修改时间，如果修改了就重新加载，这样不就行了。
小师妹：写线程啊，这么麻烦，有没有什么更简单的办法呢？
就知道你要这样问，还好我准备的比较充分，今天给你介绍一个JDK7在nio中引入的类WatchService。
WatchService和文件系统
WatchService是JDK7在nio中引入的接口：
监控的服务叫做WatchService，被监控的对象叫做Watchable：
WatchKey register(WatchService watcher,
WatchEvent.Kind<?>[] events,
WatchEvent.Modifier... modifiers)
throws IOException;
WatchKey register(WatchService watcher, WatchEvent.Kind<?>... events)
throws IOException;Watchable通过register将该对象的WatchEvent注册到WatchService上。从此只要有WatchEvent发生在Watchable对象上，就会通知WatchService。
WatchEvent有四种类型：
- ENTRY_CREATE 目标被创建
- ENTRY_DELETE 目标被删除
- ENTRY_MODIFY 目标被修改
- OVERFLOW 一个特殊的Event，表示Event被放弃或者丢失
register返回的WatchKey就是监听到的WatchEvent的集合。
现在来看WatchService的4个方法：
- close 关闭watchService
- poll 获取下一个watchKey，如果没有则返回null
- 带时间参数的poll 在等待的一定时间内获取下一个watchKey
- take 获取下一个watchKey，如果没有则一直等待
小师妹：F师兄，那怎么才能构建一个WatchService呢？
上次文章中说的文件系统，小师妹还记得吧，FileSystem中就有一个获取WatchService的方法：
public abstract WatchService newWatchService() throws IOException;我们看下FileSystem的结构图：
在我的mac系统上，FileSystem可以分为三大类，UnixFileSystem，JrtFileSystem和ZipFileSystem。我猜在windows上面应该还有对应的windows相关的文件系统。小师妹你要是有兴趣可以去看一下。
小师妹：UnixFileSystem用来处理Unix下面的文件，ZipFileSystem用来处理zip文件。那JrtFileSystem是用来做什么的？
哎呀，这就又要扯远了，为什么每次问问题都要扯到天边….
从前当JDK还是9的时候，做了一个非常大的改动叫做模块化JPMS（Java Platform Module System），这个Jrt就是为了给模块化系统用的，我们来举个例子：
public void useJRTFileSystem(){
String resource = "java/lang/Object.class";
URL url = ClassLoader.getSystemResource(resource);
log.info("{}",url);
}上面一段代码我们获取到了Object这个class的url，我们看下如果是在JDK8中，输出是什么：
jar:file:/Library/Java/JavaVirtualMachines/jdk1.8.0_171.jdk/Contents/Home/jre/lib/rt.jar!/java/lang/Object.class输出结果是jar:file表示这个Object class是放在jar文件中的，后面是jar文件的路径。
如果是在JDK9之后：
jrt:/java.base/java/lang/Object.class结果是jrt开头的，java.base是模块的名字，后面是Object的路径。看起来是不是比传统的jar路径更加简洁明了。
有了文件系统，我们就可以在获取系统默认的文件系统的同时，获取到相应的WatchService：
WatchService watchService = FileSystems.getDefault().newWatchService();WatchSerice的使用和实现本质
小师妹：F师兄，WatchSerice是咋实现的呀？这么神奇，为我们省了这么多工作。
其实JDK提供了这么多类的目的就是为了不让我们重复造轮子，之前跟你讲监控文件的最简单办法就是开一个独立的线程来监控文件变化吗？其实…..WatchService就是这样做的！
PollingWatchService() {
// TBD: Make the number of threads configurable
scheduledExecutor = Executors
.newSingleThreadScheduledExecutor(new ThreadFactory() {
@Override
public Thread newThread(Runnable r) {
Thread t = new Thread(null, r, "FileSystemWatcher", 0, false);
t.setDaemon(true);
return t;
}});
}上面的方法就是生成WatchService的方法，小师妹看到没有，它的本质就是开启了一个daemon的线程，用来接收监控任务。
下面看下怎么把一个文件注册到WatchService上面：
private void startWatcher(String dirPath, String file) throws IOException {
WatchService watchService = FileSystems.getDefault().newWatchService();
Path path = Paths.get(dirPath);
path.register(watchService, ENTRY_MODIFY);
Runtime.getRuntime().addShutdownHook(new Thread(() -> {
try {
watchService.close();
} catch (IOException e) {
log.error(e.getMessage());
}
}));
WatchKey key = null;
while (true) {
try {
key = watchService.take();
for (WatchEvent<?> event : key.pollEvents()) {
if (event.context().toString().equals(fileName)) {
loadConfig(dirPath + file);
}
}
boolean reset = key.reset();
if (!reset) {
log.info("该文件无法重置");
break;
}
} catch (Exception e) {
log.error(e.getMessage());
}
}
}上面的关键方法就是path.register，其中Path是一个Watchable对象。
然后使用watchService.take来获取生成的WatchEvent，最后根据WatchEvent来处理文件。
总结
道生一，一生二，二生三，三生万物。一个简简单单的功能其实背后隐藏着…道德经，哦，不对，背后隐藏着道的哲学。
第八章 文件File和路径Path
简介
文件和路径有什么关系？文件和路径又隐藏了什么秘密？在文件系统的管理下，创建路径的方式又有哪些？今天F师兄带小师妹再给大家来一场精彩的表演。
文件和路径
小师妹：F师兄我有一个问题，java中的文件File是一个类可以理解，因为文件里面包含了很多其他的信息，但是路径Path为什么也要单独一个类出来？只用一个String表示不是更简单？
更多内容请访问www.flydean.com
万物皆有因，没有无缘无故的爱，也没有无缘无故的恨。一切真的是妙不可言啊。
我们来看下File和path的定义：
public class File
implements Serializable, Comparable<File>public interface Path
extends Comparable<Path>, Iterable<Path>, Watchable首先，File是一个类，它表示的是所有的文件系统都拥有的属性和功能，不管你是windows还是linux，他们中的File对象都应该是一样的。
File中包含了Path，小师妹你且看，Path是一个interface,为什么是一个interface呢？因为Path根据不同的情况可以分为JrtPath，UnixPath和ZipPath。三个Path所对应的FileSystem我们在上一篇文章中已经讨论过了。所以Path的实现是不同的，但是包含Path的File是相同的。
小师妹：F师兄，这个怎么这么拗口，给我来一个直白通俗的解释吧。
既然这样，且听我解释：爱国版的，或许我们属于不同的民族，但是我们都是中国人。通俗版的，大家都是文化人儿，为啥就你这么拽。文化版的，同九年，汝何秀？
再看两者的实现接口，File实现了Serializable表示可以被序列化，实现了Comparable，表示可以被排序。
Path继承Comparable，表示可以被排序。继承Iterable表示可以被遍历，可以被遍历是因为Path可以表示目录。继承Watchable，表示可以被注册到WatchService中，进行监控。
文件中的不同路径
小师妹：F师兄，File中有好几个关于Path的get方法，能讲一下他们的不同之处吗？
直接上代码：
public void getFilePath() throws IOException {
File file= new File("../../www.flydean.com.txt");
log.info("name is : {}",file.getName());
log.info("path is : {}",file.getPath());
log.info("absolutePath is : {}",file.getAbsolutePath());
log.info("canonicalPath is : {}",file.getCanonicalPath());
}File中有三个跟Path有关的方法，分别是getPath，getAbsolutePath和getCanonicalPath。
getPath返回的结果就是new File的时候传入的路径，输入什么返回什么。
getAbsolutePath返回的是绝对路径，就是在getPath前面加上了当前的路径。
getCanonicalPath返回的是精简后的AbsolutePath，就是去掉了.或者..之类的指代符号。
看下输出结果：
INFO com.flydean.FilePathUsage - name is : www.flydean.com.txt
INFO com.flydean.FilePathUsage - path is : ../../www.flydean.com.txt
INFO com.flydean.FilePathUsage - absolutePath is : /Users/flydean/learn-java-io-nio/file-path/../../www.flydean.com.txt
INFO com.flydean.FilePathUsage - canonicalPath is : /Users/flydean/www.flydean.com.txt构建不同的Path
小师妹：F师兄，我记得路径有相对路径，绝对路径等，是不是也有相应的创建Path的方法呢？
当然有的，先看下绝对路径的创建：
public void getAbsolutePath(){
Path absolutePath = Paths.get("/data/flydean/learn-java-io-nio/file-path", "src/resource","www.flydean.com.txt");
log.info("absolutePath {}",absolutePath );
}我们可以使用Paths.get方法传入绝对路径的地址来构建绝对路径。
同样使用Paths.get方法，传入非绝对路径可以构建相对路径。
public void getRelativePath(){
Path RelativePath = Paths.get("src", "resource","www.flydean.com.txt");
log.info("absolutePath {}",RelativePath.toAbsolutePath() );
}我们还可以从URI中构建Path：
public void getPathfromURI(){
URI uri = URI.create("file:///data/flydean/learn-java-io-nio/file-path/src/resource/www.flydean.com.txt");
log.info("schema {}",uri.getScheme());
log.info("default provider absolutePath {}",FileSystems.getDefault().provider().getPath(uri).toAbsolutePath().toString());
}也可以从FileSystem构建Path：
public void getPathWithFileSystem(){
Path path1 = FileSystems.getDefault().getPath(System.getProperty("user.home"), "flydean", "flydean.txt");
log.info(path1.toAbsolutePath().toString());
Path path2 = FileSystems.getDefault().getPath("/Users", "flydean", "flydean.txt");
log.info(path2.toAbsolutePath().toString());
}总结
好多好多Path的创建方法，总有一款适合你。快来挑选吧。
第九章 Buffer和Buff
简介
小师妹在学习NIO的路上越走越远，唯一能够帮到她的就是在她需要的时候给她以全力的支持。什么都不说了，今天介绍的是NIO的基础Buffer。老铁给我上个Buff。
Buffer是什么
小师妹：F师兄，这个Buffer是我们纵横王者峡谷中那句：老铁给我加个Buff的意思吗？
当然不是了，此Buffer非彼Buff，Buffer是NIO的基础，没有Buffer就没有NIO，没有Buffer就没有今天的java。
因为NIO是按Block来读取数据的，这个一个Block就可以看做是一个Buffer。我们在Buffer中存储要读取的数据和要写入的数据，通过Buffer来提高读取和写入的效率。
更多内容请访问www.flydean.com
还记得java对象的底层存储单位是什么吗？
小师妹：这个我知道，java对象的底层存储单位是字节Byte。
对，我们看下Buffer的继承图：
Buffer是一个接口，它下面有诸多实现，包括最基本的ByteBuffer和其他的基本类型封装的其他Buffer。
小师妹：F师兄，有ByteBuffer不就够了吗？还要其他的类型Buffer做什么？
小师妹，山珍再好，也有吃腻的时候，偶尔也要换个萝卜白菜啥的，你以为乾隆下江南都干了些啥？
ByteBuffer虽然好用，但是它毕竟是最小的单位，在它之上我们还有Char，int，Double，Short等等基础类型，为了简单起见，我们也给他们都搞一套Buffer。
Buffer进阶
小师妹：F师兄，既然Buffer是这些基础类型的集合，为什么不直接用结合来表示呢？给他们封装成一个对象，好像有点多余。
我们既然在面向对象的世界，从表面来看自然是使用Object比较合乎情理，从底层的本质上看，这些封装的Buffer包含了一些额外的元数据信息，并且还提供了一些意想不到的功能。
上图列出了Buffer中的几个关键的概念，分别是Capacity，Limit，Position和Mark。Buffer底层的本质是数组，我们以ByteBuffer为例，它的底层是：
final byte[] hb; - Capacity表示的是该Buffer能够承载元素的最大数目，这个是在Buffer创建初期就设置的，不可以被改变。
- Limit表示的Buffer中可以被访问的元素个数，也就是说Buffer中存活的元素个数。
- Position表示的是下一个可以被访问元素的index，可以通过put和get方法进行自动更新。
- Mark表示的是历史index，当我们调用mark方法的时候，会把设置Mark为当前的position，通过调用reset方法把Mark的值恢复到position中。
创建Buffer
小师妹：F师兄呀，这么多Buffer创建起来是不是很麻烦？有没有什么快捷的使用办法？
一般来说创建Buffer有两种方法，一种叫做allocate，一种叫做wrap。
public void createBuffer(){
IntBuffer intBuffer= IntBuffer.allocate(10);
log.info("{}",intBuffer);
log.info("{}",intBuffer.hasArray());
int[] intArray=new int[10];
IntBuffer intBuffer2= IntBuffer.wrap(intArray);
log.info("{}",intBuffer2);
IntBuffer intBuffer3= IntBuffer.wrap(intArray,2,5);
log.info("{}",intBuffer3);
intBuffer3.clear();
log.info("{}",intBuffer3);
log.info("{}",intBuffer3.hasArray());
}allocate可以为Buffer分配一个空间，wrap同样为Buffer分配一个空间，不同的是这个空间背后的数组是自定义的，wrap还支持三个参数的方法，后面两个参数分别是offset和length。
INFO com.flydean.BufferUsage - java.nio.HeapIntBuffer[pos=0 lim=10 cap=10]
INFO com.flydean.BufferUsage - true
INFO com.flydean.BufferUsage - java.nio.HeapIntBuffer[pos=0 lim=10 cap=10]
INFO com.flydean.BufferUsage - java.nio.HeapIntBuffer[pos=2 lim=7 cap=10]
INFO com.flydean.BufferUsage - java.nio.HeapIntBuffer[pos=0 lim=10 cap=10]
INFO com.flydean.BufferUsage - truehasArray用来判断该Buffer的底层是不是数组实现的，可以看到，不管是wrap还是allocate，其底层都是数组。
需要注意的一点，最后，我们调用了clear方法，clear方法调用之后，我们发现Buffer的position和limit都被重置了。这说明wrap的三个参数方法设定的只是初始值，可以被重置。
Direct VS non-Direct
小师妹：F师兄，你说了两种创建Buffer的方法，但是两种Buffer的后台都是数组，难道还有非数组的Buffer吗？
自然是有的,但是只有ByteBuffer有。ByteBuffer有一个allocateDirect方法，可以分配Direct Buffer。
小师妹：Direct和非Direct有什么区别呢？
Direct Buffer就是说，不需要在用户空间再复制拷贝一份数据，直接在虚拟地址映射空间中进行操作。这叫Direct。这样做的好处就是快。缺点就是在分配和销毁的时候会占用更多的资源，并且因为Direct Buffer不在用户空间之内，所以也不受垃圾回收机制的管辖。
所以通常来说只有在数据量比较大，生命周期比较长的数据来使用Direct Buffer。
看下代码：
public void createByteBuffer() throws IOException {
ByteBuffer byteBuffer= ByteBuffer.allocateDirect(10);
log.info("{}",byteBuffer);
log.info("{}",byteBuffer.hasArray());
log.info("{}",byteBuffer.isDirect());
try (RandomAccessFile aFile = new RandomAccessFile("src/main/resources/www.flydean.com", "r");
FileChannel inChannel = aFile.getChannel()) {
MappedByteBuffer buffer = inChannel.map(FileChannel.MapMode.READ_ONLY, 0, inChannel.size());
log.info("{}",buffer);
log.info("{}",buffer.hasArray());
log.info("{}",buffer.isDirect());
}
}除了allocateDirect,使用FileChannel的map方法也可以得到一个Direct的MappedByteBuffer。
上面的例子输出结果：
INFO com.flydean.BufferUsage - java.nio.DirectByteBuffer[pos=0 lim=10 cap=10]
INFO com.flydean.BufferUsage - false
INFO com.flydean.BufferUsage - true
INFO com.flydean.BufferUsage - java.nio.DirectByteBufferR[pos=0 lim=0 cap=0]
INFO com.flydean.BufferUsage - false
INFO com.flydean.BufferUsage - trueBuffer的日常操作
小师妹:F师兄，看起来Buffer确实有那么一点复杂，那么Buffer都有哪些操作呢？
Buffer的操作有很多，下面我们一一来讲解。
向Buffer写数据
向Buffer写数据可以调用Buffer的put方法：
public void putBuffer(){
IntBuffer intBuffer= IntBuffer.allocate(10);
intBuffer.put(1).put(2).put(3);
log.info("{}",intBuffer.array());
intBuffer.put(0,4);
log.info("{}",intBuffer.array());
}因为put方法返回的还是一个IntBuffer类，所以Buffer的put方法可以像Stream那样连写。
同时，我们还可以指定put在什么位置。上面的代码输出：
INFO com.flydean.BufferUsage - [1, 2, 3, 0, 0, 0, 0, 0, 0, 0]
INFO com.flydean.BufferUsage - [4, 2, 3, 0, 0, 0, 0, 0, 0, 0]从Buffer读数据
读数据使用get方法，但是在get方法之前我们需要调用flip方法。
flip方法是做什么用的呢？上面讲到Buffer有个position和limit字段，position会随着get或者put的方法自动指向后面一个元素，而limit表示的是该Buffer中有多少可用元素。
如果我们要读取Buffer的值则会从positon开始到limit结束：
public void getBuffer(){
IntBuffer intBuffer= IntBuffer.allocate(10);
intBuffer.put(1).put(2).put(3);
intBuffer.flip();
while (intBuffer.hasRemaining()) {
log.info("{}",intBuffer.get());
}
intBuffer.clear();
}可以通过hasRemaining来判断是否还有下一个元素。通过调用clear来清除Buffer，以供下次使用。
rewind Buffer
rewind和flip很类似，不同之处在于rewind不会改变limit的值，只会将position重置为0。
public void rewindBuffer(){
IntBuffer intBuffer= IntBuffer.allocate(10);
intBuffer.put(1).put(2).put(3);
log.info("{}",intBuffer);
intBuffer.rewind();
log.info("{}",intBuffer);
}上面的结果输出：
INFO com.flydean.BufferUsage - java.nio.HeapIntBuffer[pos=3 lim=10 cap=10]
INFO com.flydean.BufferUsage - java.nio.HeapIntBuffer[pos=0 lim=10 cap=10]Compact Buffer
Buffer还有一个compact方法，顾名思义compact就是压缩的意思，就是把Buffer从当前position到limit的值赋值到position为0的位置：
public void useCompact(){
IntBuffer intBuffer= IntBuffer.allocate(10);
intBuffer.put(1).put(2).put(3);
intBuffer.flip();
log.info("{}",intBuffer);
intBuffer.get();
intBuffer.compact();
log.info("{}",intBuffer);
log.info("{}",intBuffer.array());
}上面代码输出：
INFO com.flydean.BufferUsage - java.nio.HeapIntBuffer[pos=0 lim=3 cap=10]
INFO com.flydean.BufferUsage - java.nio.HeapIntBuffer[pos=2 lim=10 cap=10]
INFO com.flydean.BufferUsage - [2, 3, 3, 0, 0, 0, 0, 0, 0, 0]duplicate Buffer
最后我们讲一下复制Buffer，有三种方法，duplicate，asReadOnlyBuffer，和slice。
duplicate就是拷贝原Buffer的position，limit和mark，它和原Buffer是共享原始数据的。所以修改了duplicate之后的Buffer也会同时修改原Buffer。
如果用asReadOnlyBuffer就不允许拷贝之后的Buffer进行修改。
slice也是readOnly的，不过它拷贝的是从原Buffer的position到limit-position之间的部分。
public void duplicateBuffer(){
IntBuffer intBuffer= IntBuffer.allocate(10);
intBuffer.put(1).put(2).put(3);
log.info("{}",intBuffer);
IntBuffer duplicateBuffer=intBuffer.duplicate();
log.info("{}",duplicateBuffer);
IntBuffer readOnlyBuffer=intBuffer.asReadOnlyBuffer();
log.info("{}",readOnlyBuffer);
IntBuffer sliceBuffer=intBuffer.slice();
log.info("{}",sliceBuffer);
}输出结果：
INFO com.flydean.BufferUsage - java.nio.HeapIntBuffer[pos=3 lim=10 cap=10]
INFO com.flydean.BufferUsage - java.nio.HeapIntBuffer[pos=3 lim=10 cap=10]
INFO com.flydean.BufferUsage - java.nio.HeapIntBufferR[pos=3 lim=10 cap=10]
INFO com.flydean.BufferUsage - java.nio.HeapIntBuffer[pos=0 lim=7 cap=7]总结
今天给小师妹介绍了Buffer的原理和基本操作。
第十章 File copy和File filter
简介
一个linux命令的事情，小师妹非要让我教她怎么用java来实现，哎，摊上个这么杠精的小师妹，我也是深感无力，做一个师兄真的好难。
使用java拷贝文件
今天小师妹找到我了：F师兄，能告诉怎么拷贝文件吗？
拷贝文件？不是很简单的事情吗？如果你有了文件的读权限，只需要这样就可以了。
cp www.flydean.com www.flydean.com.back当然，如果是目录的话还可以加两个参数遍历和强制拷贝：
cp -rf srcDir distDir这么简单的linux命令，不要告诉我你不会。
小师妹笑了：F师兄，我不要用linux命令，我就想用java来实现，我不正在学java吗？学一门当然要找准机会来练习啦，快快教教我吧。
既然这样，那我就开讲了。java中文件的拷贝其实也有三种方法，可以使用传统的文件读写的方法，也可以使用最新的NIO中提供的拷贝方法。
使用传统方法当然没有NIO快，也没有NIO简洁，我们先来看看怎么使用传统的文件读写的方法来拷贝文件：
public void copyWithFileStreams() throws IOException
{
File fileToCopy = new File("src/main/resources/www.flydean.com");
File newFile = new File("src/main/resources/www.flydean.com.back");
newFile.createNewFile();
try(FileOutputStream output = new FileOutputStream(newFile);FileInputStream input = new FileInputStream(fileToCopy)){
byte[] buf = new byte[1024];
int bytesRead;
while ((bytesRead = input.read(buf)) > 0)
{
output.write(buf, 0, bytesRead);
}
}
}上面的例子中，我们首先定义了两个文件，然后从两个文件中生成了OutputStream和InputStream，最后以字节流的形式从input中读出数据到outputStream中，最终完成了文件的拷贝。
传统的File IO拷贝比较繁琐，速度也比较慢。我们接下来看看怎么使用NIO来完成这个过程：
public void copyWithNIOChannel() throws IOException
{
File fileToCopy = new File("src/main/resources/www.flydean.com");
File newFile = new File("src/main/resources/www.flydean.com.back");
try(FileInputStream inputStream = new FileInputStream(fileToCopy);FileOutputStream outputStream = new FileOutputStream(newFile)){
FileChannel inChannel = inputStream.getChannel();
FileChannel outChannel = outputStream.getChannel();
inChannel.transferTo(0, fileToCopy.length(), outChannel);
}
}之前我们讲到NIO中一个非常重要的概念就是channel,通过构建源文件和目标文件的channel通道，可以直接在channel层面进行拷贝，如上面的例子所示，我们调用了inChannel.transferTo完成了拷贝。
最后，还有一个更简单的NIO文件拷贝的方法：
public void copyWithNIOFiles() throws IOException
{
Path source = Paths.get("src/main/resources/www.flydean.com");
Path destination = Paths.get("src/main/resources/www.flydean.com.back");
Files.copy(source, destination, StandardCopyOption.REPLACE_EXISTING);
}直接使用工具类Files提供的copy方法即可。
使用File filter
太棒了，小师妹一脸崇拜：F师兄，我还有一个需求，就是想删除某个目录里面的以.log结尾的日志文件，这个需求是不是很常见？F师兄一般是怎么操作的？
一般这种操作我都是一个linux命令就搞定了，如果搞不定那就用两个：
rm -rf *.log当然，如果需要，我们也是可以用java来实现的。
java中提供了两个Filter都可以用来实现这个功能。
这两个Filter是java.io.FilenameFilter和java.io.FileFilter:
@FunctionalInterface
public interface FilenameFilter {
boolean accept(File dir, String name);
}@FunctionalInterface
public interface FileFilter {
boolean accept(File pathname);
}这两个接口都是函数式接口，所以他们的实现可以直接用lambda表达式来代替。
两者的区别在于，FilenameFilter进行过滤的是文件名和文件所在的目录。而FileFilter进行过滤的直接就是目标文件。
在java中是没有目录的概念的，一个目录也是用File的表示的。
上面的两个使用起来非常类似，我们就以FilenameFilter为例，看下怎么删除.log文件：
public void useFileNameFilter()
{
String targetDirectory = "src/main/resources/";
File directory = new File(targetDirectory);
//Filter out all log files
String[] logFiles = directory.list( (dir, fileName)-> fileName.endsWith(".log"));
//If no log file found; no need to go further
if (logFiles.length == 0)
return;
//This code will delete all log files one by one
for (String logfile : logFiles)
{
String tempLogFile = targetDirectory + File.separator + logfile;
File fileDelete = new File(tempLogFile);
boolean isdeleted = fileDelete.delete();
log.info("file : {} is deleted : {} ", tempLogFile , isdeleted);
}
}上面的例子中，我们通过directory.list方法，传入lambda表达式创建的Filter，实现了过滤的效果。
最后，我们将过滤之后的文件删除。实现了目标。
总结
小师妹的两个问题解决了，希望今天可以不要再见到她。
第十一章 NIO中Channel的妙用
简介
小师妹，你还记得我们使用IO和NIO的初心吗？
小师妹：F师兄，使用IO和NIO不就是为了让生活更美好，世界充满爱吗？让我等程序员可以优雅的将数据从一个地方搬运到另外一个地方。利其器，善其事，才有更多的时间去享受生活呀。
善，如果将数据比做人，IO，NIO的目的就是把人运到美国。
小师妹：F师兄，为什么要运到美国呀，美国现在新冠太严重了，还是待在中国吧。中国是世界上最安全的国家！
好吧，为了保险起见，我们要把人运到上海。人就是数据，怎么运过去呢？可以坐飞机，坐汽车，坐火车，这些什么飞机，汽车，火车就可以看做是一个一个的Buffer。
最后飞机的航线，汽车的公路和火车的轨道就可以看做是一个个的channel。
简单点讲，channel就是负责运送Buffer的通道。
IO按源头来分，可以分为两种，从文件来的File IO，从Stream来的Stream IO。不管哪种IO，都可以通过channel来运送数据。
Channel的分类
虽然数据的来源只有两种，但是JDK中Channel的分类可不少，如下图所示：
先来看看最基本的，也是最顶层的接口Channel：
public interface Channel extends Closeable {
public boolean isOpen();
public void close() throws IOException;
}最顶层的Channel很简单，继承了Closeable接口，需要实现两个方法isOpen和close。
一个用来判断channel是否打开，一个用来关闭channel。
小师妹：F师兄，顶层的Channel怎么这么简单，完全不符合Channel很复杂的人设啊。
别急，JDK这么做其实也是有道理的，因为是顶层的接口，必须要更加抽象更加通用，结果，一通用就发现还真的就只有这么两个方法是通用的。
所以为了应对这个问题，Channel中定义了很多种不同的类型。
最最底层的Channel有5大类型，分别是：
FileChannel
这5大channel中，和文件File有关的就是这个FileChannel了。
FileChannel可以从RandomAccessFile, FileInputStream或者FileOutputStream中通过调用getChannel()来得到。
也可以直接调用FileChannel中的open方法传入Path创建。
public abstract class FileChannel
extends AbstractInterruptibleChannel
implements SeekableByteChannel, GatheringByteChannel, ScatteringByteChannel我们看下FileChannel继承或者实现的接口和类。
AbstractInterruptibleChannel实现了InterruptibleChannel接口，interrupt大家都知道吧，用来中断线程执行的利器。来看一下下面一段非常玄妙的代码：
protected final void begin() {
if (interruptor == null) {
interruptor = new Interruptible() {
public void interrupt(Thread target) {
synchronized (closeLock) {
if (closed)
return;
closed = true;
interrupted = target;
try {
AbstractInterruptibleChannel.this.implCloseChannel();
} catch (IOException x) { }
}
}};
}
blockedOn(interruptor);
Thread me = Thread.currentThread();
if (me.isInterrupted())
interruptor.interrupt(me);
}上面这段代码就是AbstractInterruptibleChannel的核心所在。
首先定义了一个Interruptible的实例，这个实例中有一个interrupt方法，用来关闭Channel。
然后获得当前线程的实例，判断当前线程是否Interrupted，如果是的话，就调用Interruptible的interrupt方法将当前channel关闭。
SeekableByteChannel用来连接Entry或者File。它有一个独特的属性叫做position，表示当前读取的位置。可以被修改。
GatheringByteChannel和ScatteringByteChannel表示可以一次读写一个Buffer序列结合（Buffer Array）：
public long write(ByteBuffer[] srcs, int offset, int length)
throws IOException;
public long read(ByteBuffer[] dsts, int offset, int length)
throws IOException;Selector和Channel
在讲其他几个Channel之前，我们看一个和下面几个channel相关的Selector：
这里要介绍一个新的Channel类型叫做SelectableChannel，之前的FileChannel的连接是一对一的，也就是说一个channel要对应一个处理的线程。而SelectableChannel则是一对多的，也就是说一个处理线程可以通过Selector来对应处理多个channel。
SelectableChannel通过注册不同的SelectionKey，实现对多个Channel的监听。后面我们会具体的讲解Selector的使用，敬请期待。
DatagramChannel
DatagramChannel是用来处理UDP的Channel。它自带了Open方法来创建实例。
来看看DatagramChannel的定义：
public abstract class DatagramChannel
extends AbstractSelectableChannel
implements ByteChannel, ScatteringByteChannel, GatheringByteChannel, MulticastChannelByteChannel表示它同时是ReadableByteChannel也是WritableByteChannel，可以同时写入和读取。
MulticastChannel代表的是一种多播协议。正好和UDP对应。
SocketChannel
SocketChannel是用来处理TCP的channel。它也是通过Open方法来创建的。
public abstract class SocketChannel
extends AbstractSelectableChannel
implements ByteChannel, ScatteringByteChannel, GatheringByteChannel, NetworkChannelSocketChannel跟DatagramChannel的唯一不同之处就是实现的是NetworkChannel借口。
NetworkChannel提供了一些network socket的操作，比如绑定地址等。
ServerSocketChannel
ServerSocketChannel也是一个NetworkChannel，它主要用在服务器端的监听。
public abstract class ServerSocketChannel
extends AbstractSelectableChannel
implements NetworkChannelAsynchronousSocketChannel
最后AsynchronousSocketChannel是一种异步的Channel：
public abstract class AsynchronousSocketChannel
implements AsynchronousByteChannel, NetworkChannel为什么是异步呢？我们看一个方法：
public abstract Future<Integer> read(ByteBuffer dst);可以看到返回值是一个Future，所以read方法可以立刻返回，只在我们需要的时候从Future中取值即可。
使用Channel
小师妹：F师兄，讲了这么多种类的Channel，看得我眼花缭乱，能不能讲一个Channel的具体例子呢？
好的小师妹，我们现在讲一个使用Channel进行文件拷贝的例子，虽然Channel提供了transferTo的方法可以非常简单的进行拷贝，但是为了能够看清楚Channel的通用使用，我们选择一个更加常规的例子：
public void useChannelCopy() throws IOException {
FileInputStream input = new FileInputStream ("src/main/resources/www.flydean.com");
FileOutputStream output = new FileOutputStream ("src/main/resources/www.flydean.com.txt");
try(ReadableByteChannel source = input.getChannel(); WritableByteChannel dest = output.getChannel()){
ByteBuffer buffer = ByteBuffer.allocateDirect(1024);
while (source.read(buffer) != -1)
{
// flip buffer,准备写入
buffer.flip();
// 查看是否有更多的内容
while (buffer.hasRemaining())
{
dest.write(buffer);
}
// clear buffer，供下一次使用
buffer.clear();
}
}
}上面的例子中我们从InputStream中读取Buffer，然后写入到FileOutputStream。
总结
今天讲解了Channel的具体分类，和一个简单的例子，后面我们会再体验一下Channel的其他例子，敬请期待。
总结
千辛万苦终于解决了小师妹的问题，F师兄要休息一下。
本文的例子https://github.com/ddean2009/learn-java-io-nio
本文PDF下载链接java-io-all-in-one.pdf
本文作者：flydean程序那些事 本文链接：http://www.flydean.com/java-io-all-in-one/
原创声明：本文系作者授权腾讯云开发者社区发表，未经许可，不得转载。
如有侵权，请联系 cloudcommunity@tencent.com 删除。
原创声明：本文系作者授权腾讯云开发者社区发表，未经许可，不得转载。
如有侵权，请联系 cloudcommunity@tencent.com 删除。