java-io流+File类

java File 类

java 文件类，以抽象的方式代表文件名和目录路径名。该类主要用于文件和目录的创建、文件的查找和文件的删除等

构造器

• File(String pathname)：以 pathname 为路径创建 File 对象，可以是绝对路径或者相对路径，如果 pathname 是相对路径，则默认的当前路径在系统属性 user.dir 中存储
• File(String parent, String chlid)：以 parent 为父路径，child 为子路径创建 File 对象
• File(File parent, String child)：根据一个父 File 对象和子文件 路径创建 File 对象
• File(URI uri)：通过将给定的 file: URI 转换成一个抽象路径名来创建一个新的 File 实例

代码：

@Test
public void test1() {
  // File(String pathname)
  File file1 = new File("hello.txt");
  File file2 = new File("D:\\JavaSE\\hello.txt");
  // File(String parent, String chlid)
  File file3 = new File("D:\\JavaSE", "hello.txt");
    // File(File parent, String child)
  File parentDir = new File("D:\\aaa");
  File file4 = new File(parentDir, "hello.txt");
}

关于路径：

• 绝对路径：从盘符开始的路径，这是一个完整的路径
• 相对路径：相对于项目目录的路径，这是一个便捷的路径，开发中经常使用
  • IDEA 中，main 中的文件的相对路径，是相对于"当前工程"
  • IDEA 中，单元测试方法中的文件的相对路径，是相对于"当前 module"

常用方法

获取文件和目录基本信息

如果 File 对象代表的文件或目录存在，则 File 对象实例初始化时，就会用硬盘中对应文件或目录的属性信息（例如，时间、类型等）为 File 对象的属性赋值，否则除了路径和名称，File 对象的其他属性将会保留默认值

代码：

@Test
public void test2() {
  File file1 = new File("C:\\code\\hello.txt");
  System.out.println("文件名称："+file1.getName());
  System.out.println("文件路径："+file1.getAbsolutePath());
  System.out.println("文件长度："+file1.length());
  System.out.println("文件最后修改时间："+file1.lastModified());
  /** 输出
     * 文件名称：hello.txt
     * 文件路径：C:\code\hello.txt
     * 文件长度：15
     * 文件最后修改时间：1687600030638
  **/

}

列出目录的下一级

代码

@Test
public void test3() {
  File file1 = new File("C:\\code");
  String[] list = file1.list();
  for (String s : list) {
    System.out.println(s);
  }
}

重命名功能

代码：

@Test
public void test4() {
  File file1 = new File("C:\\code\\hello.txt");
  File file2 = new File("C:\\code\\abc.txt");
  boolean rename = file1.renameTo(file2);
  System.out.println(rename?"重命名名成功":"重复名失败");
}

判断功能方法

代码

@Test
public void test5(){
  File file1 = new File("C:\\code");
  File file2 = new File("C:\\code\\abc.txt");
  // 判断是否存在
  System.out.println(file1.exists());
  System.out.println(file2.exists());
  // 判断是否目录
  System.out.println(file1.isDirectory());
  System.out.println(file2.isDirectory());
  // 判断是否文件
  System.out.println(file1.isFile());
  System.out.println(file2.isFile());
}

创建、删除功能

代码

@Test
public void test6() throws IOException {
  // 创建文件
  File file = new File("adc.txt");
  boolean newFile = file.createNewFile();
  System.out.println(newFile?"创建成功":"创建失败");

  // 创建一级目录
  File file1 = new File("newDir");
  boolean mkdir = file1.mkdir();
  System.out.println(mkdir?"创建成功":"创建失败");
  // 创建多级目录
  File file2 = new File("dir\\dir1\\dir2");
  boolean mkdirs = file2.mkdirs();
  System.out.println(mkdirs?"创建成功":"创建失败");

  // 文件删除
  boolean delete1 = file.delete();
  System.out.println(delete1?"删除成功":"删除失败");
  boolean delete2 = file1.delete();
  System.out.println(delete2?"删除成功":"删除失败");

}

java io

Java 程序中，对于数据的输入/输出操作以“流(stream)” 的方式进行，可以看做是 一种数据的流动

I/O 流中的 I/O 是 Input/Output 的缩写， I/O 技术是非常实用的技术，用于处理设备之间的数据传输。如读/写文件，网络通讯等

流的分类

按数据的流向不同分为：输入流和输出流

1. 输入流：将其他数据读取到内存中的流（以 InputStream、Reader 结尾）
2. 输出流：将内存的数据写入到其他设备的流（以 OutputStream、Writer 结尾）

按操作数据单位的不同分为：字节流（8bit）和字符流（16bit）

1. 以字节为单位，读写数据的流（以 InputStream、OutputStream 结尾）
2. 以字符为单位，读写数据的流（以Reader，Write 结尾）

根据 IO 流的角色不同分为：节点流和处理流

1. 节点流：直接从数据源或目的地读写数据
2. 处理流：不直接连接到数据源或目的地，而是连接在已存在的流（节点流或处理流）之上，通过对数据的处理为程序提供更为强大的读写功能

流的api

ava 的 IO 流共涉及 40 多个类，实际上非常规则，都是从如下 4 个抽象基类派生的

由这四个类派生出来的子类名称都是以其父类名作为子类名后缀

常用节点流

文件流： FileInputStream、FileOutputStrean、FileReader、FileWriter

字节/字符数组流： ByteArrayInputStream、ByteArrayOutputStream、 CharArrayReader、CharArrayWriter

– 对数组进行处理的节点流（对应的不再是文件，而是内存中的一个数组）

Reader Writer

Java 提供一些字符流类，以字符为单位读写数据，专门用于处理文本文件。不 能操作图片，视频等非文本文件

常见的文本文件有如下的格式：.txt、.java、.c、.cpp、.py 等

注意：.doc、.xls、.ppt 这些都不是文本文件

字符输入流 Reader

java.io.Reader 抽象类是表示用于读取字符流的所有类的父类，可以读取字符 信息到内存中。它定义了字符输入流的基本共性功能方法

方法：

字符输出流 Wirter

java.io.Writer 抽象类是表示用于写出字符流的所有类的超类，将指定的字符 信息写出到目的地。它定义了字节输出流的基本共性功能方法

方法

FileReader 与 FileWriter

FileReader

用于读取字符文件，构造时使用系统默认的字符编码和 默认字节缓冲区

• FileReader(File file)： 创建一个新的 FileReader ，给定要读取的 File 对象

  FileReader(String fileName)： 创建一个新的 FileReader ，给定要读取的文件的名称

@Test
public void test9()  {
  File file = new File("hello.txt");
  FileReader fr = null;
  try {
    fr= new FileReader(file);
    int data;
    while ((data = fr.read())!= -1){
      System.out.print((char)data);
    }
  } catch (IOException e) {
    e.printStackTrace();
  } finally {
    try {
      fr.close();
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
}

FileWriter

java.io.FileWriter 类用于写出字符到文件，构造时使用系统默认的字符编码 和默认字节缓冲区

• FileWriter(File file)： 创建一个新的 FileWriter，给定要读取的 File 对象
• FileWriter(String fileName)： 创建一个新的 FileWriter，给定要读取的文件 的名称
• FileWriter(File file,boolean append)： 创建一个新的 FileWriter，指明是否在现有文件末尾追加内容

@Test
public void test10(){
  FileWriter fw =null;
  try {
    // 如果输出的文件已存在，则会对现有的文件进行覆盖
    fw=new FileWriter(new File("abc.txt"));
    //如果输出的文件已存在，则会在现有的文件末尾写入数据
    // fw = new FileWriter(new File("abc.txt"),true);
    fw.write("java,");
    fw.write("php,");
    fw.write("python,");
    fw.write("javascript,");

  } catch (IOException e) {
    e.printStackTrace();
  }finally {
    try {
      // 关闭资源
      if(fw!=null)
        fw.close();
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
}

总结：

1. 输入流的文件 File 对象必须存在

2. 输出流的文件 File 对象可不存在，自动创建，若存在根据构造器覆盖或追加文件内容

3. 为了避免内存泄漏，需要使用 try-catch-finally 处理异常

   关于 flush（刷新）

因为内置缓冲区的原因，如果 FileWriter 不关闭输出流，无法写出字符到文件 中。但是关闭的流对象，是无法继续写出数据的。如果我们既想写出数据，又 想继续使用流，就需要 flush() 方法了

InputStream OutputStream

如果我们读取或写出的数据是非文本文件，则 Reader、Writer 就无能为力了， 必须使用字节流

字节输入流：InputStream

java.io.InputStream 抽象类是表示字节输入流的所有类的超类，可以读取字 节信息到内存中。它定义了字节输入流的基本共性功能方法

字节输出流：OutputStream

java.io.OutputStream 抽象类是表示字节输出流的所有类的超类，将指定的字 节信息写出到目的地。它定义了字节输出流的基本共性功能方法

FileInputStream 与 FileOutputStream

java.io.FileInputStream 类是文件输入流，从文件中读取字节

• FileInputStream(File file)： 通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的 File 对象 file 命名
• FileInputStream(String name)： 通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的路径名 name 命名

@Test
public void test11()  {
  FileInputStream fs =null
    try {

      fs = new FileInputStream("abc.txt");
      int len;
      byte[] b = new byte[2];
      while ((len = fs.read(b))!= -1){
        System.out.print(new String(b,0,len));
      }

    } catch (IOException e) {
      e.printStackTrace();
    } finally {
      try {
        fs.close();
      } catch (IOException e) {
        e.printStackTrace();
      }
    }
}

FileOutputStream类是文件输出流，用于将数据写出到文件

• public FileOutputStream(File file)：创建文件输出流，写出由指定的 File 对象表示的文件
• public FileOutputStream(String name)： 创建文件输出流，指定的名称为写出文件
• public FileOutputStream(File file, boolean append)： 创建文件输出流，指明是否在现有文件末尾追加内容

@Test
public void test12(){
  FileOutputStream fos = null;
  try {
    fos = new FileOutputStream(new File("fos.txt"));
    // 写入 abcd
    fos.write(97);
    fos.write(98);
    fos.write(99);
    fos.write(100);

    // 字符串转换为字节数组
    byte[] b = "hello".getBytes();
    // 写入 ell
    fos.write(b,1,3);

  } catch (IOException e) {
    e.printStackTrace();
  } finally {
    try {
      fos.close();
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
}

缓冲流

为了提高数据读写的速度，Java API 提供了带缓冲功能的流类：缓冲流是处理流之一

缓冲流要 “套接” 在相应的节点流之上，根据数据操作单位可以把缓冲流分为：

• 字节缓冲流：BufferedInputStream，BufferedOutputStream
• 字节缓冲流：BufferedInputStream，BufferedOutputStream

缓冲流的基本原理：在创建流对象时，内部会创建一个缓冲区数组（缺省使用 8192 个字节(8Kb)的缓冲区），通过缓冲区读写，减少系统 IO 次数，从而提高读写的效 率

构造器：

• public BufferedInputStream(InputStream in) ：创建一个 新的字节型的缓冲输入流
• public BufferedOutputStream(OutputStream out)： 创建一个新的字节型的缓冲输出流
• public BufferedReader(Reader in) ：创建一个 新的字符型的缓冲输入流
• public BufferedWriter(Writer out)： 创建一个新的字符型的缓冲输出流

代码

@Test
public void test1() throws IOException {
  // 创建字节缓冲输入流 / 输出流
  BufferedInputStream bis = new BufferedInputStream(new FileInputStream("abc.jpg"));
  BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("abc-copy.jpg"));
  // // 创建字符缓冲输入流 / 输出流
  BufferedReader br = new BufferedReader(new FileReader("abc.txt"));
  BufferedWriter bw = new BufferedWriter(new FileWriter("abc-copy.txt"));

}

字符缓冲流特有方法

@Test
public void test2() throws IOException {
  // 创建流对象
  BufferedReader br = new BufferedReader(new FileReader("abc.txt"));
  // 定义字符串,保存读取的一行文字
  String s;
  //  循环读取,读取到最后返回 null
  while ((s=br.readLine())!=null){
    System.out.println(s);
  }
  br.close();
}

转换流

转换流也是处理流之一，处理数据编码问题

InputStreamReader

构造器

• InputStreamReader(InputStream in): 创建一个使用默认字符集的字符流
• InputStreamReader(InputStream in, String charsetName): 创建一个指定字符集的字符流

InputStreamReader isr1 = new InputStreamReader(new FileInputStream("in.txt"));
//使用指定字符集
InputStreamReader isr2 = new InputStreamReader(new FileInputStream("in.txt") , "GBK");

OutputStreamWriter

**构造器 **

• OutputStreamWriter(OutputStream in): 创建一个使用默认字符集的字符流
• OutputStreamWriter(OutputStream in,String charsetName): 创建一个指定字符集的字符流

//使用默认字符集
OutputStreamWriter isr = new OutputStreamWriter(new FileOutputStream("out.txt"));
//使用指定的字符集
OutputStreamWriter isr2 = new OutputStreamWriter(new FileOutputStream("out.txt") , "GBK");

字符编码和字符集

将字符存储到计算机中，称为编码 。反之，将存储在计算机中的二进制数按照某种 规则解析显示出来，称为解码

编码:字符(人能看懂的)–>字节(人看不懂的)

解码:字节(人看不懂的)–>字符(人能看懂的)

字符集

• 字符集 Charset：也叫编码表。是一个系统支持的所有字符的集合，包括各国家文 字、标点符号、图形符号、数字等
• 计算机要准确的存储和识别各种字符集符号，需要进行字符编码，一套字符集必然至 少有一套字符编码。常见字符集有 ASCII 字符集、GBK 字符集、Unicode 字符集等

常见的字符集：

1. ASCII 字符集：用于显示现代英语
2. ISO-8859-1 字符集：拉丁码表，用于显示欧洲使用的语言
3. GBK：最常用的中文码表
4. Unicode 字符集：表达任意语言的任意字符而设计，也称为统一码、标准万国码
5. UTF-8 字符集：Unicode 是字符集，UTF-8、UTF-16、UTF-32 是三种将数字转换到程序数据的编码方案

举例：将字符编码为 gbk 的txt文件复制一份转成 utf-8

@Test
public void test3() {
  OutputStreamWriter osw = null;
  InputStreamReader isr = null;
  try {

    FileInputStream fis = new FileInputStream("abc.txt");
    FileOutputStream fisCopy = new FileOutputStream("abc-copy-utf-8.txt");
    isr = new InputStreamReader(fis, "gbk");
    osw = new OutputStreamWriter(fisCopy, "utf-8");
    char[] cbuf = new char[1024];
    int len;
    while ((len = isr.read(cbuf)) != -1) {
      osw.write(cbuf, 0, len);
      osw.flush();
    }
    System.out.println("操作成功");

  } catch (IOException e) {
    e.printStackTrace();
  } finally {
    try {
      if (osw != null)
        osw.close();
    } catch (IOException e) {
      throw new RuntimeException(e);
    }
    try {
      if (isr != null)
        isr.close();
    } catch (IOException e) {
      throw new RuntimeException(e);
    }
  }

}

数据流 对象流

将内存中定义的变量（包括基本数据类型或引用数据类型）保存在文件中，采用数据流或对象流，它们也是处理流之一

数据流

• DataOutputStream：允许应用程序将基本数据类型、String 类型的变量写入输出流中
• DataInputStream：允许应用程序以与机器无关的方式从底层输入流中读取基本数据类型、String 类型的变量

​ 常用方法：见名知意，对象流 DataOutputStream 中的方法：read 改为相应的 write

• byte readByte()

• short readShort()

• int readInt()

• long readLong()

• float readFloat()

• double readDouble()

• char readChar()

• boolean readBoolean()

• String readUTF()

• void readFully(byte[] b)

对象流

• ObjectOutputStream：将 Java 基本数据类型和对象写入字节输出流中。 通过在流中使用文件可以实现 Java 各种基本数据类型的数据以及对象的持久存储
• ObjectInputStream：ObjectInputStream 对以前使用 ObjectOutputStream 写出的基本数据类型的数据和对象进行读入操作，保存在内存中

构造器：

• public ObjectOutputStream(OutputStream out)： 创建一个指定的 ObjectOutputStream
• public ObjectInputStream(InputStream in)： 创建一个指定的 ObjectInputStream

FileOutputStream fos = new FileOutputStream("abc.txt");
ObjectOutputStream oos = new ObjectOutputStream(fos);

FileInputStream fis = new FileInputStream("abc.txt");
ObjectInputStream ois = new ObjectInputStream(fis);

方法：对象流 ObjectInputStream 中的方法：read 改为相应的 write

• public void writeBoolean(boolean val)：写出一个 boolean 值。
• public void writeByte(int val)：写出一个 8 位字节
• public void writeShort(int val)：写出一个 16 位的 short 值
• public void writeChar(int val)：写出一个 16 位的 char 值
• public void writeInt(int val)：写出一个 32 位的 int 值
• public void writeLong(long val)：写出一个 64 位的 long 值
• public void writeFloat(float val)：写出一个 32 位的 float 值
• public void writeDouble(double val)：写出一个 64 位的 double 值
• public void writeUTF(String str)：将表示长度信息的两个字节写入输出流，后跟字符串 s 中每个字符的 UTF-8 修改版表示形式。根据字符的值，将字符串 s 中每个字符转 换成一个字节、两个字节或三个字节的字节组。注意，将 String 作为基本数据写入 流中与将它作为 Object 写入流中明显不同。 如果 s 为 null，则抛出 NullPointerException。
• public void writeObject(Object obj)：写出一个 obj 对象 • public void close() ：关闭此输出流并释放与此流相关联的任何系统资源

对象的序列化

对象序列化机制允许把内存中的 Java 对象转换成平台无关的二进制流，从而允许把这种二进制流持久地保存在磁盘上，或通过网络将这种二进制流传输到另 一个网络节点

实现原理：

• 序列化：用 ObjectOutputStream 类保存基本类型数据或对象的机制，writeObject (Object obj) 将指定的对象写出
• 反序列化：用 ObjectInputStream 类读取基本类型数据或对象的机制，readObject() 将对象读入

实现序列化步骤：

1. 类必须实现 java.io.Serializable 接口，该接口是标志接口
2. 类的属性是引用类型，也要实现序列化的话，也要实现Serializable 接口
3. 静态（static）变量的值不会序列化，因为静态变量的值不属于某个对象
4. 是实现 Serializable 接口的类都有一个表示序列化版本标识符的静态变量： static final long serialVersionUID = xxxL

代码：

@Test
public void test1() throws IOException {
  // 序列化基本数据类型
  int num = 6;
  boolean flag = true;
  char ch = 'a';
  String str = "hello";
  double d = 3.14;
  ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("SerializableTest.txt"));
  oos.writeInt(num);
  oos.writeBoolean(flag);
  oos.writeChar(ch);
  oos.writeUTF(str);
  oos.writeDouble(d);
  oos.close();
}
@Test
public void test2() throws IOException {
  // 反序列化
  ObjectInputStream ois = new ObjectInputStream(new FileInputStream("SerializableTest.txt"));
  int num = ois.readInt();
  boolean flag = ois.readBoolean();
  char ch = ois.readChar();
  String str = ois.readUTF();
  double d = ois.readDouble();
  ois.close();
  System.out.print(ch);
  System.out.print(num);
  System.out.print(flag);
  System.out.print(d);
}

序列化对象

public class Student implements Serializable {
  static final long serialVersionUID = 232123213234234L;
  private String name;
  private int age;

  // static 修饰的类变量，不会被序列化
  public static String schoolName;
  // transient 瞬态修饰成员,不会被序列化
  public transient int sId;
  public Student() {
  }

  public Student(String name, int age, int sId) {
    this.name = name;
    this.age = age;
    this.sId = sId;
  }
  // 省略 get / set toString方法。。。
}

// 序列化
@Test
public void test3() throws IOException {
  Student.setSchoolName("java班");
  Student stu = new Student("小明", 20, 101);

  // 创建序列化流对象
  ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("student.txt"));
  oos.writeObject(stu);
  oos.close();
}

// 反序列化
@Test
public void test4() throws IOException, ClassNotFoundException {
  // 创建反系列化对象
  ObjectInputStream ois = new ObjectInputStream(new FileInputStream("student.txt"));
  Student stu = (Student) ois.readObject();
  System.out.println(stu);
  ois.close();
}

注意：如果有多个对象需要序列化，则可以将对象放到集合中，再序列化集 合对象即可

其他流

标准输入、输出流

• System.in 和 System.out 分别代表了系统标准的输入和输出设备

• 默认输入设备是：键盘，输出设备是：显示器

• System.in 的类型是 InputStream

• System.out 的类型是 PrintStream，其是 OutputStream 的子类 FilterOutputStream 的 子类

• 重定向：通过 System 类的 setIn，setOut 方法对默认设备进行改变

​ 1. public static void setIn(InputStream in)

​ 2. public static void setOut(PrintStream out)

例子，将键盘读正行字母转大写，按e，exit 退出

public static void main(String[] args) throws IOException {
  BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
  String str = null;
  while ((str = br.readLine()) != null) {
    if ("e".equalsIgnoreCase(str) || "exit".equalsIgnoreCase(str)) {
      break;
    }
    System.out.println(str.toUpperCase());
    System.out.println("继续输入：");
  }
  br.close();
}

打印流

打印流：PrintStream 和 PrintWriter

实现将基本数据类型的数据格式转化为字符串输出

提供了一系列重载的 print()和 println()方法，用于多种数据类型的输出

Scanner 类

构造方法

• Scanner(File source) ：构造一个新的 Scanner，它生成的值是从指定文件扫描
• Scanner(File source, String charsetName) ：构造一个新的 Scanner，它生成的值是从 指定文件扫描
• Scanner(InputStream source) ：构造一个新的 Scanner，它生成的值是从指定的输入 流扫描
• Scanner(InputStream source, String charsetName) ：构造一个新的 Scanner，它生成 的值是从指定的输入流扫描

常用方法：

• boolean hasNextXxx()： 如果通过使用 nextXxx()方法，此扫描器输入信息中的下一个 标记可以解释为默认基数中的一个 Xxx 值，则返回 true
• Xxx nextXxx()： 将输入信息的下一个标记扫描为一个 Xxx

apache-common 包

IO 技术开发中，代码量很大，而且代码的重复率较高，为此 Apache 软件基金 会，开发了 IO 技术的工具类 commonsIO，大大简化了 IO 开发。 Apahce 软件基金会属于第三方，（Oracle 公司第一方，我们自己第二方，其他 都是第三方）我们要使用第三方开发好的工具，需要添加 jar 包

参考资料

尚硅谷Java基础