Java核心之file类、I/O流的字节流

File类(重点)

• 基本概念

  java.io.File类主要用于描述硬盘上文件和目录的路径信息。

  使用该类可以获取文件的大小等特征信息。

-常用的方法

File(String pathname) - 根据参数指定的路径名来构造对象.

boolean exists() - 测试此抽象路径名表示的文件或目录是否存在.

boolean delete() - 用于删除文件,当删除目录时要求是空目录.

boolean createNewFile() - 用于创建新的空文件.

boolean mkdir() - 用于创建目录.

boolean mkdirs() - 用于创建多级目录.

import java.io.File;
import java.io.IOException;
public class FileTest {
  public static void main(String[] args) throws IOException {
    // 1.构造File类型的对象与c:/a.txt文件关联
    File f1 = new File("c:/a.txt");
    // 2.判断文件是否存在，若存在则获取文件大小并打印后删除文件
    if(f1.exists()) {
      System.out.println("文件的大小是：" + f1.length());
      System.out.println(f1.delete()? "删除文件成功": "删除文件失败");
    }
    //   若文件不存在，则创建新的空文件
    else {
      System.out.println(f1.createNewFile()? "创建文件成功！": "创建文件失败！");
    }
    System.out.println("--------------------------------------");

    // 3.构造File类型的对象与c:/捣乱目录关联
    File f2 = new File("c:/捣乱/猜猜我是谁/就不告诉你/死鬼");
    // 4.判断目录是否存在，若存在则删除目录，否则创建目录
    if(f2.exists()) {
      System.out.println(f2.delete()? "删除目录成功": "删除目录失败");
    } else {
      //System.out.println(f2.mkdir()? "创建目录成功": "创建目录失败");
      System.out.println(f2.mkdirs()? "创建目录成功": "创建目录失败");
    }
  }
}

I/O流

• I/O流的结构

  

• 基本概念

  I/O就是Input/Output的简写，也就是输入/输出的含义。

  I/O流主要指像流水一样不间断地读写的过程。

• 基本分类

  根据数据流动的单位不同分为：字节流 和 字符流。

  其中字节流主要指以单个字节为单位进行读写的流，可以读写任意类型的文件。

  其中字符流主要指以单个字符(2个字节)为单位进行读写的流，只能读写文本文件。

  根据数据流动的方向不同分为：输入流 和 输出流(站在程序的角度)。

  其中输入流主要指将文件中的数据内容输入到程序中，也就是读文件。

  其中输出流主要指将程序中的数据内容输出到文件中，也就是写文件。

FileOutputStream类

• 基本概念

  java.io.FileOutputStream类主要用于将图像数据之类的原始字节流写入输出流中。

• 常用的方法

  void write(int b) - 将指定字节写入此文件输出流.

  void write(byte[] b,int off,int len) - 将指定字节数组中从偏移量off开始的len个字节写入此文件输出流.

  void write(byte[] b) - 将b.length个字节从指定字节数组写入此文件输出流中.

  void close() - 用于关闭文件输出流并释放有关的资源.

import java.io.FileOutputStream;
public class FileOutputStreamTest {
  public static void main(String[] args) {
    try {
      // 1.构造FileOutputStream类型的对象与c:/a.txt文件关联
      // 当文件不存在时，该流会自动创建新的空文件
      // 当文件存在时，该流会清空文件中的原有内容
      FileOutputStream fos = new FileOutputStream("c:/a.txt");
      // 当文件存在时，该流不会清空文件中的原有内容，追加的方式
      //FileOutputStream fos = new FileOutputStream("c:/a.txt", true);

      // 2.使用输出流写入数据内容
      // 当写入一个字符后，文件的读写位置会向右移动一位
      fos.write(65); // 写入单个字节  'A'
      fos.write('6');// 写入单个字节  '6'
      fos.write('5');// 写入单个字节  '5'
      fos.write("hello".getBytes());  //写入整个字符串 "hello"
      System.out.println("写入数据成功！");

      // 3.关闭流对象并释放有关的资源
      fos.close();
    } catch(Exception e) {
      e.printStackTrace();
    }
  }
}

FileInputStream类

• 基本概念

  java.io.FileInputStream类主要用于从输入流中读取图像数据之类的原始字节流。

• 常用方法

  int read() - 读取一个byte无符号填充到int低八位,-1是EOF.

  int read(byte[] b) - 从此输入流中将最多b.length个字节的数据读入一个字节数组中,返回读取的字节的个数.

  int read(byte[] b,int off,int len) - 从此输入流中将最多len个字节的数据读入一个字节数组中.

  void close() - 用于关闭文件输出流并释放有关的资源.

import java.io.FileInputStream;
public class FileInputStreamTest {
  public static void main(String[] args) {
    try {
      // 1.构造FileInputStream类型的对象与c:/a.txt文件关联
      FileInputStream fis = new FileInputStream("c:/a.txt");

      // 2.从输入流中读取数据内容并打印出来
      /*
      int res = fis.read();
      System.out.println("读取到的单个字节是：" + res
        + "，对应的字符是：" + (char)res); // 65  'A'
      // 每当读取一个字节后，读取的位置向后移动
      res = fis.read();
      System.out.println("读取到的单个字节是：" + res
          + "，对应的字符是：" + (char)res); // 54  '6'
      */
      /*
      int res = 0;
      while((res = fis.read()) != -1) {
        System.out.println("读取到的单个字节是：" + res
            + "，对应的字符是：" + (char)res);
      }
      */
      // 期望读取字节数组中的一部分内容
      byte[] bArr = new byte[20];
      // 表示从fis中读取5个字节的数据内容放入数组bArr中从下标2开始的位置
      int res = fis.read(bArr, 2, 5);
      System.out.println("读取到的数据内容是："
        + new String(bArr, 2, res)
        + "，数据大小是：" + res); // A65he

      // 3.关闭流对象并释放有关的资源
      fis.close();
      // 练习：使用FileOutputStream类和FileInputStream类实现文件
      // a.txt到文件b.txt的拷贝。
    } catch(Exception e) {
      e.printStackTrace();
    }
  }
}

##字节流拷贝文件

import java.io.FileInputStream;
import java.io.FileOutputStream;
public class FileCopyTest {
  public static void main(String[] args) {
    try {
      // 1.构造FileInputStream类型的对象与c:/a.txt文件关联
      FileInputStream fis = new FileInputStream("D:\\java30\\day17\\must\\video\\Java基础与设计_Java核心类库和设计_1_作业讲解之Set集合中放入随机数.wmv");
      // 2.构造FileOutputStream类型的对象与c:/b.txt文件关联
      FileOutputStream fos = new FileOutputStream("c:/b.wmv");

      // 3.不断地从输入流中读取数据内容写入到输出流中
      System.out.println("正在玩命地拷贝...");
      // 方式一：当文件稍大时，则拷贝文件的效率很低
      /*
      int res = 0;
      while((res = fis.read()) != -1) {
        fos.write(res);
      }
      */
      // 方式二：准备一个和文件大小一样的缓冲区，一次性将所有内容读出来
      //   将缓冲区的所有内容一次性写入到文件中
      // 该方式的缺点就是：当文件过大时，无法申请与文件大小一样的缓冲区
      /*
      int len = fis.available();
      System.out.println("文件的大小是：" + len);
      byte[] bArr = new byte[len];
      // 将a.txt文件中的内容一次性全部读取到缓冲区中
      int res = fis.read(bArr);
      System.out.println("实际读取到的数据大小是：" + res);
      // 将缓冲区中的所有内容一次性全部写入到b.txt中
      fos.write(bArr);
      */
      // 方式三：准备一个合理的缓冲区，每次将缓冲区读满再写入
      //    在以后的开发中推荐该方式
      byte[] bArr = new byte[1024*8];
      int res = 0;
      while((res = fis.read(bArr)) != -1) {
        fos.write(bArr, 0, res);
      }
      System.out.println("文件拷贝成功！");

      // 4.关闭流对象并释放有关的资源
      fos.close();
      fis.close();
    } catch(Exception e) {
      e.printStackTrace();
    }
  }
}