编程好记

主题

I/O流 ​

一、File类 ​

1、构造的三种方法 ​

java
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()
java
File f1 = new File("//Users//wangminghao//Desktop//demo.txt");
try {
 System.out.println(f1.createNewFile());
} catch (IOException e) {
 e.printStackTrace();
  • 相对路径：默认与模块同一级别，在项目路径下
  1. 创建相应目录：public boolean mkdir()
java
File f2 = new File("//Users//wangminghao//Desktop//demo");
System.out.println(f2.mkdir());
  1. 创建相应目录及其父目录：public boolean mkdirs()
java
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、遍历目录 ​

java
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 --> 创建文件和指向文件的字节输出流对象

    java
    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. 释放资源

    java
    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
java
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
    java
    int by;
while((by = fis.read()) != -1){
    System.out.print(by);
}
    1. 读一个字节数组：int read(byte[] b)
    java
    byte[] bys = new byte[1024];
int len;
while((len = fis.read(bys)) != -1){
	System.out.print(new String(bys,0,len));
}
    1. 读一个字节数组的部分：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
java
String line;
while((line = br.readLine()) != null){
   System.out.println(line);
}

6、异常处理 ​

java
// 定义
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集合的使用
java
Properties prop = new Properties();
prop.put("wmh","wjh");
for (Object key : prop.keySet()) {
    System.out.println(key + "," + prop.get(key));
}
  1. 作为Map集合的特有方法
    1. Object setProperty(String key, String value)：put集合的值
    2. String getProperty(String key)：查键值（不存在返回null）
    3. Set<String> stringPropertyNames()：返回键集
  2. 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

Released under the MIT License.

code by wmh1024