目录
一、File 类
二、IO流
三、字节输出流
四、字节输入流
五、字节流文件复制
六、字符输出流
七、字符输入流
八、字符流复制文本文件
一、File 类
1. 概述
文件 和 目录路径名 的抽象表达形式
Java中把文件或者目录（文件夹）都封装成 File对象
我们要去操作硬盘上的文件，或者文件夹只要找到 File这个类即可
File类对象，只是路径名的 抽象表示形式，即使该文件在操作系统上并不物理存在，也可以创建这个路径所表示的File对象
2. 构造方法
File(String pathname)：通过给定 路径名字符串 转换为 抽象路径名 来创建一个新 File 实例
windows中的路径或文件名不区分大小写，但是最好别这样，跨平台可能会出现问题
File(String parent, String child)：根据 parent 路径名字符串 和 child 路径名字符串，创建一个新 File 实例
好处: 单独操作父路径和子路径
File(File parent, String child)：根据 parent 抽象路径名 和 child 路径名字符串，创建一个 File 实例
好处: 父路径是File类型,父路径可以直接调用File类方法
public class Test {
public static void main(String[] args) {
/*
* File(String pathname)
* 传递路径名: 可以写到文件夹,可以写到一个文件
*/
File file = new File("f:\\a.txt");
System.out.println(file);
/*
* File(String parent, String child)
* 传递字符串父路径,字符串子路径
*/
File file = new File("f:\\", "a.txt");
System.out.println(file);
/*
* File(File parent, String child)
* 传递传递File类型父路径,字符串子路径
*/
File parent = new File("f:");//带不带"\\"都可以
File file = new File(parent, "a.txt");
System.out.println(file);
}
}
123456789101112131415161718192021222324253. File 类成员方法
—创建功能—
public boolean createNewFile()：创建文件，如果文件已存在，不再创建
public boolean mkdir()：创建单级文件夹，如果文件夹已存在，不再创建
public boolean mkdirs()：创建多级文件夹，文件夹已经存在了,不再创建
mkdirs() 也可以创建单级文件夹，所以推荐使用 mkdirs()
—删除功能—
public boolean delete()： 删除文件或者文件夹，不走回收站，直接从硬盘删除！
如果此路径名表示一个目录，则该目录 必须为空 才能删除。
—重命名功能—
public boolean renameTo(File dest)： 重新命名文件
—判断功能—
public boolean isFile() ：判断File构造方法中封装的路径是不是文件
public boolean isDirectory()：判断File构造方法中封装的路径是不是文件夹
public boolean exists()： 判断File构造方法中封装的路径是否存在
public boolean canRead() ：读权限
public boolean canWrite() ：写权限
public boolean isHidden() ：是否隐藏
—基本获取功能—
public String getAbsolutePath()：获取绝对路径，返回 String 对象
public File getAbsoluteFile()：获取绝对路径，返回 file 对象（推荐使用）
eclipse和 IDEA环境中,写一个相对路径，获取的绝对位置是工程根目录
public String getPath()：将抽象路径名转换为字符串（就相当于 toString）
public String getName()：返回路径中表示的文件名或者文件夹名 (获取路径中的最后部分的名字)
public long length() ：返回路径中表示的文件的字节数（文件夹为 0）
public long lastModified() ：上次修改的时间
String getParent(): 获取父路径，返回String对象
File getParentFile(): 获取父路径，返回File对象（推荐使用）
4. File类高级获取功能
public String[] list()
获取到 File 构造方法中封装的路径中的文件和文件夹名 (遍历一个目录)，返回只有名字。如果此抽象路径名不表示一个目录，那么此方法将返回 nul，返回的是一个字符串数组，不会递归的获取子目录中的信息（文件或者目录的名称）。
public File[] listFiles()
获取到 File 构造方法中封装的路径中的文件和文件夹名 (遍历一个目录)，返回的是目录或者文件的 全路径
返回一个 File对象数组。不会递归的获取子目录中的信息（文件或者目录的名称）
注意：在获取指定目录下的文件或者文件夹时必须满足下面两个条件
1)指定的目录必须存在
2)指定的必须是目录。否则容易引发 返回数组为null，出现NullPointerException
5. 文件过滤器
listFiles(FileFilter filter) : 传递 FileFilter 接口的实现类
FileFilter 接口:
必须自定义 FileFilter 接口实现类，重写抽象方法，然后将接口实现类对象传递到遍历方法 listFiles
boolean accept(File pathname) 返回 true 满足条件，回false不满足过滤条件
过滤器中的 accept() 方法接受一个参数，这个参数就当前文件或文件夹对象(全路径)
FilenameFilter接口:
过滤器中的 accept() 接受两个参数，一个当前文件或文件夹所在的路径，一个是当前文件或文件夹对象的名称
boolean accept(File dir, String name) 返回true满足条件，回false不满足过滤条件
当我们需要过滤文件名称时就可以使用 FilenameFilter 这个过滤器，当我们想对当前文件或文件夹进行过滤，就可以使用 FileFilter
对于一个目录下，文件或文件目录的筛选工作代码：
不变——筛选过程
变化——筛选条件
原理分析
listFiles() 遍历目录的同时，获取到了文件名全路径，调用过滤器的方法 accept()，将获取到的路径传递给 accept()，accept() 方法接收了参数，参数是 listFiles 传递来的，在 accept()方法中，进行判断，如果满足过滤条件，返回true，否则返回false，一旦方法返回了true，listFiles 就将路径保存到 File数组 中
6. 递归遍历全目录
public class FileDemo {
public static void main(String[] args) {
File dir = new File("E:\\a");
getAllDir(dir);
}
// 定义方法,实现目录的全遍历
private static void getAllDir(File dir) {
//调用方法listFiles()对目录,dir进行遍历
File[] fileArr = dir.listFiles();
for(File f : fileArr){
//判断变量f表示的路径是不是文件夹,是，则递归遍历
if(f.isDirectory()){
getAllDir(f);
}else{
System.out.println(f);
}
}
}
}
1234567891011121314151617181920二、IO流
1. 概述
IO流用来处理设备之间的 数据传输
Java对数据的操作是通过 流 的方式
Java用于操作流的对象都在 IO包 中（input/output）
Output操作：把内存中的数据存储到持久化设备上这个动作称为输出（写）
Input操作：把持久设备上的数据读取到内存中的这个动作称为输入（读）
流的分类：
流按流向分为两种：
输出流：内存——>外设（写出数据）
输入流：磁盘——>内存（读入数据）
流按操作类型分为两种：
字节流：字节流可以操作任何数据,因为在计算机中任何数据都是以字节的形式存储的
字符流：字符流只能操作纯字符数据，比较方便。
2. IO流常用父类
字节流的抽象父类：InputStream ，OutputStream
字符流的抽象父类：Reader ， Writer
三、字节输出流
1. 概述
java.io.OutputStream 此抽象类，是表示输出字节流的所有类的超类。操作的数据都是 字节
2. OutputStream 的核心方法：
void close(): 关闭此输出流并释放与此流有关的所有系统资源。
close的常规协定：该方法将关闭输出流。关闭的流不能执行输出操作，也不能重新打开。
如果流对象建立失败了,需要关闭资源吗？
new 对象的时候，失败了，没有占用系统资源；释放资源的时候,对流对象判断null，变量不是null,对象建立成功，需要关闭资源
write(byte[] b)： 将 b.length 个字节从指定的 byte 数组写入此输出流
write(byte[] b, int off, int len)：将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流。
write(int b)： 将指定的字节写入此输出流。write 的常规协定：向输出流写入一个字节。要写入的字节是参数 b 的八个低位。b 的 24 个高位将被忽略。
3. FileOutputStream 类
(1) 构造方法
FileOutputStream(File file) ：创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
FileOutputStream(File file, boolean append)： 创建一个向指定 File 对象表示的文件中写入数据的文件输出流，以追加的方式写入。
FileOutputStream(String name) ：创建一个向具有指定名称的文件中写入数据的输出文件流。
FileOutputStream(String name, boolean append) ：创建一个向具有指定 name 的文件中写入数据的输出文件流，以追加的方式写入。
(2) 流对象的使用步骤：
创建流子类的对象,绑定数据目的
调用流对象的方法write写
close释放资源
注意事项：流对象的构造方法,可以创建文件，如果文件存在，直接覆盖
public class IoDemo {
public static void main(String[] args) throws IOException {
//创建流子类的对象,绑定数据目的
FileOutputStream fos = new FileOutputStream("E:\\a.txt");
//用write方法写数据
//写一个字节
fos.write(100); //d
//写字节数组
byte[] bytes = {65,66,67,68}; //ABCD
fos.write(bytes);
//写字节的一部分,开始索引，写几个
fos.write(bytes,1,1); //B
//写入字节数组的简便方式
//写字符串
fos.write("Hello".getBytes());
//关闭资源
fos.close();
}
}
123456789101112131415161718192021224. 文件的续写和换行
（1）实现数据的换行
在文件中，写入换行符号换行： \r\n
\r\n 可以写在上一行的末尾, 也可以写在下一行的开头
fos.write("hello\r\n".getBytes());
1(2）关于数据的追加写入
默认情况下，当一个文件输出流对象，指向一个文件的时候，会清空文件内容
必须使用特殊的构造方法实现文件的追加写入，FileOutputStream构造方法, 的第二个参数中加入 true
//实现追加写入：
FileOutputStream fos = new FileOutputStream(file, true);
15. IO异常的处理
一些细节：
保证流对象变量，作用域足够
catch里面处理异常
输出异常的信息，目的看到哪里出现了问题，停下程序,重新尝试
如果流对象建立失败了，需要关闭资源吗
new 对象的时候，失败了，没有占用系统资源；释放资源的时候，对流对象判断 null；变量不是 null，对象建立成功，需要关闭资源
public class FileOutputStreamDemo3 {
public static void main(String[] args) {
File file = new File("c:\\file.txt");
//try 外面声明变量,try 里面建立对象，为了提升流对象作用域
//定义FileOutputStream的引用
FileOutputStream fos = null;
try {
//创建FileOutputStream对象
fos = new FileOutputStream(file);
//写出数据
fos.write("abcde".getBytes());
} catch (IOException e) {
System.out.println(e.toString() + "----");
throw new RuntimeException("文件写入失败,重试");
} finally {
//一定要判断fos是否为null，只有不为null时，才可以关闭资源
if (fos != null) {
try {
fos.close();
} catch (IOException e) {
throw new RuntimeException("关闭资源失败");
}
}
}
}
}
1234567891011121314151617181920212223242526四、字节输入流
1. 概述
java.io.InputStream: 此抽象类是表示字节输入流的所有类的超类。读取任意文件，每次只读取1个字节
2. 核心方法
abstract int read()：读取一个字节
read()方法的特点：read() 执行一次，就会自动读取下一个字节，返回值是读取到的字节, 读取到结尾返回 -1
public class IoDemo {
public static void main(String[] args) throws IOException {
//创建字节输入流的子类对象
FileInputStream fis = new FileInputStream("E:\\a.txt"); //ABCD
//读取一个字节，调用read方法，返回int
//使用循环方式，读取文件，循环结束的条件：read() 返回 -1
int len = 0; //接收read()的返回值
while((len = fis.read()) != -1){
System.out.print((char)len); //可以转换成字符
}
//关闭资源
fis.close();
}
}
1234567891011121314int read(byte[] b)：读取一定数量的字节，并将其存储在缓冲区数组 b 中
int read(byte[] b, int off, int len) ：读取最多 len 个字节，存入 byte 数组。
数组的作用：缓冲的作用, 提高效率
read 返回的 int，表示读取到多少个有效的字节数
public class IoDemo {
public static void main(String[] args) throws IOException {
//创建字节输入流的子类对象
FileInputStream fis = new FileInputStream("E:\\a.txt");
//创建字节数组
byte[] b = new byte[1024];
int len = 0;
while((len = fis.read(b)) != -1){
System.out.print(new String(b,0,len)); //使用String的构造方法，转为字符串
}
//关闭资源
fis.close();
}
}
1234567891011121314153. FileInputStream 类
（1）构造方法
为这个流对象 绑定数据源
FileInputStream(File file)
FileInputStream(String name)
参数：File对象 和 String对象
（2）输入流读取文件的步骤
创建字节输入流的子类对象
调用读取方法 read 读取
关闭资源
（3）读取数据的方式：
第一种方式：一次读取一个字节数据
第二种方式：一次读取一个字节数组
第二种方式效率更高，每次读取都会和操作系统发生一次交互，第二种方式每次可以读取多个数据，提高了操作效率
4、释放资源的另一种方式
//1.第一种释放资源的方式 closeQuietly
//释放输入流资源
closeQuietly(fis);
//释放输出流对象
closeQuietly(fos);
private static void closeQuietly(Closeable close) {
if(close != null) {
try {
close.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
//2.jdk7 中引入的 try-with-resource语句
try(放申请资源的语句){
}catch() {
}
// 一旦资源的申请放在try-with-resource语句的（）中，那么资源会保证一定自动被释放
12345678910111213141516171819202122232425五、字节流文件复制
1. 读取单个字节
public class Copy {
public static void main(String[] args) {
long s = System.currentTimeMillis();
//定义两个流的对象变量
FileInputStream fis = null;
FileOutputStream fos = null;
try{
//建立两个流的对象,绑定数据源和数据目的
fis = new FileInputStream("D:\\test.mp3"); //8,003,733 字节
fos = new FileOutputStream("d:\\test.mp3");
//字节输入流,读取1个字节,输出流写1个字节
int len = 0 ;
while((len = fis.read())!=-1){
fos.write(len);
}
}catch(IOException e){
System.out.println(e);
throw new RuntimeException("文件复制失败");
}finally{
try{
if(fos!=null)
fos.close();
}catch(IOException e){
throw new RuntimeException("释放资源失败");
}finally{
try{
if(fis!=null)
fis.close();
}catch(IOException e){
throw new RuntimeException("释放资源失败");
}
}
}
long e = System.currentTimeMillis();
System.out.println(e-s);
}
}
//耗时：61817
12345678910111213141516171819202122232425262728293031323334353637382. 读取字节数组
public class Copy_1 {
public static void main(String[] args) {
long s = System.currentTimeMillis();
FileInputStream fis = null;
FileOutputStream fos = null;
try{
fis = new FileInputStream("D:\\test.mp3");
fos = new FileOutputStream("E:\\test.mp3");
//定义字节数组,缓冲
byte[] bytes = new byte[1024*10];
//读取数组,写入数组
int len = 0 ;
while((len = fis.read(bytes))!=-1){
fos.write(bytes, 0, len);
}
}catch(IOException e){
System.out.println(e);
throw new RuntimeException("文件复制失败");
}finally{
try{
if(fos!=null)
fos.close();
}catch(IOException e){
throw new RuntimeException("释放资源失败");
}finally{
try{
if(fis!=null)
fis.close();
}catch(IOException e){
throw new RuntimeException("释放资源失败");
}
}
}
long e = System.currentTimeMillis();
System.out.println(e-s);
}
}
//耗时：41
1234567891011121314151617181920212223242526272829303132333435363738六、字符输出流
1. 概述
java.io.Writer 所有字符输出流的超类。写文件，写 文本文件
2. 方法介绍
void write(int c)：写入单个字符
void write(String str) ：写入字符串
void write(String str, int off, int len)：写入字符串的某一部分
void write(char[] cbuf)：写入字符数组
abstract void write(char[] cbuf, int off, int len) ：写入字符数组的某一部分
3. FileWriter 类
Writer 类是抽象类，找到子类对象 FileWriter
构造方法：参数也是 File 类型对象 和 String 文件名
字符输出流，写数据的时候，必须要运行一个功能，刷新功能：flush()
public class WriterDemo {
public static void main(String[] args) throws IOException{
FileWriter fw = new FileWriter("c:\\1.txt");
//写1个字符
fw.write(100);
fw.flush();
//写1个字符数组
char[] c = {'a','b','c','d','e'};
fw.write(c);
fw.flush();
//写字符数组一部分
fw.write(c, 2, 2);
fw.flush();
//写如字符串
fw.write("hello");
fw.flush();
fw.close();
}
}
123456789101112131415161718192021222324七、字符输入流
1. 概述
java.io.Reader，字符输入流读取文本文件,所有字符输入流的超类，专门读取文本文件
2. 方法介绍
int read()： 读取单个字符
int read(char[] cbuf)：将字符读入数组
abstract int read(char[] cbuf, int off, int len) ：将字符读入数组的某一部分
没有读取字符串的方法
3. FileReader 类
Reader类 是抽象类，找到子类对象 FileReader
构造方法：写入的数据目的。绑定数据源。参数也是 File 类型对象 和 String 文件名
public class ReaderDemo {
public static void main(String[] args) throws IOException{
FileReader fr = new FileReader("c:\\1.txt");
//读字符
/*int len = 0 ;
while((len = fr.read())!=-1){
System.out.print((char)len);
}*/
//读数组
char[] ch = new char[1024];
int len = 0 ;
while((len = fr.read(ch))!=-1){
System.out.print(new String(ch,0,len)); //转字符串
}
fr.close();
}
}
1234567891011121314151617184. flush 方法和 close 方法区别
flush()方法：用来刷新缓冲区的，刷新后可以再次写出，只有字符流才需要刷新
close()方法：用来关闭流释放资源的的，如果是带缓冲区的流对象的close()方法，不但会关闭流，还会再关闭流之前刷新缓冲区，关闭后不能再写出
八、字符流复制文本文件
字符流复制文本文件，必须是文本文件
字符流查询本机默认的编码表，简体中文GBK
FileReader 读取数据源
FileWriter 写入到数据目的
//读取字符数组
public class Copy_2 {
public static void main(String[] args) {
FileReader fr = null;
FileWriter fw = null;
try{
fr = new FileReader("c:\\1.txt");
fw = new FileWriter("d:\\1.txt");
char[] cbuf = new char[1024];
int len = 0 ;
while(( len = fr.read(cbuf))!=-1){
fw.write(cbuf, 0, len);
fw.flush();
}
}catch(IOException ex){
System.out.println(ex);
throw new RuntimeException("复制失败");
}finally{
try{
if(fw!=null)
fw.close();
}catch(IOException ex){
throw new RuntimeException("释放资源失败");
}finally{
try{
if(fr!=null)
fr.close();
}catch(IOException ex){
throw new RuntimeException("释放资源失败");
}
}
}
}
}
123456789101112131415161718192021222324252627282930313233343536