1.获得File路径和检测状态:
操作File路径和名称:
File getAbsoluteFile() :获取绝对路径
String getAbsolutePath():获取绝对路径
String getPath() :获取文件路径
String getName() :获取文件名称
File getParentFile():获取上级目录文件
String getParent() :获取上级目录路径
检测File状态的方法:
boolean canExecute() :判断是否是可执行文件
boolean canRead() :判断该文件是否可读
boolean canWrite():判断该文件是否可写
boolean isHidden():判断该文件是否是隐藏文件
long lastModified():判断该文件的最后修改时间
long length():获取该文件的长度大小(单位字节)
import java.io.File;
//系统平台的分隔符
public class FileDemo1 {
public static void main(String[] args) {
/**
* static String pathSeparator
* static char pathSeparatorcChar
* static String Separator
* static char SeparatorChar
*/
// 获取属性分隔符
String pathSeparator = File.pathSeparator;
char pathSeparatorChar = File.pathSeparatorChar;
System.out.println(pathSeparator); // ;
System.out.println(pathSeparatorChar);// ;
// 获取路径分隔符
String Separator = File.separator;
char SeparatorChar = File.separatorChar;
System.out.println(Separator); // \
System.out.println(SeparatorChar);// \
System.out.println("===========");
// 表示一个文件的路径
String path1 = "c:\\will\\123.txt";
String path2 = "c:/will/123.txt"; //推荐. win和unix下都可以
String path3 = "c:" + File.separator + "will" + File.separator
+ "123.txt";
System.out.println(path3);
}
}
2.文件操作
import java.io.File;
import java.io.IOException;
import java.util.Arrays;
public class FileDemo2 {
public static void main(String[] args) throws IOException {
/*
* //创建File对象 的几种方式
//File(String pathname),通过将给定路径名字符串转换为抽象路径名来创建一个新 File 实例
File f1 = new File("c:abc/123.txt");
//File(String parent, String child)根据 parent 路径名字符串和 child 路径名字符串创建一个新 File 实例
File f2 = new File("c:abc","123.txt");
File dir = new File("c:abc");
File f3= new File(dir,"123.txt");
System.out.println(f1);
System.out.println(f2);
System.out.println(f3);
*/
text1();
// text2();
//text3();
test4();
}
private static void test4() {
/*
* File类中方法-目录操作
boolean isDirectory() :判断是否是目录
boolean mkdir() :创建当前目录 (只能创建一级目录)
boolean mkdirs() :创建当前目录和上级目录
String[] list() :列出所有的文件名
File[] listFiles() :列出所有文件对象
boolean renameTo(File dest) :重新修改名称
static File[] listRoots() :列出系统盘符
boolean delete() :删除文件
*/
File dir = new File("C:/IOtest/abc");
File f4 = new File(dir,"123.txt");
System.out.println(dir.isDirectory()); //true
System.out.println(f4.isDirectory());//false
//dir.mkdir(); //只能创建一级目录
dir.mkdirs(); //可以创建多级目录 (当前不录不存在的时候创建 ,返回一个false)
System.out.println("=========");
// String[] names = dir.list();//(当前目录下的全部文件夹和文件名)
// for (String file : names) {
// System.out.println(file);
// }
File[] files = dir.listFiles();
System.out.println(Arrays.toString(files));
System.out.println(f4.delete());
}
private static void text3() throws IOException {
/*File类中方法-文件操作:
boolean isFile() :是否是文件
boolean createNewFile() :创建新的文件
static File createTempFile(String prefix, String suffix) :创建临时文件
boolean delete() :删除文件
void deleteOnExit() :在JVM停止时删除文件
boolean exists():判断文件是否存在
boolean renameTo(File dest) :重新修改名称*/
File f3 = new File("C:/IOtest/abc/456.txt");
System.out.println(f3.isFile());
System.out.println(f3.exists());
//如果"C:/IOtest/abc/456.txt"不存在的话就创建该文件
if (!f3.exists()) {
f3.createNewFile();//(该方法只能用来创建文件, 不能创建目录)
}else{
f3.renameTo(new File("C:/IOtest/abc/XXXX.txt"));//改名
}
}
private static void text2() {
/*检测File状态的方法:
boolean canExecute() :判断是否是可执行文件
boolean canRead() :判断该文件是否可读
boolean canWrite():判断该文件是否可写
boolean isHidden():判断该文件是否是隐藏文件
long lastModified():判断该文件的最后修改时间
long length():获取该文件的长度大小(单位字节)*/
File f2 = new File("C:/IOtest/abc/123.txt");
System.out.println(f2.getAbsoluteFile());
System.out.println(f2.canExecute());
System.out.println("1" + f2.canRead());
System.out.println(f2.lastModified());
System.out.println(f2.canWrite());
System.out.println(f2.length());
}
private static void text1() {
/*操作File路径和名称:
File getAbsoluteFile() :获取绝对路径
String getAbsolutePath():获取绝对路径
String getPath() :获取文件路径
String getName() :获取文件名称
File getParentFile():获取上级目录文件
String getParent() :获取上级目录路径
*/
File f1 = new File("c:/abc/123.txt");
File f10 = new File("c:/abc");
System.out.println(f1.getAbsoluteFile());
System.out.println(f1.getAbsolutePath());
System.out.println(f1.getName());
System.out.println("1 " + f1.getPath());
System.out.println("2 " + f1.getParentFile());
System.out.println("222 " + f10.getParentFile());
}
}
3.文件目录操作
import java.io.File;
import java.util.Arrays;
//需求:列出指定目录中所有的文件,包括子文件夹中的所有文件(使用递归算法(recursion)).
public class FileDemo3 {
public static void main(String[] args) {
//创建一个指定的文件夹路径
File dir = new File("C:/Users/Lin/Desktop/笔记");
listAllFile(dir);
//dir.list();
//System.out.println(Arrays.toString(dir.list()));
}
public static void listAllFile(File f){
File[] fs = f.listFiles();//列出所有的文件对象
for (File file : fs) {
System.out.println(file);
if (file.isDirectory()) { //判断当前文件是不是目录文件
// File[] fs2 = file.listFiles();//列出所有的文件对象
listAllFile(file);
}
}
}
}
4.列出文件分层结构
import java.io.File;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
//列出文件的分层结构
//C:/Users/Lin/Desktop/笔记/day16数据结构笔记.xls
// 步骤 : 得到文件名, 通过文件名找父目录,一直往上找.根目录返回一个盘符 为空
public class FileDemo4 {
public static void main(String[] args) {
String f = "C:/Users/Lin/Desktop/笔记/day16数据结构笔记.xls";
File file = new File(f); // 得到一个文件夹对象
// 将得到的所有父目录名称存放在一个集合里面. 有序.可重复
List<String> parentName = new ArrayList<>();// 文件路径 有序的,可重复的 所以选用List
listAllName(parentName, file);
Collections.reverse(parentName); // 点颠元素倒顺序
StringBuilder sb = new StringBuilder(50);
for (String ele : parentName) {
sb.append(ele).append(">");
}
sb.deleteCharAt(sb.length() - 1);
System.out.println(sb);
}
private static void listAllName(List<String> parentName, File file) {
// String s = file.getParentFile().getName(); //得到 笔记
// System.out.println(s);
if (!"".equals(file.getParentFile().getName())) {
parentName.add(file.getParentFile().getName());
}
if (file.getParentFile().getParentFile() != null) { // 判断当前文件对象是否还有父目录
listAllName(parentName, file.getParentFile()); // 有父目录继续调用方法 ,直到返回
// null
}
}
}
5.文件过滤器
import java.io.File;
import java.io.FilenameFilter;
//文件过滤器
public class FileDemo6 {
public static void main(String[] args) {
File dir = new File("C:/IOtest/abc");// 指定路径
File[] fs = dir.listFiles(new FilenameFilter() {
@Override
public boolean accept(File dir, String name) {
//判断当前对象是文件且以规定的字符结尾
if (new File(dir, name).isFile() && name.endsWith(".java")) {
return true; // 返回值为true的时候存入集合中
} else {
return false;
}
}
});
for (File file : fs) {
System.out.println(file);
}
}
}
6.IO操作
IO流的分类和操作模板:
IO流的分类,站在不同的角度,分类方式是不一样滴:
1):根据流向划分: 输入流和输出流.
2):根据数据的单位划分: 字节流和字符流.
3):根据功能的划分:节点流和包装流.
四大基流:(字节输出流,字节输入流,字符输出流,字符输入流)
四大基流都是抽象类: 其他流都是继承于这四大基流的.
我们不能创建四大基流的对象,只能创建其子类对象.
无论是什么流,都有close方法,用来关闭资源.
如果操作文件,就得开通一个流对象关联我们得磁盘文件,如果不关闭资源,那么磁盘的文件一直被程序所引用着,不能删除,也不能更改.
操作IO流的模板:
1):创建源或者目标对象(挖井).
拿文件流举例:
输入操作: 把文件中的数据流向到程序中,此时文件是源,程序是目标.
输出操作: 把程序中的数据流向到文件中,此时文件是目标,程序是源.
2):创建IO流对象(水管).
输入操作: 创建输入流对象.
输出操作: 创建输出流对象.
3):具体的IO操作.
输入操作: 输入流对象的read方法.
输出操作: 输出流对象的write方法.
4):关闭资源(勿忘). 一旦资源关闭之后,就不能使用流对象了,否则报错.
输入操作: 输入流对象.close();
输出操作: 输出流对象.close().
操作IO流的六字箴言:
读进来,写出去.
读进来: 进来强调了是输入, 读说明是read方法.
写出去: 出去强调了是输出,写说明是write方法.
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
public class CloseResourceDemo {
public static void main(String[] args) {
InputStream in = null;
OutputStream out = null;
try {
// 可能出现的异常
// 1.创建源和目标
File srcf = new File(“C:/IOtest/stream/123.txt”);
File destf = new File(“C:/IOtest/stream/123_copy.txt”);
// 2.创建输入流和输出对象
in = new FileInputStream(srcf);
out = new FileOutputStream(destf);
// 3.读取/写出操作
byte[] buffer = new byte[5];// 创建容量为5的缓冲区(存储已经读取到的数据)
int len = -1;// 返回-1 表示读取完毕
while ((len = in.read(buffer)) != -1) {
// 将数据从buffer中写出去
out.write(buffer, 0, len);
}
} catch (Exception e) {
// 处理异常
e.printStackTrace();
} finally {
// 4.关闭管道
try {
if (in == null) {
in.close();
}
} catch (IOException e) {
e.printStackTrace();
}
try {
if (out == null) {
out.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
7.文件流
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.util.Arrays;
//文件字节输入流
public class FileInputStreamDemo {
public static void main(String[] args) throws IOException {
// 1.创建源(挖井)
File f = new File("C:/IOtest/stream/123.txt");
// 2.创建文件字节输入流对象,并接在源上
InputStream in = new FileInputStream(f);
// 3.具体的读取操作 当读取到最后的时候没有数据的时候 返回 -1 判断结束
/* int read();// 只读取一个字节,返回读取的字节
* int read(byte[] b) //将文件中的数据存到数组里,在从数组索引为0的位置开始读取
* int read(byte[] b, int off,int len) //将文件从索引off的位置开始读取 读取到的数据存放在b中
*/
//int data = in.read(); //读取当前文件里面的第一个字节
byte[] buffer = new byte[5];//此时buffer中最多可以存储5个字节
System.out.println(Arrays.toString(buffer));
//System.out.println(Arrays.toString(buffer));
// in.read(buffer); //返回的为读取的字节数,读取完毕返回-1
//System.out.println(ret);
int len = -1;
while((len = in.read(buffer))!= -1){
String str = new String(buffer,0,len);
System.out.print(str);
}
// 4.关闭资源
in.close();
}
}
8.刷新
flush(刷新)操作,输出流中都有flush方法:
计算机访问外部设备(磁盘文件),要比直接访问内存慢很多,如果每次write都要直接写出到磁盘文件中,CPU都会花更多的时间,此时我们可以准备一个内存缓冲区,程序每次write方法都是直接写到内存缓冲区中,当内存缓冲区满后,系统才把缓冲区内容一次性写出给磁盘文件.
使用缓冲区的好处:
1:提高CPU使用率.
2:有机会回滚写入的数据.
对于字节流,flush方法不是都有作用(部分字节流才有作用,缓冲流),对于字符流都起作用.
如果我们调用close方法,系统在关闭资源前,会先调用flush方法.
操作系统使用-1表示磁盘文件的结尾标记.
缓冲区大小一般使用容量整数倍,可以提高IO性能.
9.解码与编码
字符的编码和解码操作:
编码: 把字符串转换为byte数组.
解码: 把byte数组转换为字符串.
一定要保证编码和解码的字符相同,否则乱码.
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.Arrays;
//编码和解码
// UTF-8(3个字节) , GBK(2个字节) ISO-8859-1(1个字节)
//编码 把字符串转化为数组
//解码 把数组转化为字符串
public class EncodingDemo {
public static void main(String[] args) throws IOException {
String str = "广州小码哥";
//将String转为 UTF-8的数组
byte[] data = str.getBytes("UTF-8");
System.out.println(Arrays.toString(data));
//将data转为ISO-8859-1的字符串
String ret = new String(data,"ISO-8859-1");
System.out.println(ret); //????·??°???????
byte[] data2 = ret.getBytes("ISO-8859-1");
String ret2 = new String(data,"UTF-8");
System.out.println(ret2);
}
}
10.缓冲流
处理流/包装流(相对于节点流更高级)装饰设计模式/包装模式:
1:隐藏了底层的节点流的差异,并对外提供了更方便的输入/输出功能,让我们只关心高级流的操作.
2:使用处理流包装了节点流,程序直接操作处理流,让节点流与底层的设备做IO操作.
3:只需要关闭处理流即可.
包装流如何区分:写代码的时候,发现创建对象对象的时候,需要传递另一个流对象.
new 包装流( 流对象 ) ;
什么是缓冲流:
是一个包装流,目的起缓冲作用.
BufferedInputStream:
BufferedOutputStream:
BufferedReader:
BufferedWriter:
缓冲流的目的:
操作流的时候,习惯定义一个byte/char数组.
int read():每次都从磁盘文件中读取一个字节. 直接操作磁盘文件性能极低.
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
//字节缓冲流
public class BufferedStreamDemo {
public static void main(String[] args) throws Exception {
//字节缓冲输出流
File f = new File("C:/IOtest/bufferreader/123.txt");
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(f,true));
bos.write("abcdefg".getBytes());
bos.close();
//字节缓冲输入流
File f2 = new File("C:/IOtest/bufferreader/123.txt");
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(f2));
byte[] buffer = new byte[1024];
int len = -1 ;
while((len = bis.read(buffer))!= -1){
System.out.println(new String(buffer,0,len));
}
bis.close();
}
}
11.转换流
转换流:把字节流转成字符流:
InputStreamReader:把字节输入流转成字符输入流.
OutputStreamWriter:把字节输出流转成字符输出流.
为什么有字节转字符流,没有字符转字节流.
字节流可以操作一切文件(纯文本文件/二进制文件).
字符流是用来操作中文纯文本使用的,本身是对字节流的增强
12.内存流（适配器模式）
内存流(数组流):适配器模式:
把数据先临时存在数组中,待会再从数组中获取出来.
1):字节内存流: ByteArrayInputStream/ByteArrayOutputStream
2):字符内存流: CharArrayReader/CharArrayWriter
3):字符串流:StringReader/StringWriter(把数据临时存储到字符串中)
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
//字节的数组刘(内存流)
public class ByteArrayDemo {
public static void main(String[] args) throws Exception {
// 字节数组输出流 : 程序-->内存
ByteArrayOutputStream bos = new ByteArrayOutputStream();
bos.write("abcde".getBytes());
// 要使用存储的临时数据
byte[] buffer = bos.toByteArray();
// 字节输入流 内存-->程序
ByteArrayInputStream bis = new ByteArrayInputStream(buffer);
byte[] bys = new byte[10];
int len = -1;
while ((len = bis.read(bys)) != -1) {
System.out.println(new String(bys, 0, len));
}
bis.close();
bos.close();
}
}
13.合并流
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.SequenceInputStream;
//顺序刘/合并流
public class SequenceInputStreamDemo {
public static void main(String[] args) throws Exception {
File f1 = new File("C:/IOtest/transform/123.txt");
File f2 = new File("C:/IOtest/transform/456.txt");
SequenceInputStream in = new SequenceInputStream(new FileInputStream(f1),new FileInputStream(f2));
byte[] ch = new byte[1024];
int len = -1 ;
while((len = in.read(ch))!= -1 ){
System.out.println(new String(ch,0,len));
}
in.close();
}
}
14.序列化
序列化和反序列化:
序 列 化: 指把堆内存中的Java对象数据,通过某种方式把对象存储到磁盘文件中或者传递给其他网络的节点(在网络上传输).
我们把这个过程称之为序列化.
反序列化:把磁盘文件中的对象数据或者把网络节点上的对象数据,恢复成Java对象的过程.
为什么要做序列化:
1):在分布式系统中,需要共享的数据的JavaBean对象,都得做序列化,此时需要把对象再网络上传输,此时就得把对象数据转换为二进制形式.
以后存储在HttpSession中的对象,都应该实现序列化接口(只有实现序列化接口的类,才能做序列化操作).
2):服务钝化:如果服务发现某些对象好久都没有活动了,此时服务器就会把这些内存中的对象,持久化在本地磁盘文件中(Java对象–>二进制文件).
如果某些对象需要活动的时候,现在内存中去寻找,找到就使用,找不到再去磁盘文件中,反序列化我们得对象数据,恢复成Java对象.
需要做序列化的对象的类,必须实现序列化接口:java.io.Serializable接口(标志接口[没有抽象方法]).
底层会判断,如果当前对象是Serializable的实例,才允许做序列化. boolean ret = Java对象 instanceof Serializable;
在Java中大多数类都已经实现Serializable接口.
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
//使用对象流来实现序列化和反序列化
//需要用对象装数据 ,所以建user
//做序列化的对象必须实现java.io.Serializable接口 对象只能调用自己编译类型里面的方法
public class ObjectStreamDemo {
public static void main(String[] args) throws Exception {
File f = new File("C:/IOtest/objStream/123.txt");
//writeObject(f);
ReaderObject(f);
}
//反序列化操作 :把磁盘文件中的对象数据或者把网络节点上的对象数据,恢复成Java对象的过程.
private static void ReaderObject(File f) throws Exception, Exception {
ObjectInputStream in = new ObjectInputStream(new FileInputStream(f));
UserDemo user = (UserDemo)in.readObject();
System.out.println(user);
in.close();
}
//序列化操作:把堆内存中的Java对象数据,通过某种方式把对象存储到磁盘文件中或者传递给其他网络的节点(
private static void writeObject(File f) throws Exception {
//对象只能调用自己编译类型里面的方法 Object不能省略
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(f));
out.writeObject(new UserDemo("linwei","3333",18));//将对象内容写入文件
out.close();
}
}
15.打印流
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintStream;
//字节打印流
public class PrintStreamDemo {
public static void main(String[] args) throws Exception {
//PrintStream ps = new PrintStream(new File("C:/IOtest/printstream.txt"));
PrintStream ps = new PrintStream(new FileOutputStream(new File("C:/IOtest/printstream.txt"),true));//true是带自动刷新
ps.write("abbbaaa".getBytes());
ps.print(true); //可以往文件打印任意类型的数据
ps.close();
}
}
16.标准IO
标准的IO:
标准的输入: 通过键盘录入数据给程序.
标准的输出: 在屏幕上显示程序数据.
在System类中有两个常量:
InputStream in = System.in;
PrintStream out = System.out;
标准流的重定向操作:
标准的输入: 通过键盘录入数据给程序.
重新指定输入的源不再是键盘,而是一个文件.
static void setIn(InputStream in) 重新分配“标准”输入流。
此后,System.in数据的来源就是通过setIn制定的源.
标准的输出: 在屏幕上显示程序数据.
重新指定输出的目标不再是屏幕,而是一个文件.
static void setOut(PrintStream out) 重新分配“标准”输出流。
public class SystemIODemo {
public static void main(String[] args) throws Exception {
// System.out.println("begin..");
// int data = System.in.read();// 接收键盘录入的一个字节 /标准输入
// System.out.println(data); // 标准输出
// System.out.println("end..");
// 重新定向标准输入流
System.setIn(new FileInputStream("C:/IOtest/stream/123.txt"));
// 重新定向标准输出流
System.setOut(new PrintStream("C:/IOtest/stream/123_copy.txt"));
System.out.println("begin..");
int data = System.in.read();
System.out.println(data);
System.out.println("end..");
}
}
17.扫描器类
import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;
//可以从指定文件扫描内容进去 , 表示输入操作 , 还可以指定某种编码方式
public class ScannerDemo {
public static void main(String[] args) throws Exception {
// 扫描文件中的数据
Scanner sc= new Scanner(new
File("C:/IOtest/bufferreader/123.txt"),"GBK");
// 扫描键盘输入的数据
//Scanner sc = new Scanner(System.in);
// 扫面字符串的数据
// Scanner sc = new Scanner("拉丁舞小王子-张大猪");
while (sc.hasNextLine()) {
String line = sc.nextLine();
System.out.println("ECHO " + line);
}
sc.close();
}
}
18.Properities类加载对象
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;
import java.util.Properties;
//加载properties文件
//db文件是专门为数据库提供的一个配置文件.里面存储数据库连接的相关信息
public class LocalPropertiesDemo {
public static void main(String[] args) throws Exception {
// 创建Properties对象
// 必须使用Properties类(Hashtable的子类,Map接口的实现类).
Properties p = new Properties();
InputStream inStream = new FileInputStream(
"C:/Users/Lin/Desktop/Project/IO/bin/com/_520it/day03/_05_properties/db.properties");
// load(InputStream inStream) 从输入流中读取属性列表（键和元素对）。
p.load(inStream);// 加载之后.数据都在p对象中;
System.out.println(p);
System.out.println("账号 : " +p.getProperty("username"));
System.out.println("密码 : " +p.getProperty("password"));
}
}
19.数据流
数据流,提供了可以读/写任意数据类型的方法:
DataOutputStream: 提供了 writeXxx(xxx value)方法.
DataInputStream: 提供了 readXxx()方法.
注意: writeXxx和readXxx必须要对应起来, writeByte写出的数据,此时只能使用readByte读取回来.
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
//数据流
public class DataStreamDemo {
public static void main(String[] args) throws Exception {
File f = new File("C:/IOtest/data/data.txt");
//write(f);
read(f);
}
private static void read(File f) throws Exception {
DataInputStream in = new DataInputStream(new FileInputStream(f));
System.out.println(in.readByte());
System.out.println(in.readChar());//只能用相对应的方式来读取
System.out.println(in.readUTF());
//System.out.println(in.readInt());
in.close();
}
private static void write(File f) throws Exception {
DataOutputStream out = new DataOutputStream(new FileOutputStream(f));
out.writeByte(66);// byte
out.writeChar('穷');// char
out.writeUTF("天王盖地虎!");// string
out.close();
}
}
20.NIO
NIO:New IO:
从JDK1.4开始提出的,新的IO,可以把一块磁盘文件映射到内存中,我们再去读取内存中的数据.
存放在java.nio包中.
Java NIO（New IO）是从Java 1.4版本开始引入的一个新的IO API，可以替代标准的Java IO API
现在主要运用于服务器中,对于我们写代码依然使用传统的IO就够了.
在JDK1.7中提取出更新的IO,NIO2.0.–>Files(文件工具类).
21.总结
四大基流:
InputStream---- OutputStream
Reader ---- Writer
IO流的总结和梳理:
文件流:
FileInputStream
FileOutputStream
FileReader
FileWriter
缓冲流:
BufferedInputStream
BufferedOutputStream
BufferedReader
BufferedWriter
转换流(把字节转换为字符):
InputStreamReader
OutputStreamWriter
内存流(临时存储数据):
ByteArrayInputStream
ByteArrayOutputStream
CharArrayReader
CharArrayWriter
StringReader
StringWriter
顺序流(合并流):
SequenceInputStream
对象流(序列化和反序列化):
ObjectInputStream
ObjectOutputStream
打印流:
PrintStream
PrintWriter
数据流:
DataInputStream
DataOutputStream
管道流:
PipedInputStream
PipedOutputStream
PipedReader
PipedWriter
File
FIlenameFilter
RandomAccessFile
Files