1 流的概念
2 流的分类
3 字节流
- 文件字节流
- - FileInputStream
  - FileOutputStream
- 字节缓冲流
- - BufferedInputStream
  - BufferedOutputStream
- 对象流
- - ObjectOutputStream
  - ObjectInputStream
  - 注意事项
5 字符流
- 文件字符流
- - FileReader
  - FileWriter
- 字符缓冲流
- - BufferedReader
  - BufferedWriter
- 转换流
- - InputStreamReader
  - OutputStreamWriter
6 File类
- 对文件操作
- 对文件夹操作
- FileFilter接口
- 对文件夹递归操作

1 流的概念

内存与存储设备之间传输数据的通道

2 流的分类

按方向
输入流：将<存储设备>中的内容读到<内存>中
输出流：将<内存>中的内容写到<存储设备>中
按单位
字节流：以字节为单位，可以读写所有数据
字符流：以字符为单位，只能读写文本数据
按功能
节点流：具有实际传输数据的读写功能
过滤流：在节点流的基础之上增强功能

3 字节流

字节流的父类（抽象类）：InputStream和OutputStream

//InputStream 字节输入流
public int read(){}
public int read(byte[] b){}
public int read(byte[] b, int off, int len){}// OutputStream 字节输出流
public void write(int n){}
public void write(byte[] b){}
public void write(byte[] b, int off, int len){}

文件字节流

FileInputStream

FileInputStream从文件系统中的文件获取输入字节。什么文件可用取决于主机环境。
构造方法：
FileInputStream(String name) throws FileNotFoundException：通过打开与实际文件的连接来创建一个 FileInputStream，该文件由文件系统中的路径名 name命名。
public int read(byte[] b) throws IOException：从该输入流读取最多b.length字节的数据到字节数组。

读入缓冲区的总字节数，如果没有更多的数据，因为文件的结尾已经到达，则返回-1 。

psvm(String[] args) throws Exception{//可能会找不到文件，所以抛出异常// 1 创建FileInputStream 并指定文件路径FileInputStream fis = new FileInputStream("d:\\abc.txt");// 2 读取文件// fis.read();// 2.1单字节读取int data = 0;while((data = fis.read()) != -1){System.out.print((char)data);}// 2.2 一次读取多个字节byte[] buf = new byte[3]; // 大小为3的缓存区int count = fis.read(buf); // 一次读3个System.out.println(new String(buf));System.out.println(count);int count2 = fis.read(buf); // 再读3个System.out.println(new String(buf));System.out.println(count2);// 将上述优化：byte[] buf = new byte[1024];int count = 0;while((count = fis.read(buf)) != -1){System.out.println(new String(buf, 0, count));}// 3 关闭fis.close();
}

FileOutputStream

FileOutputStream用于写入诸如图像数据的原始字节流。
构造方法1：
public FileOutputStream(String name) throws FileNotFoundException：创建文件输出流以指定的名称写入文件。
构造方法2：
public FileOutputStream(File file,boolean append) throws
FileNotFoundException：创建文件输出流以指定的名称写入文件。如果第二个参数是true
，则字节将写入文件的末尾而不是开头。
public void write(byte[] b) throws IOException：将b.length字节从指定的字节数组写入此文件输出流。

psvm(String[] args) throws Exception{// 1 创建文件字节输出流FileOutputStream fos = new FileOutputStream("路径", true);// true表示不覆盖 接着写 // 2 写入文件fos.write(97);fos.write('a');// String string = "hello world";fos.write(string.getByte());// 3 关闭fos.close();
}

复制文件（边读边写）：

// 1 创建流
// 1.1 文件字节输入流
FileInputStream fis = new FileInputStream("路径");
// 1.2 文件字节输出流
FileInputStream fos = new FileOutpuStream("路径");
// 2 边读边写
byte[] buf = new byte[1024];
int count = 0;
while((count = fis.read(buf)) != -1){fos.write(buf, 0, count);
}
// 3 关闭
fis.close();
fos.close();

字节缓冲流

字节缓冲流：BufferedInputStream/BufferedOutputStream
提高IO效率，减少访问磁盘次数
数据存储在缓冲区中，flush是将缓冲区的内容写入文件中，也可以直接close

BufferedInputStream

构造函数：
public BufferedInputStream(InputStream in)：创建一个BufferedInputStream并保存其参数，输入流in供以后使用。内部缓冲区数组创建并存储在buf 。

// 使用字节缓冲流 读取 文件
psvm(String[] args) throws Exception{// 1 创建BufferedInputStreamFileInputStream fis = new FileInputStream("路径");BufferedInputStream bis = new BufferedInputStream(fis);// 2 读取int data = 0;while((data = bis.read()) != -1){sout((char)data);}// 3 关闭bis.close();
}

默认缓冲流大小为8k，可以自定义缓冲流：

 // 用自己创建的缓冲流byte[] buf = new byte[1024];int count = 0;while((count = bis.read(buf)) != -1){sout(new String(buf, 0, count));}

BufferedOutputStream

构造方法1：
BufferedOutputStream(OutputStream out)
创建一个新的缓冲输出流，以将数据写入指定的底层输出流。
构造方法2：
BufferedOutputStream(OutputStream out, int size)
创建一个新的缓冲输出流，以便以指定的缓冲区大小将数据写入指定的底层输出流。

// 使用字节缓冲流 写入 文件
psvm(String[] args) throws Exception{// 1 创建BufferedInputStreamFileOutputStream fos = new FileOutputStream("路径");BufferedOutputStream bos = new BufferedOutputStream(fos);// 2 写入文件for(int i = 0; i < 10; i ++){bos.write("hello".getBytes());// 写入8k缓冲区（因为数据没到8k的大小，先暂存到缓冲区而不立即写入文件）bos.flush(); // 刷新到硬盘（立即写入）}// 3 关闭bos.close();
}

对象流

ObjectOutputStream / ObjectInputStream
增强了缓冲区功能
增强了读写8种基本数据类型和字符串的功能
增强了读写对象的功能
使用流传输对象的过程称为序列化、反序列化

序列化：将对象转换为序列，或者说将对象写入流之中。一个对象可以被表示为一个字节序列，该字节序列包括该对象的数据、有关对象的类型的信息和存储在对象中数据的类型。

反序列化：从流中读取对象。

ObjectOutputStream

构造方法：
protected ObjectOutputStream(OutputStream out)：创建一个写入指定的OutputStream的ObjectOutputStream。

// 使用ObjectOutputStream实现序列化
psvm(String[] args)throws Exception{// 1. 创建对象流FileOutputStream fos = new FileOutputStream("d:\\st.bin");ObjectOutputSream oos = new objectOutputSream(fos);// 2. 序列化（写入操作）Student zhangsan = new Student("zs", 20);//Student类要实现Serializable接口oos.WriteObject(zhangsan);// 3. 关闭oos.close();sout("序列化完毕");
}

public class Student implements Serializable{}

ObjectInputStream

构造方法：
protected ObjectInputStream(InputStream in)：创建从指定的InputStream读取的ObjectInputStream。
Object readObject() ：从ObjectInputStream读取一个对象。

// 使用ObjectInputSteam实现反序列化（读取重构对象）
psvm(String[] args)throws Exception{// 1. 创建对象流FileInputStream fis = new FileInputStream("d:\\stu.bin");ObjectInputStream ois = new ObjectInputStream(fis);// 2. 读取文件（反序列化）Student s = (Student)ois.readObject();//返回Object类型，需转换// 3. 关闭ois.close();sout("执行完毕");sout(s.toString());
}

注意事项

某个类要想序列化必须实现Serializable接口
序列化类中对象属性（属性中的引用数据类型）也要求实现Serializable接口
序列化版本号ID（serialVersionUID ）的作用：保证序列化的类和反序列化的类是同一个类
使用transient修饰的属性，这个属性就不能被序列化
静态属性不能被序列化
序列化多个对象，可以借助集合来实现

借助集合来实现序列化多个对象：

psvm(String[] args)throws Exception{// 1. 创建对象流FileOutputStream fos = new FileOutputStream("d:\\st.bin");ObjectOutputSream oos = new objectOutputSream(fos);// 2. 序列化（写入操作）Student s1 = new Student("张三", 20);Student s2 = new Student("李四", 22);ArrayList<Student> list = new ArrayList<>();list.add(s1);list.add(s2);oos.WriteObject(list);// 3. 关闭oos.close();sout("序列化完毕");
}

psvm(String[] args)throws Exception{// 1. 创建对象流FileInputStream fis = new FileInputStream("d:\\stu.bin");ObjectInputStream ois = new ObjectInputStream(fis);// 2. 读取文件（反序列化）ArrayList<Student> list = (ArrayList<Student>)ois.readObject();//返回Object类型，需转换// 3. 关闭ois.close();sout("执行完毕");sout(list.toString());
}

5 字符流

注：在UTF-8编码中，
一个中文字符 / 中文标点符号占3个字节；
一个英文字符 / 英文标点 / 数字符号占1个字节。

因为字节流是逐个字节读取，要是读取汉字或者其他内容的文本的话会出现乱码，因为一个字节无法组成汉字，所以要用到字符流。
字符流的两个父类（抽象类）：
Reader字符输入流：
public int read()
public int read(char[] c)
public int read(char[] b, int off, int len)
Writer字符输出流：
public void write(int n)
public void write(String str)
public void write(char[] c)

文件字符流

FileReader和FileWriter

FileReader

单个字符读取：

// 1. 创建FileReader 文件字符输入流
FileReader fr = new FileReader("..");
// 2. 读取
// 2.1 单个字符读取
int data = 0;
while((data = fr.read()) != -1){sout((char)data);// 读取一个字符
}// 3. 关闭
fr.close();

使用自定义字符缓冲区读取：

// 1. 创建FileReader 文件字符输入流
FileReader fr = new FileReader("..");
// 2. 读取
// 2.2 使用字符缓冲区读取
char[] buf = new char[2];
//2表明2个字符2个字符地读，缓冲区大小可以自定义
int count = 0;
while((count = fr.read(buf) != -1)){sout(new String(buf, 0, count));
}
// 3. 关闭
fr.close();

FileWriter

// 1. 创建FileWriter对象
FileWriter fw = new FileWriter("..");
// 2. 写入fw.write("Java是世界上最好的语言");fw.flush();// 3. 关闭
fw.close();
sout("执行完毕");

复制文件（使用FileReader和FileWriter）：
不能复制图片或二进制文件（声音、视频、可编译文件等），使用字节流可以复制任意文件。

psvm(String[] args) throws Exception{// 1. 创建FileReader fr = new FileReader("...");FileWriter fw = new FileWriter("...");// 2. 读写int data = 0;while((data = fr.read()) != -1){fw.write(data);fw.flush();}// 3. 关闭fw.close();fr.close();
}

字符缓冲流

BufferedReader和BufferedWriter
高效读写、支持输入换行符、可一次写一行读一行

BufferedReader

从字符输入流读取文本，缓冲字符，以提供字符，数组和行的高效读取

构造方法1：BufferedReader(Reader in)：创建使用默认大小的输入缓冲区的缓冲字符输入流。
public int read()：读一个字符，如果已经达到流的结尾，则为-1。
public String readLine()：读一行文字。一行被视为由换行符（’\ n’），回车符（’\ r’）中的任何一个或随后的换行符终止。如果已达到流的末尾，则为null

psvm(String[] args) throws Exception{// 创建缓冲流FileReader fr = new FileReader("..");BufferedReader br = new BufferedReader(fr);// 读取// 1. 第一种方式 一个一个字符地读取char[] buf = new char[1024];int count = 0;while((count = br.read(buf)) != -1){sout(new String(buf, 0, count));}// 2. 第二种方式 一行一行地读取String line = null;while((line = br.readLine()) != null){sout(line);}// 关闭br.close();
}

BufferedWriter

将文本写入字符输出流，缓冲字符，以提供单个字符，数组和字符串的高效写入。

psvm(String[] args) throws Exception{// 1. 创建BufferedWriter对象FileWriter fw = new FileWriter("...");//若已有该文件，则会覆盖文件BufferedWriter bw = new BufferedWriter(fw);// 2. 写入for(int i = 0; i < 10; i ++){//写十遍bw.write("写入的内容");bw.newLine(); // 写入一个换行符bw.flush();}// 3. 关闭bw.close();

转换流

InputStreamReader

InputStreamReader是从字节流（硬盘）到字符流（内存）的桥：它读取字节，并使用指定的charset将其解码为字符。
它使用的字符集可以由名称指定，也可以被明确指定，或者可以接受平台的默认字符集。
构造方法1：
InputStreamReader(InputStream in)
创建一个使用默认字符集的InputStreamReader。
构造方法2：
InputStreamReader(InputStream in, String charsetName)
创建一个使用命名字符集的InputStreamReader。
String getEncoding() 返回此流使用的字符编码的名称。
int read() 读一个字符

psvm(String[] args) throws Exception{// 1 创建InputStreamReader对象FileInputStream fis = new FisInputStream("..");InputStreamReader isr = new InputStreamReader(fis, "utf-8");// 2 读取文件int data = 0;while((data = isr.read()) != -1){sout((char)data);}// 3 关闭isr.close();
}

OutputStreamWriter

OutputStreamWriter是字符的桥梁流以字节流：向其写入的字符编码成使用指定的字节charset 。
它使用的字符集可以由名称指定，也可以被明确指定，或者可以接受平台的默认字符集。
构造方法1：
OutputStreamWriter(OutputStream out)
创建一个使用默认字符编码的OutputStreamWriter。
构造方法2：
OutputStreamWriter(OutputStream out, String charsetName)
创建一个使用命名字符集的OutputStreamWriter。
void flush() 刷新流。
void write(int c) 写一个字符

psvm(String[] args) throws Exception{// 1 创建OutputStreamReader对象FileOutputStream fos = new FisOutputStream("..");OutputStreamWRITER osw = new OutputStreamReader(fos, "utf-8");// 2 写入for(int i = 0; i < 10; i ++){osw.write("写入内容");osw.flush();}// 3 关闭osw.close();
}

6 File类

文件和目录路径名的抽象表示。
常量：
static String pathSeparator
与系统相关的路径分隔符字符，为方便起见，表示为字符串。（即 ;）
static char pathSeparatorChar
与系统相关的路径分隔符。（即 ;）
static String separator
与系统相关的默认名称 - 分隔符字符，以方便的方式表示为字符串。（即 \）
static char separatorChar
与系统相关的默认名称分隔符。（即 \）
构造方法：
File(File parent, String child)
从父抽象路径名和子路径名字符串创建新的 File实例。
File(String pathname)
通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例。
File(String parent, String child)
从父路径名字符串和子路径名字符串创建新的 File实例。
File(URI uri)
通过将给定的 file: URI转换为抽象路径名来创建新的 File实例。

常用方法：

boolean createNewFile() 当且仅当具有该名称的文件尚不存在时，创建一个由该抽象路径名命名的新的空文件。
boolean mkdir() 创建由此抽象路径名命名的单个目录。
boolean mkdirs() 创建由此抽象路径名命名的多级目录。
boolean delete() 删除由此抽象路径名表示的文件或目录。
boolean exists() 测试此抽象路径名表示的文件或目录是否存在。
String getAbsolutePath() 返回此抽象路径名的绝对路径名字符串。
String getName() 返回由此抽象路径名表示的文件或目录的名称。
String getParent() 返回此抽象路径名的父 null的路径名字符串，如果此路径名未命名为父目录，则返回null。
boolean isDirectory() 测试此抽象路径名表示的文件是否为目录。
boolean isFile() 测试此抽象路径名表示的文件是否为普通文件。
long length() 返回由此抽象路径名表示的文件的长度。
File[] listFiles() 返回一个抽象路径名数组，表示由该抽象路径名表示的目录中的文件。
boolean renameTo(File dest) 重命名由此抽象路径名表示的文件。

对文件操作

/*
File类的使用
1. 分隔符
2. 对文件操作
3. 对文件夹操作
*/
public class FileDemo {public static void main(String[] args) throws Exception{//        separator();
//        fileOpe();directoryOpe();}//1. 分隔符public static void separator(){System.out.println("路径分隔符" + File.pathSeparator);System.out.println("名称分隔符" + File.separator);}// 2. 对文件操作public static void fileOpe() throws Exception {// 1. 创建文件File file = new File("G:\\360MoveData\\Users\\cheng\\Desktop\\demo1.txt");if(!file.exists()){  //如果不存在，则创建boolean b = file.createNewFile();System.out.println("创建结果："+b);}// 2. 删除文件// 2.1 直接删除
//        System.out.println("删除结果："+file.delete()); // 2.2 让jvm退出时删除
//        file.deleteOnExit();
//        Thread.sleep(3000);//3秒// 3. 获取文件信息System.out.println("获取绝对路径"+file.getAbsolutePath());System.out.println("获取路径" + file.getPath());System.out.println("获取文件名称" + file.getName());System.out.println("获取父目录" + file.getParent());System.out.println("获取文件长度" + file.length());System.out.println("文件创建时间" + new Date(file.lastModified()).toLocaleString());// 4. 判断System.out.println("是否可写" + file.canWrite());System.out.println("是否是文件" + file.isFile());System.out.println("是否隐藏" + file.isHidden());}
}

对文件夹操作

    // 对文件夹操作public static void directoryOpe() throws Exception{// 1. 创建文件夹File dir = new File("G:\\360MoveData\\Users\\cheng\\Desktop\\aaa\\bbb\\ac");if(!dir.exists()){//dir.mkdir(); // 只能创建单级目录dir.mkdirs(); // 创建多级目录}// 2. 删除文件夹// 2.1 直接删除
//        System.out.println("删除结果："+dir.delete()); // 1.只能删除最里面的目录；2.而且只删除空目录// 2.2 让jvm退出时删除
//        dir.deleteOnExit();
//        Thread.sleep(3000);//3秒// 3. 获取文件夹信息System.out.println("获取绝对路径" + dir.getAbsolutePath());System.out.println("获取路径" + dir.getPath());System.out.println("获取文件名称" + dir.getName());System.out.println("获取父目录" + dir.getParent());System.out.println("获取文件长度" + dir.length());System.out.println("文件夹创建时间" + new Date(dir.lastModified()).toLocaleString());
//// 4. 判断System.out.println("是否是文件夹" + dir.isDirectory());System.out.println("是否隐藏" + dir.isHidden());// 5. 遍历文件夹File dir2 = new File("G:\\360MoveData\\Users\\cheng\\Desktop\\杂项");String[] files = dir2.list();for(String string : files){System.out.println(string);}}
}

FileFilter接口

public interface FileFilter
boolean accept(File pathname) 测试指定的抽象路径名是否应包含在路径名列表中。
当调用File类的listFiles()方法时，支持传入FileFilter接口实现类，对获取文件进行过滤，只有满足条件才可以出现在listFiles()的返回值中。

// FileFilter接口的使用File[] files2 = dir2.listFiles(new FileFilter(){@Overridepublic boolean accept(File pathname){if(pathname.getName().endsWith(".jpg")){return true;}return false;}
});
for(File file : files2){System.out.println(file.getName());
}

对文件夹递归操作

1.递归遍历文件夹（显示里面所有文件，包括其所有子文件夹里面的所有文件）

//递归遍历文件夹public static void main(String[] args) {//        listDir(new File("G:\\360MoveData\\Users\\cheng\\Desktop\\杂项1"));deleteDir(new File("G:\\360MoveData\\Users\\cheng\\Desktop\\杂项2"));}public static void listDir(File dir){File[] files = dir.listFiles();System.out.println(dir.getAbsolutePath());if(files != null && files.length > 0){for(File file : files){if(file.isDirectory()){listDir(file); // 递归}else {System.out.println(file.getAbsolutePath());}}}}

2.递归删除文件夹里所有文件（包括其所有子文件夹里的所有文件）

    public static void deleteDir(File dir){File[] files = dir.listFiles();if(files != null && files.length > 0){for(File file : files){if(file.isDirectory()){deleteDir(file); // 递归}else{// 删除文件System.out.println(file.getAbsolutePath() + "删除" + file.delete());}}}System.out.println(dir.getAbsolutePath() + "删除" + dir.delete());}

Java学习笔记4——I/O框架相关推荐

Java学习笔记-Day64 Spring 框架（二）
Java学习笔记-Day64 Spring 框架(二) 一.控制反转IOC和依赖注入DI 1.控制反转IOC 2.依赖注入DI 3.Spring IOC容器 3.1.简介 3.2.实现容器 3.2.获 ...
java学习笔记11--集合总结
java学习笔记系列: java学习笔记10--泛型总结 java学习笔记9--内部类总结 java学习笔记8--接口总结 java学习笔记7--抽象类与抽象方法 java学习笔记6--类的继承.Ob ...
设计模式学习笔记——状态(State)模式框架
设计模式学习笔记--状态(State)模式框架 @(设计模式)[设计模式, 状态模式, State] 设计模式学习笔记状态State模式框架基本介绍状态案例类图实现代码 State接口 Day ...
《Java学习笔记(第8版)》学习指导
<Java学习笔记(第8版)>学习指导目录图书简况学习指导第一章 Java平台概论第二章从JDK到IDE 第三章基础语法第四章认识对象第五章对象封装第六章继承与多 ...
2022年Java学习笔记目录
一.2022年Java任务驱动课程任务驱动,统摄知识点:2022年Java程序设计讲课笔记二.2022年Java学习笔记 (一)踏上Java开发之旅 Java学习笔记1.1.1 搭建Java开发环 ...
JAVA学习笔记（四）城堡游戏
城堡游戏我们在尝试了之前的简单媒体库构造之后,试着整合一下之前学到的关于类,继承,多态等知识,制作一个简单的城堡游戏,城堡游戏是一个简单的文字游戏,通过输入命令可以在地图上不同的房间进行移动. 目录 ...
JAVA学习笔记(1)【基础知识】
JAVA学习笔记DAY_1 提示:关于java系列的内容只是本人在老师的指导下和自学过程中的一些学习笔记,如果存在错误敬请批评指正! 文章目录 JAVA学习笔记DAY_1 前言一.Java语言未来的 ...
Java学习笔记-Day43 HTML标签
Java学习笔记-Day43 HTML标签一.布局标签 1.p标签 2.div标签 3.span标签二.列表标签 1.有序列表 2.无序列表 3.自定义列表三.文本标签 1.内联型文本标签 2. ...
Java学习笔记(原创)
Java学习笔记(原创) 2011-12-01 16:37:00| 分类: Java|举报|字号订阅下载LOFTER客户端基本知识一． Java基础 1. java语言的特点: ①简单:没有 ...

Java学习笔记4——I/O框架

目录