IO数据流

File类

文件和目录路径名的抽象表示形式。java把电脑中的文件和文件夹（目录）封装为了一个File类，我们可以使用File类对文件和文件夹进行操作

构造方法

File(String pathname)

通过将给定路径名用字符串转换为抽象路径来创建一个新的File实例

• 参数：
  String pathname：字符串的路径名称
  路径可以是以文件结尾，也可以是以文件夹结尾
  路径可以是相对路径，也可以是绝对路径
  路径可以是存在，也可以是不存在
  创建File对象，只是把字符串路径封装为File对象，不考虑路径的真假情况

File(String parent,String child)

根据parent路径名字符串和child路径名字符串创建一个新File实例

• 参数：把路径分成了两部分
  String parent：父路径
  String child：子路径
• 好处：父路径和子路径，可以单独书写，使用起来非常灵活；父路径和子路径都可以变化

File(File parent,String child)

根据parent抽象路径名和child路径名字符串创建一个新File实例

• 参数：把路径分成了两部分
  File parent：父路径
  String child：子路径

  private static void show03(){
      File parent = new File("c:\\");
      File file = new File(parent,"hello.java");
      System.out.println(file);
  }

• 好处：
  父路径和子路径，可以单独书写，使用起来非常灵活；父路径和子路径都可以变化
  父路径是File类型，可以使用File的方法对路径进行一些操作，再使用路径创建对象

File类的方法

创建一个文件/文件夹

• public boolean createNewFile():
  当且仅当具有该名称的文件尚不存在时，创建一个新的空文件。

  • 创建文件的路径和名称在构造方法中给出（构造方法的参数）
  • 返回值：布尔值
    true：文件不存在，创建文件，返回true
    false：文件存在，不会创建，返回false
  • 注意：
    1.此方法只能创建文件，不能创建文件夹
    2.创建文件的路径必须存在，否则会抛出异常
  • 一般写 public boolean createNewFile() throws IOException
    因为createNewFile声明抛出了IOException，我们调用这个方法，就必须处理这个异常，要么throws,要么trycatch
    如果路径不存在，抛出IOException

• public boolean mkdir():创建由此File表示的目录
  创建单级空文件夹。
  public boolean mkdirs():创建由此File表示的目录，包括任何必需但不存在的父目录
  既可以创建单级空文件夹，也可以创建多级文件夹

  • 返回值：布尔值
    true：文件夹不存在，创建文件夹，返回true
    false：文件夹存在，不会创建，返回false；构造方法中给出的路径不存在返回false
  • 注意：
    1.此方法只能创建文件夹，不能创建文件
    2.路径不存在不会创建，但不会报异常

删除文件/文件夹

• public boolean delete():
  删除由此File表示的文件或目录。

  • 返回值：布尔值

• true：文件/文件夹删除成功，返回true
• false：文件夹中有内容，不会删除返回false；构造方法中路径不存在false
  • • 注意：
• delete方法是直接在硬盘删除文件/文件夹，不走回收站，删除要谨慎。

获取文件/文件夹

• File类获取功能的方法

  • public String getAbsolutePath():
    返回此File的绝对路径名字符串：
    f1.getAbsolutePath();
    获取的构造方法中传递的路径
    无论路径是绝对的还是相对的，getAbsolutePath()方法返回的都是绝对路径
  • public String getPath()：将此File住那换为路径名字符串：f1.getPath();
    获取的构造方法中传递的路径
    toString方法调用的就是getPath方法
    源码：
    public String toString(){
    return getPath();
    }
  • public String getName()：返回由此File表示的文件或目录的名称：f1.getName();
    获取的就是构造方法传递路径的结尾部分（文件/文件夹）

判断文件/文件夹是否存在

• File判断功能的方法

  • public boolean exists():此file表示的文件或者目录是否实际存在。
    用于判断构造方法中的路径是否存在
  • 存在：true
  • 不存在：false

  • public boolean isDirectory():此file表示的是否为目录。
    用于判断构造方法中给定的路径是否以文件夹结尾

  • public boolean isFile()：此file表示的是否为文件。
    用于判断构造方法中给定的路径是否以文件结尾

  • 注意

    • 电脑的硬盘中只有文件/文件夹，两个方法是互斥
      这两个方法使用前提，路径必须是存在的，否则都返回false

对文件夹进行遍历

• File类遍历（文件夹）目录功能

  • public String[] list():返回一个String数组，表示该File目录中的所有子文件或目录。
    遍历构造方法中给出的目录，会获取目录中所有文件/文件夹的名称，把获取到的多个名称存储到一个String类型的数组中
  • public File[] listFiles():返回一个File目录中所有的子文件或目录。
    遍历构造方法中给出的目录，会获取目录中所有的文件/文件夹，把文件/文件夹封装为File对象储存到一个String类型的数组中
  • 注意：
    list方法和listFile方法遍历的是构造方法中给出的目录
    如果构造方法中给出的目录路径不存在，会抛出空指针异常
    如果构造方法中给出的路径不是一个目录，也会抛出空指针异常

获取文件的大小

• public Long length()：返回由此File表示的文件的长度：f1.length();
  获取的就是构造方法指定的文件的大小，以字节为单位
  注意：
  1.文件夹是没有大小概念的。不能获取文件夹的大小
  2. 如果构造方法中给出的路径不存在，那么length方法返回0

路径

绝对路径：是一个完整的路径

以盘符（C:,D:）开始的路径

相对路径：是一个简化的路径

相对指的是相对于当前项目的根目录

注意：

1.路径是不区分大小写的
2.路径中的文件名称分隔符Windows使用反斜杠，反斜杠是转义字符，两个反斜杠代表一个普通的反斜杠

分隔符

路径分隔符 Windows：分号； Linux：冒号：
文件名称分隔符 windows:反斜杠\ Linux：正斜杠/

String pathSeparator 与系统有关的路径分隔符

String separator 与系统有关的默认名称分隔符

=================

=================

=================

IO流

java.io.OutputStream:字节输出流

此抽象类是表示输出字节流的所有类的超类

• java.io.FileOutputStream extends OutputStream
  FileOutputStream:文件字节输出流
  作用：把内存中的数据写入到硬盘中

• 构造方法

  • FileOutputStream(String name)创建一个向指定名称的文件夹中写入数据的输出文件流。

  • FileOutputStream(File file)创建一个向指定File对象表示的文件中写入数据的文件输出流。

  • 作用

    • 1.创建一个FileOutputStream对象
    • 2.会根据构造方法中传递的文件/文件路径，创建一个空的文件
    • 3.会把FileOutputStream对象指向创建好的文件

子类共性的成员方法

-  public void close（）：关闭此输出流并释放与此流相关联的任何系统资源。
-  public void flush(): 刷新此输出流并强制任何缓冲的输出字节被写出。
-  public void write(byte[] b): 将b.length字节从指定的数组写入此输入流。

• 一次写多个字节
  如果写的第一个字节是正数（0-127），那么显示的时候会查询ASCII表
  如果写的第一个字节是负数，那第一个字节会和第二个字节，两个字节组成一个中文显示，查询系统默认码表（GBK）

  • public void write(byte[] b，int off, int len): 从制定的字节数组写入len字节，从偏移量off开始，输出到此输出流。

    • 把字节数组的一部分写入到文件中
      int off:数组的开始索引
      int len：写几个字节

    • 写入字符串的方法：可以使用String类中的方法把字符串，转换为字节数组
      byte[] getBytes() 把字符串转换为字节数组

      byte[] bytes1 = “你好”.getBytes();
      System.out.println(Arrays.toString(bytes1));//[-28, -67, -96, -27, -91, -67]
      fos.write(bytes1);

  • public abstract void write(int b):将指定的字节输出流,写一个字节的方法

字节输出流的使用步骤

• 1.创建一个FileOutputStream对象，构造方法中传递写入数据的目的地

    - FileOutputStream fos = new FileOutputStream("D:\\IDEA\\demo011-code\\a.txt");
  

• 2.调用一个FileOutputStream对象中的方法write，把数据写入到文件中

    -  fos.write(97);
  

• 3.释放资源（流使用会占用一定的内存，使用完毕要把内存清空，提高程序的效率）

    - fos.close();
  

写入数据的原理（内存–>硬盘）

- Java程序-->jvm（Java虚拟机）-->OS（操作系统）-->OS调用写数据的方法-->把数据写入到文件中

追加/续写

  FileOutputStream fos = new FileOutputStream("D:\\IDEA\\demo011-code\\c.txt",true);
  fos.write("你好".getBytes(StandardCharsets.UTF_8));
  fos.close();

• 构造方法

    - FileOutputStream(String name,boolean append)创建一个向指定name的文件中写入数据的输出文件流。
    - FileOutputStream(File file,boolean append)创建一个向指定File对象表示的文件中写入数据的文件输出流。
  

• 参数

    -  String name,File file:写入数据的目的地
    -  Boolean append：追加写开关
    -    true：创建对象不会覆盖源文件，继续在文件的末尾追加写数据
    - 	 false：创建一个新文件，覆盖源文件
  

• 写换行：写换行符号

  FileOutputStream fos1 = new FileOutputStream(new File("D:\\IDEA\\demo011-code\\c.txt"));
  for (int i = 1;i <= 10;i++){
      fos1.write("你好".getBytes(StandardCharsets.UTF_8));
      fos1.write("\r\n".getBytes(StandardCharsets.UTF_8));
      
    -    windows：\r\n
    -    linux：/n
    -    mac:/r
  

java.io.InputStream:字节输入流

此类抽象类是表示字节输入流的所有类的超类。

• java.io.FileInputStream extends InputStream
  FileInputStream:文件字节输入流
  作用：把硬盘文件中的数据，读取到内存中使用

• 构造方法

  • FileInputStream(String name)

  • FileInputStream(File file)

  • 作用

    • 1.会创建一个FileInputStream对象
    • 2.会把FileInputStream对象指定构造方法中要读取的文件

子类共性的方法

- int read()从输入流中读取数据的下一个字节。
- int read(byte[] b)从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中。
- void close()关闭此输入流并释放与该流关联的所有系统资源。

• 参数：读取文件的数据源

  • String name:文件的路径
  • File file:文件

读取数据的原理（硬盘–>内存）

- java程序———>JVM——>OS——>OS读取数据的方法——>读取文件

字节输入流的使用步骤

• 1.创建FileInputStream对象，构造方法中绑定要读取的数据源

• 2.使用FileInputStream对象中的方法read，读取文件

  • int read();读取文件是一个重复的过程，所以可以使用循环优化
    不知道文件中有多少字节，使用while循环
    while循环结束条件，读取到-1的时候结束，布尔表达式（len-fis.read()）!= -1
    1.fis.read():读取一个字节
    2.len = fis.read():把读取到的字节赋值给变量len
    3.(len = fis.read())!=-1:判断变量len受否不等于-1

  注意：必须用变量来接收指针，因为读完之后指针直接后移，再返回的时候会丢失第一个数

    int len1 = 0;
    while((len1 = fis.read())!=-1){
        System.out.println((char) len1);
    }
  

• 3.释放资源

文件复制

• 明确
  数据源
  数据目的地

• 步骤

  • 1.创建一个字节输入流对象，构造方法中绑定要读取的数据源

  • 2.创建一个字节输入流对象，构造方法中绑定要写入的目的地

  • 3.使用字节输入流对象中的方法read读取文件

    • 一次读取一个字节写入一个字节的方式

    int len = 0;
    while((len- fis.read())!=-1){
    fos.write(len);
    }

    • 优化：使用数组缓冲读取多个字节，写入多个字节；这样快的多

      byte[] bytes = new byte[1024];
      int len1=0;//每次读取的有效字节个数
      while((len1=fis.read(bytes))!=-1){
      fos.write(bytes,0,len1);
      }

  • 4.使用字节输出流中的方法write，把读取到的字节写入到目的地的文件中

  • 5.释放资源

    • （先关写的，后关闭读的；如果写完了，肯定读取完毕了）
      fos.close();
      fis.close();

java.io.Reader:字符输入流，

是字符输入流的最顶层的父类，定义了一些共性的成员方法，是一个抽象类

• java.io.FileReader extends InputStreamReader extends Reader
  FileReader:文件字符输入流
  作用：把硬盘文件中的数据以字符串的方式读取到内存中

• 构造方法

  • FileReader(String fileName)
    String fileName:文件的路径
  • FileReader(File file)
    File file:一个文件

• 作用
  - 1.创建一个FileReader对象
  - 2.会把FileReader对象指向要读取的文件

共性的成员方法

• int read():读取单个字符并返回。
• int read(char[] cbuf)一次读取多个字符，将字符读入数组。
• void close()关闭该流并释放与之关联的所有资源。

使用步骤

• 1.创建FileReader对象，构造方法中绑定要读取的数据源

• 2.使用FileReader对象中的方法read读取文件

   - int read()读取文件中的单个字节并返回
   int len = 0;
     while((len= fr.read())!= -1){
         System.out.print((char) len);
     }
     
   - int read(char[] cbuf)一次读取多个字符，将字符读入数组
  
     char[] cs = new char[1024];//存储读取到的多个字符
     int len = 0;
     while((len= fr.read(cs))!= -1){
         /*String类的构造方法
         * String(char[] value)把字符数组转换为字符串
         * String(char[] value,int offset,int count)把数组的一部分转换为字符串
         * offset数组开始的索引
         * count转换的个数*/
         System.out.println(new String(cs,0,len));
     }
  

• 3.释放资源

java.io.writer:字符输出流，

是所有字符输出流的最顶层的父类，是一个抽象类

• java.io.FileWriter extends OutputStreamWriter extends Writer
  FileWriter:文件字符输出流
  作用：把内存中字符数据写到文件中

• 构造方法

  • FileWriter(File file)根据给定的File对象构造一个FileWriter对象。
    String fileName:文件的路径

  • FileWriter(String fileName)根据给定的文件名构造一个FileWriter对象。
    File file:文件

  • 作用

    • 1.会创建一个FileWriter对象
    • 2.会根据构造方法中传递的文件/文件的路径，创建文件
    • 3.会把FileWriter对象指向创建好的文件

共性的成员方法

• void write(int c)：写入单个字符

• void write(char[] cbuf)：写入字符数组

  FileWriter fw = new FileWriter("D:\\IDEA\\demo011-code\\e.txt");
  char[] cs = {'a','b','c','d','e'};
  fw.write(cs);
  

• abstract void write(char[] cbuf,int off,int len)：写入字符数组的某一部分，off数组的开始索引，len的字符个数。
  fw.write(cs,1,3);

• void write(String str)：写入字符串
  fw.write(“字符流”);

• void write(String str,int off,int len)：写入字符数串的某一部分，off字符串的开始索引，len写的字符个数。
  fw.write(“广联达科技股份有限公司”,3,4);//科技股份

• void flush()：刷新该流的缓冲
  刷新缓冲区，流对象可以继续使用

• void close()：关闭此流，但要先刷新它。

    - 先刷新缓冲区，然后通知系统释放资源，流对象不可以再被使用了。
    - close方法之后流已经关闭了，已经从内存中消失了，流就不能再用了
  

再写的话就会抛出IOException:Stream closed

使用步骤

• 1.创建FileWriter对象，构造方法中绑定要写入数据的目的地
• 2.使用FileWriter中的方法write，把数据写入到内存缓冲区中（字符转换为字节的过程）
• 3.使用FileWriter中的方法flush，把内存缓冲区中的数据，刷新到文件中
• 4.释放资源（会先把内存缓冲区中的数据刷新到文件中）

续写/换行

• 构造方法

    - FileWriter（string fileName,boolean append）
    -  FileWriter(File file,boolean append)
  

• 参数

    -  String fileName,File file:写入数据的目的地
    -  boolean append：续写开关 
    - true:不会创建新的文件覆盖源文件，可以续写；false：创建新的文件覆盖源文件
  

• 换行

    - windows：\r\n
    - linux：/n
    - mac:/r