目录

1 流的概念2 流的分类3 字节流文件字节流FileInputStreamFileOutputStream字节缓冲流BufferedInputStreamBufferedOutputStream对象流ObjectOutputStreamObjectInputStream注意事项5 字符流文件字符流FileReaderFileWriter字符缓冲流BufferedReaderBufferedWriter转换流InputStreamReaderOutputStreamWriter6 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 FileFilterboolean 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());}