# File 类

# 构建的三种方法

File f1 = new File("//Users//baozi//a.txt");

System.out.println(f1);

File f2 = new File("//Users//baozi","a.txt");

System.out.println(f2);

File f3 = new File("//Users//baozi");

File f4 = new File(f3,"a.txt");

System.out.println(f4);

1. 两个反斜线为了转义
2. 构造 File 类知识存储路径（抽象存在），不会创建对应的文件

# File 类创建功能

1. 不存在时创建新空文件： public boolean createNewFile()
   1. 相对路径：默认与模块同一级别，在项目路径下
2. 创建响应目录： public boolean mkdir()
3. 创建响应目录及其父目录： public boolean mkdirs()

File f1 = new File("//Users//baozi//a.txt");

try {

    System.out.println(f1.createNewFile());

} catch (IOException e) {

    e.printStackTrace();

}

File f2 = new File("//Users//baozi//a");

System.out.println(f2.mkdir());

File f3 = new File("//Users//baozi//a//b");

System.out.println(f3.mkdirs());

# File 类的删除方法

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

# 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()

# 遍历目录

public class File01 {

    static File f = new File("//Users//baozi//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：输入流超类
2. OutputStream：输出流超类
3. 子类名特点：以基类名为后缀

# 字节流写数据

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

FileOutputStream fos = new FileOutputStream("//Users//baozi//a.txt");

// 2. 写入数据

// 2.1 写一个字节：void write (int b)

// 2.2 写一个字节数据：void write (byte [] b)

// 2.3 返回一个字符串的字节数组：byte [] getBytes (StandardCharsets.UTF-8)

// 2.4 写一个字节数组的部分：void write (byte [] b, int off, int len)  off 偏移量，即索引位置

// 3. 释放资源

fos.close();	// 放 finally

// 4. 补充

// 4.1 换行：win：\r\n linux：\n mac：\r

// 4.2 追加写入：public FileOutputStream (String name, boolean append)   append = true：追加写入，默认为 false

FileOutputStream fos = null;

try {

    fos = new FileOutputStream("//Users//baozi//a.txt");

    fos.write("123456".getBytes(StandardCharset.UTF-8));

} catch (FileNotFoundException e) {

    e.printlnStackTrace(e);

} catch (IOException e) {

    e.printlnStackTrace(e);

} finally {

    if(fos != null) {

        try {

            fos.close();

        } catch (IOException e) {

            e.printStackTrace();

        }

    }

}

# 字节流读数据

// 1. 创建 FileInputStream

FileInputStream fis = new FileInputStream("//Users//baozi//a.txt");

// 2. 读取数据

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

int by;

while ((by = fis.read()) != -1) {

    System.out.println(by);

}

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

byte[] bys = new byte[1024];

int len;

while((len = fis.read(bys)) != -1) {

    System.out.println(new String(bys,0,len));

}

// 3. 读一个字节数据的部分：void write (byte [] b, int off, int len) off 偏移量，即索引

# 字节缓冲流

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

# 字符串编码解码问题

# 编码

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

# 解码

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

# 字符流读写数据

# 字符流写数据

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)

# 字符流子类

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

# 字符缓冲流

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

}

# 异常处理

try (FileInputStream fis = new FileInputStream("D://a.txt"); FileOutputStream fos = new FileOutputStream("D://a.txt")) {

    int r = fis.read();

    fos.write(96);

} catch (IOException e) {

    e.printStackTrace();

}

# 特殊操作流

# 标准输入输出流

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. Ststem.out 的本质就是一个字节输出流
   2. System.out.println()
   3. System.out.print();
   4. System.out.printf();

# 打印流

# 分类

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

# 特有方法

1. print
2. println

# 特点

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

# 对象序列化流

# 概述

1. 对象序列化：保存对象文件
2. 对象反序列化：读取对象文件

# 对象序列化流： ObjectOutputStream

1. 构造： ObjectOutputStream(OutputStream out)
2. 写入对象： void writeObject(Object obj)
3. 对对象实现 Serializable 标记接口

# 对象反序列化流： ObjectInputStream

1. 构造： ObjectOutputStream(InputStream in)
2. 读取对象： Object readObject()

# serialVersionUID

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

# transient 关键字

使成员变量不参与序列化

# Properties

1. 作为 Map 集合的使用
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)
      1. comments：描述信息，不描述写 null

Properties prop = new Properties();

prop.put("baozi","baobao");

for (Object key : prop.keySet) {

    System.out.println(key + "," + prop.get(key));

}