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());}