Java进阶 - IO流 - 《Java 学习记录》

分类：
File类
字节流
字符流
字节缓冲流
字符缓冲流

File类

描述：用于描述一个计算机文件/文件夹的信息，并提供相关文件的操作
常用的构造方法：
1. File(String c)：根据文件/文件夹的路径创建File对象
2. File(String parent,String child)：根据父目录的路径+子文件的路径创建File对象
3. File(File parent,String child)：根据父目录的File对象+子文件的路径创建File对象
常用方法：
例：
1. 获取目录下所有的文件名 ```java String path = “D:\study”; File file = new File(path);
  
  //如果不存在，就结束 if (!file.exists()) { return;//方法结束 } //如果存在，就输出名字 if (file.isFile()) { System.out.println(file.getName()); return; } print(file); }

public static void print(File file) { //获得目录的子文件，子目录的数组 File[] files = file.listFiles(); if (files == null) { return; } for (File f : files) { //要么是文件 if (f.isFile()) { System.out.println(f.getName()); } else { //要么是目录 print(f);//传递一个目录下去 } } }


   2. 递归获取某路径下的所有文件，文件夹，并输出
```java
public static void main(String[] args) {
//路径   这里写一个路径进去
String path="D:\study";
//调用方法
getFiles(path);
}
public static void getFiles(String path) {
    File file = new File(path);
    // 如果这个路径是文件夹
    if (file.isDirectory()) {
        // 获取路径下的所有文件
        File[] files = file.listFiles();
        for (int i = 0; i < files.length; i++) {
            // 如果还是文件夹 递归获取里面的文件 文件夹
            if (files[i].isDirectory()) {
                System.out.println("目录：" + files[i].getPath());
                getFiles(files[i].getPath());
            } else {
                System.out.println("文件：" + files[i].getPath());
            }
        }
    } else {
        System.out.println("文件：" + file.getPath());
    }
}

字节流

描述：以字节单位进行传输

FileOutputStream：字节输出流/写入流
1. 常用构造方法：
  1. new FileOutputStream(String path)：通过路径创建会覆盖原内容的输出流对象，目录不存在时无法创建。
  2. new FileOutputStream(String path,true)：不会覆盖原内容，在原内容后追加
  3. new FileOutputStream(String path)：通过File对象会覆盖原内容的输出流对象，目录不存在时无法创建。
  4. new FileOutputStream(File file,true)：不会覆盖原内容，在原内容后追加
2. 常用方法：
  1. void write(int) ：写出ASCII码为参数的字符
  2. void write(byte[])：将一个字节数组写出
  3. void write(byte[],int start,int len)：写出字节数组从start开始到len的内容
3. 例：
  字节流写入
```
public static void main(String[] args) throws IOException{
String path="D\\read.txt";
String songs="🍕";
//创建流
FileOutputStream fos=new FileOutputStream(path);
byte[] datas=songs.getBytes();//将字符串变为字节数组
fos.write(datas);//写入
fos.close;//关闭流
}
```

FileInputStream：字节输入流/读取流

描述：创建一个输入流对象时，就建立的文件到程序之间的管道。从流中取出一些数据后，数据就不存在于流中

构造方法：
1. new FileInputStream(String path)：通过文件物理路径创建输入流
2. new FileInputStream(File file)：通过File对象创建输入流
常用方法
1. int read() ：读取一个字节，返回这个字节的ASCII码值
2. int read(byte[]) ：读取最多为参数数组长度的字节数，返回真正的字节数

例：

文件读取

public static void main(String[] args) throws IOException {
File file = new File("D:\\read.txt");
FileInputStream fis = new FileInputStream(file);
//一次读一个字节，从头读到尾
//for (int i = 0; i < file.length(); i++) {
//    //每次读取一个字节，返回其ASCII值
//    int c = fis.read();
//    System.out.println((char) c);
//}
//创建字符缓冲区，每次最多读取缓冲区长度的字节数
byte[] bytes = new byte[1024];
int l = 0;
while ((l = fis.read(bytes)) != -1) {
   System.out.println(new String(bytes, 0, l));
}
//关闭流
fis.close();
}

文件复制

public static void main(String[] args) throws IOException {
String target = "D:\\1.jpg";
String to = "D:\\11.jpg";
FileInputStream fis = new FileInputStream(target);//创建读取对象
FileOutputStream fos = new FileOutputStream(to);//创建写入对象
//操作流(思路：边读，边写)
byte[] datas = new byte[1024];
int length = -1;//保存每次读取了多少字节
while ((length = fis.read(datas)) != -1) {
   fos.write(datas, 0, length);//将实际读取到的数据写入目标文件中
}//关闭流
fis.close();
fos.close();
}

字符流

描述：适用于操作文本文件

FileReader：字符输入流
1. 构造方法：
  1. new FileReader(String path)：根据路径创建字符输出流
  2. new FileReader(File file)：根据File对象创建字符输出流
2. 常用方法
  1. int read()：每次读取一个字符，返回其ASCII码值
  2. int read(char[])：每次最多读取缓冲区数据长度的字符，返回真正读取的字符数
3. 例：读取文本
```
  String path = "D:\\read.txt";
  //创建流
  FileReader fr = new FileReader(path);
  //操作流
  char[] datas = new char[1024];
  int l=0;
  while ((l=fr.read(datas)) != -1) {
      //将字符数组，转换为字符串
      System.out.println(new String(datas,0,l));
  }
  //关闭流
  fr.close();
```
FileWriter：字符输出流
1. 构造方法
  1. new FileWrite(String path)：根据路径创建字符输出流
  2. new FileWrite(String path，true)：不会覆盖原内容，在原内容后追加
  3. new FileWrite(File file)：根据File对象创建字符输出流
  4. new FileWrite(File file，true)不会覆盖原内容，在原内容后追加
2. 常用方法
  1. void write(String)：将一个字符串的所有字符写入到文件中
  2. void write(String,int start,int length)：将一个字符串从start到length的内容输出
  3. void write(char[])：将一个字符数组的所有字符写到文件中
  4. void write(char[],int start,int length)：将一个字符数组的从start位开始后面length长度的字符写到文件中
  5. void write(int)：将ASCI码对应的字符写到文件中
3. 例：字符写入
```
public static void main(String[] args) throws IOException {
  String path = "D:\\read.txt";
  String str = "我是个大傻逼";
  char[] cs = str.toCharArray();
  FileWriter fw = new FileWriter(path);
  fw.write(str);
  //字符流写出 必须要刷新或关闭写出流对象，否则不能呢正常写出
  fw.flush();
  fw.close();
}
```

字节缓冲流

Buf**feredInputStream**：缓冲输入流，是一个装饰流
描述：一次性从硬盘中取出最大长度的数据，流中数据被取完后再从硬盘取，从而减少与硬盘的交互
1. 构造方法
  1. new BufferdInputStream(InputStream is)
  2. new BufferdInputStream(InputStream is,int size)：自定义缓冲数组长度
2. 例：和字节流一样用法
```
public static void main(String[] args) throws FileNotFoundException {
  String path="D:\\read.txt";
  FileInputStream fis=new FileInputStream(path) ;
  java.io.BufferedInputStream bis=new java.io.BufferedInputStream(fis) ;
}
```
BufferedOutputStream：缓冲输出流，装饰流
描述：使用方式和FileOutputStream一致，但BufferedOutputStream在大小达到8kb时才会一次性写入文件中，从而减少与硬盘的交互。如果要手动写入，需要调用flush方法；关闭流时，系统会自动调用flush方法。
1. 构造方法
  1. new BufferedOutputStream(OutputStream os)
  2. new BufferedOutputStream(OutputStream os,int size)：自定义缓冲数组长度

IO流

分类：

File类

字节流

字符流

字节缓冲流

字符缓冲流