1、File类 java.io.File
1.1 File类简介
（1）File类的一个对象，代表一个文件或一个文件目录（文件夹）
（2）File能新建、删除、重命名文件和目录,但File不能访问文件内容本身。如果需要访问文件内容本身,则需要使用输入/输出流。
（3）想要在Java程序中表示一个真实存在的文件或目录,那么必须有一个File对象,但是Java程序中的一个File对象,可能没有一个真实存在的文件或目录。
（4）File类中涉及到关于文件或文件目录的创建、删除、重命名、修改时间、文件大小等方法,并未涉及到写入或读取文件内容的操作。如果需要读取或写入文件内容，必须使用IO流来完成。
（5）后续File类的对象常会作为参数传递到流的构造器中，指明读取或写入的“终端”。（此时File主要指文件，不是文件目录）
1.2 常用构造器 查字典
注意事项：在不同操作系统中，路径分割符是不一样的。
windows系统：\\
unix:/
（1）public File(String pathname)以pathname为路径创建File对象,可以是绝对路径或者相对路径,如果pathname是相对路径,则默认的当前路径在系统属性user.dir中存储（Idea中，会在当前工程的Module下）。（创建文件）
① 绝对路径:是一个固定的路径,从盘符开始，即包含盘符在内的文件或文件目录的路径
File file1 = new File("D:\\workspace_idea1\\JavaSenior\\he.txt");
说明：在D:\workspace_idea1\JavaSenior\文件夹下创建一个he.txt 文件。由于Java中\会被转义，所以写成\\
② 相对路径（默认）:是相对于某个路径下，指明路径。（IDEA中是相对于当前Module所在的文件夹）
File file2 = new File("hello.txt"); //相对于当前module的位置
（2）public File(String parent,String child)
以parent为父路径, child为文件夹名，创建File对象，创建文件夹
File file3 = new File("D:\\workspace_idea1","JavaSenior");//在D:\\workspace_idea1目录下，创建JavaSenior文件夹
（3）public File(File parent,String child)
根据一个父File对象为路径，在此路径下创建一个名为child的文件
File file4 = new File(file3,"hi.txt"); //在file3文件夹下（D:\\workspace_idea1），创造“hi.txt”文件
说明：构造器构造出的File对象，还是存储在内存层面，还没有拷贝到硬盘上
1.3 File类的常用方法 查字典 （很多都是桌面下对文件或文件夹点右键，属性 看到的内容 ）
File类中涉及到关于文件或文件目录的创建、删除、重命名、修改时间、文件大小等方法
（1）File类的获取功能
public String getAbsolutePath():获取绝对路径
public String getPath() :获取路径
public String getName():获取名称
public String getParent):获取上层文件目录路径。若无,返回null
public long length() :获取文件长度(即:字书数) 。不能获取目录的长度。
public long lastModified() :获取最后一次的修改时间,毫秒值
如下两个方法适用于文件目录
public String[ ] list() :获取指定目录下的所有文件或者文件目录的名称数组
public File[ ] listFiles() :获取指定目录下的所有文件或者文件目录的File数组
（2）File类的重命名功能
public boolean renameTo(File dest):把文件重命名为指定的文件路径
（3）File类的判断功能
public boolean isDirectory():判断是否是文件目录（文件夹）
public boolean isFile() :判断是否是文件
public boolean exists():判断是否存在 （指硬盘中是否存在）
public boolean canRead() :判断是否可读
public boolean canWrite() :判断是否可写public boolean isHidden() :判断是否隐藏
（4）File类的创建功能 （真的在硬盘上创建）
public boolean createNewFile():创建文件。若文件存在,则不创建,返回false
public boolean mkdir() :创建文件目录。如果此文件目录存在,就不创建了。如果此文件目录的上层目录不存在,也不创建。
public boolean mkdirs() :创建文件目录。如果上层文件目录不存在,一并创建
注意事项:如果你创建文件或者文件目录没有写盘符路径,那么,默认在项目路径下。
（5）File类的删除功能 （删除硬盘上的文件或文件目录）
public boolean delete():删除文件或者文件夹
注意事项：Java中的删除，不走回收站。因此要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录。
2、Java I/O流原理
（1）概述
I/O是Input/Output的缩写, I/O技术是非常实用的技术,用于处理设备之间的数据传输。如读/写文件,网络通讯等。
Java程序中,对于数据的输入/输出操作以“流(stream)"的方式进行。
java.io包下提供了各种“流”类和接口,用以获取不同种类的数据,并通过标准的方法输入或输出数据。
说明：设备之间是广义的，主机与主机之间，内存与硬盘之间，等等
（2）输入与输出
输入input：读取外部数据（磁盘、光盘等存储设备的数据）到程序（内存）中。
输出output：将程序（内存）数据输出到磁盘、光盘等存储设备中。
说明：如下图，我们占位在程序的角度（即内存），只要是数据流入内存就是输入。流出内存，就是输出
3、 流的分类
（1）分类概述
① 按操作数据单位不同分为:字节流(8 bit),字符流(16 bit)
说明：
Ⅰ 字节流就是byte 按011010101 的方式传输。字符流是一次传2个字节，16位，传char类型数据，即直接按照'a','b'等字符传输。
Ⅱ 显然传输文本（比如txt、java、c、cpp）用字符流效率更高。但是对于非文本等抽象的图片或视频（比如jpg、MP3/4、avi、doc、ppt等），还是用字节流传输。
② 按数据流的流向不同分为:输入流,输出流
③ 按流的角色的不同分为: 节点流,处理流
说明：节点流就是直接连接外部设备数据 与 内存 的“管道”，处理流是包装节点流或处理流的流，比如给节点流加速之类的（一般将节点流对象作为形参给处理流）。处理流，就是“套接”在已有的流（节点流或处理流）的基础上。
| 抽象基类 | 字节流 | 字符流 |
| 输入流 | InputStream | Reader |
| 输出流 | OutputStream | Writer |
总结：
① Java的IO流共涉及40多个类,实际上非常规则,都是从如上图4个抽象基类派生的。
② 由这四个类派生出来的子类名称都是以其父类名作为子类名后缀。
（2）IO流体系 每一列的类都是继承于第一行的基类
说明：
① 第一行是基类。第二行访问文件这四个流是节点流，其他都是处理流（直接操作文件的流）。
② 看IO流子类后缀，都会带有他们基类的名字。
③ 蓝色背景的需要重点掌握
| 抽象基类 | 节点流（或文件流）及对应方法 | 缓冲流（处理流的一种）及对应方法 |
| InputStream | FileInputStream / read(byte[ ] buffer) | BufferedInputStream/ read(byte[ ] buffer) |
| OutputStream | FileOutputStream / write(byte[ ] buffer,0,len) | BufferedOutputStream/write(byte[ ] buffer,0,len) |
| Reader | FileReader / read(char[ ] cbuf) | BufferedReader/ read(char[ ] cbuf) 或 readLine() |
| Writer | FileWriter / write(char[ ] cbuf,0,len) | BufferedWriter / write(char[ ] cbuf,0,len) |
注意：表格里面的缓冲流专门处理相对应的节点流。
3.1节点流的使用 FileInputStream FileOutputStream FileReader FileWriter
（1）流使用的标准步骤
step1 File类的实例化，指明要操作的文件
step2 IO流的实例化，建立物理连接
step3 数据的写入或输出
step4 流资源的关闭
（2）FileReader 的使用 （字符流）
exp1:读取硬盘中hello.txt文件中的内容到内存中，并打印
public void testFileReader() {
FileReader fr = null;
try{
File file = new File("hello.txt"); //1、实例化File类对象，指明要操作的文件
FileReader fr = new FileReader(file);//2、提供具体的流（建立文件与内存的物理“管道”）
int date = fr.read();//3、数据的读入 read()方法返回读入的一个字符，达到文件末尾返回-1
while(date !=-1){
System.out.println((char)date);//date是int型，强制转换成char，使其输出字符
date = fr.read();//继续读取下一个字符
}
} catch(IOException e){
e.printStackTrace();
} finally {
try{
fr.close(); //4、关闭流（非常重要，java垃圾回收机制没法自动关闭，必须手动关闭）
} catch (IOException e) {
e.printStackTrace();
}
}
}
注意：如果前面代码抛异常，可能导致程序未执行关闭流的操作，为了保证流资源一定执行了关闭操作（否则内存泄漏）。需要使用try-catch-finally处理
读入的文件一定要在硬盘中存在，否则会报FileNotFoundException异常
（3）FileWriter的使用 （字符流）
exp2：从内存中写出数据到硬盘文件里
public void testFileWriter() throws IOException{ //后面的异常都先抛了，具体处理方式和exp1一样，免得看的花里胡哨
File file = new File("hello1.txt"); //1、提供File类对象，指明写出到的文件
FileWriter fw = new FileWriter(file【,false】); //2、提供FileWriter的对象，用于数据的写出
fw.write("I have a dream!\n"); //3、写出操作
fw.write("you need to have a dream!");
fw.close();//4、流资源的关闭
}
程序输出：
I have a dream！
you need to have a dream!
说明：
输出操作，对应的File可以不存在。不会报异常
如果File文件不存在，再输出过程中会自动创建此文件。
如果File文件存在，看流构造器的第二形参 FileWriter(file【,false】) 默认为false
如果是false或默认值（不写），则覆盖源文件
如果是true，则不会覆盖原文件，而是在原文件基础上添加内容
（4）FileInputStream 和 FileOutputStream 的使用 （字节流）
exp：实现对图片的复制操作
public void testFileInputOutputStream() throws FileNotFoundException{
File srcFile = new File("爱情与友情.jpg");
File destFile = new File("爱情与友情2");
FileInputStream fis = new FileInputStream(srcFile);
FileOutputStream fos = new FileOutputStream(destFile);
//复制过程
byte[ ] buffer = new byte[5]; //准备一次操作5个数据
int len;
while(len=fis.read(buffer)!=-1){ //只要能够从srcFile中，读取到数组里面的数据到内存中
fos.write(buffer;0;len); //从buffer数组的第一开始，到读取到的最后一个值（len长度）结束，将读到数据从内存中的写入到destFile
}
fos.close();
fis.close();
}
3.2 缓冲流 （类似C++的cin cout） 处理流之一
（1）作用
缓冲流用于包装2.3讲的4种字节流，主要用于提高他们的读写效率。实际开发，不会用前面4个字节流，效率太低。
说明：缓冲流提供了缓冲区，数据先缓存在缓冲区，等积累了一定量再一次性输出去，同时自动刷新缓冲区。可以用flush()方法，显式刷新缓冲区。
（2）缓冲流的使用
① BufferedInputStream 和 BufferedOutputStream
exp1:复制非文本文件
public void BufferedStreamTest{
//1、造文件
File srcFile = new File("爱情与友情.jpg");
File destFile = new File("爱情与友情3.jpg");
//2、造流
//2.1 造节点流
FileInputStream fis = new FileInputStream(srcFile);
FileOutputStream fos = new FileOutputStream(destFile);
//2.2 造缓冲流
BufferedInputStream bis = new BufferedInputStream(fis);
BufferedOutputStream bos = new BufferedOutputStream(fos);
//3、复制过程：读取、写入
byte[ ] buffer = new byte[10];
int len;
while((len=bis.read(buffer))!=-1){
bos.write(buffer,0,len);
}
//4、资源关闭。特别注意，先关闭外层的流（缓冲流），再关闭内层的流
bos.close();
bis.close();
//特别说明：关闭外层流的同时，内层流会被自动关闭。因此我们可以省略关闭内层流（不省略也没错）
// fos.close();
// fis.close();
}
② BufferedReader 和 BufferedWriter
exp2：复制某个文本文件
public void testBufferedxx(){
//创建文件和相应的流
BufferedReader br = new BufferedReader(new FileReader(new File("dbcp.txt"))); //匿名对象叠加
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("dbcp1.txt")));
//读写操作方法二（区别exp1的方法一）
String date;
while((date=br.readLine())!=null){ //readLine()一行就读取完，不读取换行符
bw.write(date+"\n"); //date不包含换行符，因此，需要我们自己添加换行符
}
bw.close();
br.close();
}
3.3 转换流 又一种处理流
（1）概述
① 转换流提供了在字节流和字符流之间的转换
② Java API提供了两个转换流:
InputStreamReader:将InputStream转换为Reader 即 将字节的输入流转换为字符的输入流
OutputStreamWriter:将Writer转换为OutputStream 即 将字符的输出流转换为字节的输出流
复习：
解码：字节、字节数组（看不懂的）————> 字符数组、字符串（看得懂的）
编码：字符数组、字符串————>字节、字节数组
注意：字符集（用什么字符集编码或者解码），就是用当初文件保存的字符集去做
③ 字节流中的数据都是字符时,转成字符流操作更高效。
④ 很多时候我们使用转换流来处理文件乱码问题。实现编码和解码的功能。
（2）案例
public void test1() throws IOException{
FileInputStream fis = new FileInputStream("dbcp.txt");
InputStreamReader isr = new InputStreamReader(fis【,"utf-8"】); //使用默认的字符集,具体使用哪个字符集，取决于当初保存文件时用的字符集
char[ ] cbuf = new char[20];
int len;
while((len=isr.read(cbuf))!=-1){
String str = new String(cbuf,0,len);
System.out.print(str);
}
isr.close();
}
（3）综合使用InputStreamReader 和 OutputStreamWriter
exp:读取某个utf-8编码的文件，再用gbk重新编码写入文件 （即 给文本文件换一种字符集）
public void test2(){
//造文件，造流
File file1 = new File("dbcp.txt");
File file2 = new File("dbcp_gbk.txt");
FileInputStream fis = new FileInputStream(file1);
FileOutputStream fos = new FileOutputStream(file2);
InputStreamReader isr = new InputStreamReader(fis,"utf-8");
OutputStreamWriter osw = new OutputStreamWriter(fos,"gbk");
//读写过程
char[ ] cbuf = new char[20];
int len;
while((len=isr.read(cbuf))!=-1){
osw.write(cbuf,0,len);
}
//关闭资源
isr.close();
osw.close();
}
3.4 标准输入、输出流
（1）简介
class System{
static PrintStream out; //System.out属性的类型是PrintStream（打印流）
static InputStream in;//System.in属性的类型是InputStream
//重定向方法:通过System类的setln, setOut方法对默认输入输出设备进行改变。比如改变让其输出到某个txt里面去
public static void setln(InputStream in);
public static void setOut(PrintStream out);
}
说明：
System.in和System.out分别代表了系统标准的输入和输出设备。默认输入设备是:键盘,输出设备是显示器
Ⅰ System.in：标准的输入流，默认从键盘输入。如果输入的都是字符，可以结合转换流将其转换为字符流
Ⅱ System.out,其是OutputStream的子类：标准输出流，默认从控制台（显示器）输出
3.5 打印流
class PrintStream{
void print(各种类型形参);//提供了一系列重载的print()和printin()方法,用于多种数据类型的输出.
void printlm(各种类型形参);
}
打印流实现将基本数据类型的数据格式转化为字符串输出。
提供了一些重载的print()和println()
打印流: PrintStream（打印字节）和PrintWriter（打印字符）
① 提供了一系列重载的print()和printin()方法,用于多种数据类型的输出.
② PrintStream和PrintWriter的输出不会抛出IOException异常
③ PrintStream和PrintWriter有自动flush功能
④ PrintStream打印的所有字符都使用平台的默认字符编码转换为字节。在需要写入字符而不是写入字节的情况下,应该使用PrintWriter类。
⑤ System.out返回的是PrintStream的实例
3.6 对象流 （了解即可，实际开发都是用json传输）
（1）简介
对象流ObjectInputStream和OjbectOutputSteam
用于存储和读取基本数据类型数据或对象的处理流。它的强大之处就是可以把Java中的对象写入到数据源中,也能把对象从数据源中还原回来。
① 序列化:用ObjectOutputStream类保存基本类型数据或对象的机制 即 将内存中的java对象保存到磁盘中或通过网络传输出去
② 反序列化:用ObjectInputStream类读取基本类型数据或对象的机制
（2）对象的序列化
① 对象序列化机制允许把内存中的Java对象转换成平台无关的二进制流,从而允许把这种二进制流持久地保存在磁盘上,或通过网络将这种二进制流传输到另一个网络节点。（序列化） 当其它程序获取了这种二进制流,就可以恢复成原来的Java对象（反序列化）
② 序列化的好处在于可将任何实现了Serializable接口的对象转化为字节数据,使其在保存和传输时可被还原
③ 序列化是RMI (Remote Method Invoke-远程方法调用)过程的参数和返回值都必须实现的机制,而RMI是JavaEE的基础。因此序列化机制是JavaEE平台的基础
④ 对象所属的类必须是可序列化的类 对象需要满足如下要求，方可序列化
Ⅰ 该类必须实现如下两个接口之一。否则,会抛出NotSerializableException异常
❶ Serializable （常用）：
标识接口 即不需要重写任何方法的接口，只要声明出来就好。同时，该接口要求当前类必须提供一个static final long seriaVersionUID=xxL的全局常量属性 即序列版本号，序列化以后，就变成字节流在网络中传输了，因此给一个标识，防止走丢了
注意：关于static final long seriaVersionUID属性
如果类没有显示定义这个静态常量,它的值是Java运行时环境根据类的内部细节自动生成的。若类的实例变量做了修改, serialVersionUID可能发生变化（修改后，Java又会自动重新生成一个新的静态常量，可能跟以前的不一样），导致反序列化出来不是修改后的实例。故建议,显式声明。
❷ Externalizable
Ⅱ 类的内部所有属性也必须是可序列化的，基本数据类型都可序列化
注意：ObjectOutputStream和ObjectInputStream不能序列化static和transient修饰的成员变量
说明：static本来就是类的，不是对象的。这个是对象流，就是传对象，当然不能序列化类属性。transient就是修饰，自己不想被序列化的属性
exp：
public class Person implements Serializable{
public static final long seriaVersionUID=45651645545L; //用一个标识绑定类
private String name; //string本来就可序列化
private int age; //基本数据类型int 也可序列化
private static int id; //id属性不能序列化。但就他不序列化，不影响对象序列化
..............
}
public void testObjectOutputStream(){ //序列化操作，将String对象 保存在 object.dat中
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("object.dat")); //造流造对象
oos.writeObject(new String("我爱北京天安门")); //writeObject方法就是写出对象
oos.flush();//刷新操作
oos.close(); //关闭资源
}
public void testObjectInputStream(){ //反序列化过程。将磁盘中的对象，还原成一个java对象
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("object.dat"));//选取要读入的文件，创建流
Object obj = ois.readObject();//读取文件
String str = (String) obj;//转换成String
ois.close(); //关闭流
}
3.7 任意存取文件流 RandomAccessFile类 既可以是输入流，也可以是输出流
（1）简介
① RandomAccessFile声明在java.io包下,但直接继承于java.lang.Object类（不像其他输入输出流，继承于4个基类）。并且它实现了Datalnput, DataOutput这两个接口,也就意味着这个类既可以读（输入）也可以写（输出）。
② RandomAccessFile类支持“随机访问”的方式,程序可以直接跳到文件的任意地方来读、写文件
支持只访问文件的部分内容
可以向已存在的文件后追加内容
③ RandomAccessFile对象包含一个记录指针,用以标示当前读写处的位置。
④ RandomAccessFile类对象可以自由移动记录指针:
long getFilePointer():获取文件记录指针的当前位置
void seek(long pos):将文件记录指针定位到pos位置，默认pos从0开始
⑤ RandomAccessFile作为输出流时，写出到的文件如果不存在，则在执行过程中自动创建。如果文件存在，则会对原有文件内容进行覆盖（默认情况下，从头覆盖）
（2）构造器
public RandomAccessFile(File file, String mode)
public RandomAccessFile(String file, String mode)
说明：
① 创建RandomAccessFile类实例需要指定一个mode参数，该参数指定RandomAccessFile的访问模式：
r:以只读方式打开
rw:打开以便读取和写入
rwd:打开以便读取和写入;同步文件内容的更新.
rws:打开以便读取和写入;同步文件内容和元数据的更新
② 如果模式为只读r。则不会创建文件,而是会去读取一个已经存在的文件,如果读取的文件不存在则会出现异常。如果模式为rw读写。如果文件不存在则会去创建文件,如果存在则不会创建。
exp1：复制图片
public void test1() throws IOException{
//1、造对象
RandomAccessFile raf1 = new RandomAccessFile(new File("爱情与友情"),"r");
RandomAccessFile raf2 = new RandomAccessFile(new File("爱情与友情1"),"rw");
//2、读写过程
byte[ ] buffer = new byte[1024];
int len;
while((len=raf1.read(buffer))!=-1){
raf2.write(buffer,0,len);
}
//3、关闭资源
raf1.close();
raf2.close();
}
exp2：输出覆盖文件内容
public void test2() throws IOException{
RandomAccessFile raf1 = new RandomAccessFile("hello.txt","rw"); //作为输出流向hello.txt文件写数据
raf1.seek(3);//pos为3，即指针调到角标为3的位置（即第四个字符）
raf1.write("xyz".getBytess()); //将xyz转换成字节后写入 hello.txt文件，从第四个字符开始覆盖，其他保持不变
raf1.close();
}
3.8 数据流（了解）
为了方便地操作Java语言的基本数据类型和String的数据，可以使用数据流。
作用：用于读取或写出基本数据类型的变量或字符串
分类：DateInputStream 和 DateOutputStream
4、Java NIO 概述 Java1.4
4.1 NIO
（1）Java NIO (New IO, Non-Blocking IO)是从Java 1.4版本开始引入的一套新的IO API,可以替代标准的Java IO API。NIO与原来的IO有同样的作用和目的,但是使用的方式完全不同, NIO支持面向缓冲区的(IO是面向流的（即字节流，字符流）)、基于通道的IO操作。NIO将以更加高效的方式进行文件的读写操作。
（2）Java API中提供了两套NIO,一套是针对标准输入输出NIO,另一套就是网络编程NIO.
-----Java.nio.channels.Channel （缓冲区 通道）
----FileChannel:处理本地文件
----SocketChannel: TCP网络编程的客户端的Channel
----ServerSocketChannel:TCP网络编程的服务器端的
----Channel-DatagramChannel: UDP网络编程中发送端和接收端的Channel
4.2 NIO2 JDK7
（1）概述
随着JDK7的发布, Java对NIO进行了极大的扩展,增强了对文件处理和文件系统特性的支持,以至于我们称他们为NIO.2因为NIO提供的一些功能, NIO已经成为文件处理中越来越重要的部分。
（2）NIO2中新的类 Path、Paths和Files
早期的Java只提供了一个File类来访问文件系统,但File类的功能比较有限,所提供的方法性能也不高。而且,大多数方法在出错时仅返回失败,并不会提供异常信息。
NIO. 2为了弥补这种不足,引入了Path接口,代表一个平台无关的平台路径,描述了目录结构中文件的位置。Path可以看成是File类的升级版本,实际引用的资源也可以不存在。,
NIO.2在java.nio.file包下还提供了Files, Paths 工具类, Files包含了大量静态的工具方法来操作文件; Paths则包含了两个返回Path的静态工厂方法:
static Path get(String first, String ...more) :用于将多个字符串串连成路径
static Path get(URI uri):返回指定uri对应的Path路径
exp:
在以前IO操作都是这样写的:
import java.io.File
File file = new File("index.html");
但在Java7中,我们可以这样写:
import java.nio.file.Path;
import java.nio.file.Paths;
Path path = Paths.get("index.html"):
539
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
