【Java】JavaSE的IO流操作

一、File类

1、构造的三种方法

File f1 = new File("//Users//wangminghao//Desktop//demo.txt");
System.out.println(f1);

File f2 = new File("//Users//wangminghao//Desktop","demo.txt");
System.out.println(f2);

File f3 = new File("//Users//wangminghao//Desktop");
File f4 = new File(f3,"demo.txt");
System.out.println(f4);

1. 两个反斜线是为了转义
2. 构造File类只是存储路径(抽象存在)，不会创建相应的文件

2、File类的创建功能

1. 不存在时创建新空文件：public boolean createNewFile()

File f1 = new File("//Users//wangminghao//Desktop//demo.txt");
try {
   
 System.out.println(f1.createNewFile());
} catch (IOException e) {
   
 e.printStackTrace();

• 相对路径：默认与模块同一级别，在项目路径下

1. 创建相应目录：public boolean mkdir()

File f2 = new File("//Users//wangminghao//Desktop//demo");
System.out.println(f2.mkdir());

1. 创建相应目录及其父目录：public boolean mkdirs()

File f3 = new File("//Users//wangminghao//Desktop//demo1//demo2");
System.out.println(f3.mkdirs());

3、File类的删除方法

public boolean delete()：删除空文件夹或文件

4、File类的判断与获取方法

1. 判目录：public boolean isDirectory()
2. 判文件：public boolean isFile()
3. 判存在：public boolean exists()
4. 返回绝对路径：public String getAbsolutePath()
5. 返回(构建时的)路径：public String getPath()
6. 返回目录/文件名：public String getName()
7. 返回目录下文件/目录的数组：public String[] list()
8. 返回目录下文件/目录的File：public File[] listFiles()

5、遍历目录

public class demo4 {
   
  static File f = new File("//Users//wangminghao//Desktop");
  static int i = 0;
  public static void main(String[] args) {
   
      dfs(f);
  }
  public static void dfs(File f){
   
      File[] files = f.listFiles();
      for (File file : files){
   
          if(file.isFile()){
   
              System.out.println( ++i + "." + file.getName() + ":" + file.getAbsoluteFile());
          }else{
   
              dfs(file);
          }
      }
  }
}

二、I/O流

1. IO：输入输出
2. 流：数据传输
3. 用途：处理设备间的数据传输
4. 分类
   1. 流向
      1. 输入流：读数据
      2. 输出流：写数据
   2. 数据类型
      1. 字节流：其他格式
      2. 字符流：文本格式

三、字节流

1、字节流抽象基类

• InputStream：输入流超类
• OutputStream：输出流超类
• 子类名特点：以基类名为后缀

2、字节流写数据

1. 创建FileOutputStream --> 创建文件和指向文件的字节输出流对象

    FileOutputStream fos = new FileOutputStream("...//demo.txt");
   

2. 写入数据

   1. 写一个字节：void write(int b)
   2. 写一个字节数组：void write(byte[] b)
   3. 返回一个字符串的字节数组：byte[] getBytes(StandardCharsets.UTF_8)
   4. 写一个字节数组的部分：void write(byte[] b, int off, int len)
      1. off：偏移量，即索引位置

3. 释放资源

    fos.close();    // 放finally
   

4. 补充：

   1. 换行
      1. win：\r\n
      2. linux：\n
      3. mac：\r
   2. 追加写入
      1. public FileOutputStream(String name, boolean append)
      2. append = true：追加写入，默认为false

FileOutputStream fos = null;
try {
   
   fos = new FileOutputStream("//Users//wangminghao//Desktop//demo.txt");
   fos.write("芭芭拉冲呀！".getBytes(StandardCharsets.UTF_8));
} catch (FileNotFoundException e) {
   
   e.printStackTrace();
} catch (IOException e) {
   
   e.printStackTrace();
}finally {
   
   if(fos != null){
   
       try {
   
           fos.close();
       } catch (IOException e) {
   
           e.printStackTrace();
       }
   }
}

3、字节流读数据

1. 创建FileInputStream

FileInputStream fis = new FileInputStream("...//demo.txt");

1. 读取数据

   1. 读一个字节：int read() --> 返回ascii码，到末尾返回-1

      int by;
      while((by = fis.read()) != -1){
             
       System.out.print(by);
      }
      

   2. 读一个字节数组：int read(byte[] b)

      byte[] bys = new byte[1024];
      int len;
      while((len = fis.read(bys)) != -1){
             
       System.out.print(new String(bys,0,len));
      }
      

   3. 读一个字节数组的部分：void write(byte[] b, int off, int len)

      1. off：偏移量，即索引位置

4、字节缓冲流

1. 作用：将数据写入缓冲区，一次性输出，提高效率 --> 字节缓冲流 + 一次读写一个字节数组：最快
2. 字节缓冲输出流：BufferedOutputstream(Outputstream out)
3. 字节缓冲输入流：BufferedInputstream(Inputstream in)
4. 建议使用匿名对象
   BufferedInputStream bis = new BufferedInputStream(new FileInputStream("//Users//wangminghao//Desktop//demo.mp4"));
5. 刷新流：void flush() --> 将缓冲区刷新到输入、输出流

四、字符流

1、字符流概述

1. 字符流 = 字节流 + 编码表
2. 出现的的原因：
   1. 字节读取文本数据文件，汉字在不同编码下占用的字节数不同
   2. 中文第一个数字是负数
3. GBK：2字节
4. UTF-8：3字节

2、字符串的编解码问题

(1)编码

1. byte[] getBytes()：默认编码
2. byte[] getBytes(String charsetName)：指定编码

(2)解码

1. String(byte[] bytes)：默认解码
2. String(byte[] bytes, String charsetName)：指定解码

(3)字符流抽象基类

1. 输入流Reader：InputStreamReader：字节 --> 字符
   InputStreamReader isr = new InputStreamReader(new FileInputStream("D:\\demo")[, "UTF-8"]);
2. 输出流Writer：OutputStreamWriter：字符 --> 字节
   OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("D:\\demo")[, "UTF-8"]);

3、字符流读写数据

字符流写数据

1. 写一个字符：void write(int c)
2. 写一个字符数组：void write(char[] cbuf)
3. 写部分字符数组：void write(char[] cbuf, int off, int len)
4. 写一个字符串：void write(String s)
5. 写部分字符串：void write(String s, int off, int len)
6. 刷新流：void flush() --> 除了字节流，其内部有缓冲区，需要刷新

字符流读数据

1. 读一个字符：int read()
2. 读一个字符数组：int read(char[] cbuf)

4、字符流子类

1. FileReader：FileReader(String fileName)
2. FileWriter：FileWriter(String fileName)
3. 用途：
   1. 用于替代OutputStreamReader/InputStreamWriter
   2. 只能用默认字符集

5、字符缓冲流

1. BufferedReader
   1. 构造方法：BufferedReader(Reader in)
   2. 写一个换行：void newLine()
2. BufferedWriter
   1. 构造方法：BufferedReader(Writer out)
   2. 读一行字符串：public String readLine()
      1. 不包括终止字符
      2. 流的结尾返回null

String line;
while((line = br.readLine()) != null){
   
   System.out.println(line);
}

6、异常处理

// 定义
try(定义流操作){
   
    异常代码;
}catch{
   
    异常处理代码;
}
// 实例
try (FileInputStream fis = new FileInputStream("D:\\demo1/txt");
    FileOutputStream fos = new FileOutputStream("D:\\demo2.txt")) {
   
    int r = fis.read();
    fos.write(96);
} catch (IOException e) {
   
    e.printStackTrace();
}

节省了释放资源于判断空指针异常的操作

五、特殊操作流

1、标准输入输出流

System类的两个静态成员变量

1. 标准输入流：public static final InputStream in
   1. 构造：
      1. InputStream is = System.in
      2. BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
   2. 包装类Scanner：Scanner sc = new Scanner(System.in);
2. 标准输出流：public static final OutputStream out
   1. System.out的本质是一个字节输出流
   2. System.out.println(...);
   3. System.out.print(...);
   4. System.out.printf(...);

2、打印流

分类

• 字节打印流：PrintStream(String fileName[, boolean autoFlush])
• 字符打印流：PrintWriter(String fileName[, boolean autoFlush])
• autoFlush：每次print后自动刷新流，默认为false

特有方法

(不转码，所见即所得)

• print
• println

特点

• 只负输出数据，不负责读取
• 特有方法输出不转码，所见即所得

3、对象序列化流

概述

• 对象序列化：保存对象文件
• 对象反序列化：读取对象文件

对象序列化流：ObjectOutputStream

• 构造：ObjectOutputStream(OutputStream out)
• 写入对象：void writeObject(Object obj)
• 对象需要实现Serializable标记接口

对象反序列化流：ObjectInputStream

• 构造：ObjectOutputStream(InputStream in)
• 读取对象：Object readObject()

serialVersionUID

• 用于验证序列化和反序列化时，是否使用了同一个类
• 可以子类重写：private static final long serialVersionUID = 42L;

transient关键词

使成员变量不参与序列化

4、Properties

1. 作为Map集合的使用

   Properties prop = new Properties();
   prop.put("wmh","wjh");
   for (Object key : prop.keySet()) {
        
    System.out.println(key + "," + prop.get(key));
   }
   

2. 作为Map集合的特有方法

   1. Object setProperty(String key, String value)：put集合的值
   2. String getProperty(String key)：查键值（不存在返回null）
   3. Set<String> stringPropertyNames()：返回键集
3. Properties与I/O流结合
   1. 字节流读取：void load(InputStream inStream)
   2. 字符流读取：void load(Reader reader)
   3. 字节流写入：void store(OutputStream out, String comments)
   4. 字符流写入：void store(Writer writer, String comments)
      • comments：描述信息，不描述写null