测试开发之Java文件操作、IO流篇

File类

File类概述和构造方法

File类介绍

• 它是文件和目录路径名的抽象表示
• 文件和目录是可以通过File封装成对象的
• 对于File而言，其封装的并不是一个真正存在的文件，仅仅是一个路径名而已。它可以是存在的，也可以是不存在的。将来是要通过具体的操作把这个路径的内容转换为具体存在的

File类的构造方法

• File(String pathname) 通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例
• File(String parent, String child) 从父路径名字符串和子路径名字符串创建新的 File实例
• File(File parent, String child) 从父抽象路径名和子路径名字符串创建新的 File实例

File类创建功能

方法分类

• public boolean createNewFile() 当具有该名称的文件不存在时，创建一个由该抽象路径名命名的新空文件
• public boolean mkdir() 创建由此抽象路径名命名的目录
• public boolean mkdirs() 创建由此抽象路径名命名的目录，包括任何必需但不存在的父目录

  public class FileDemo02{
      public static void main(String[] args) throws IOException {
          //需求1：我要在/Volumes/DATA1/000-develop/demo目录下创建一个文件java.txt
          File f1 = new File("/Volumes/DATA1/000-develop/demo/java.txt");
          System.out.println(f1.createNewFile());
          System.out.println("--------");
  
          //需求2：我要在/Volumes/DATA1/000-develop/demo目录下创建一个目录JavaSE
          File f2 = new File("/Volumes/DATA1/000-develop/demo/JavaSE");
          System.out.println(f2.mkdir());
          System.out.println("--------");
  
          //需求3：我要在/Volumes/DATA1/000-develop/demo目录下创建一个多级目录JavaWEB/HTML
          File f3 = new File("/Volumes/DATA1/000-develop/demo/JavaWEB/HTML");
          //System.out.println(f3.mkdir());
          System.out.println(f3.mkdirs());
          System.out.println("--------");
  
          //需求4：我要在/Volumes/DATA1/000-develop/demo目录下创建一个文件javase.txt
          File f4 = new File("/Volumes/DATA1/000-develop/demo/javase.txt");
          //System.out.println(f4.mkdir());
          System.out.println(f4.createNewFile());
      }
  }

File类判断和获取功能

判断功能

• public boolean isDirectory() 测试此抽象路径名表示的File是否为目录
• public boolean isFile() 测试此抽象路径名表示的File是否为文件
• public boolean exists() 测试此抽象路径名表示的File是否存在

获取功能

• public String getAbsolutePath() 返回此抽象路径名的绝对路径名字符串
• public String getPath() 将此抽象路径名转换为路径名字符串
• public String getName() 返回由此抽象路径名表示的文件或目录的名称
• public String[] list() 返回此抽象路径名表示的目录中的文件和目录的名称字符串数组
• public File[] listFiles() 返回此抽象路径名表示的目录中的文件和目录的File对象数组

  public class FileDemo04 {
      public static void main(String[] args) {
          //创建一个File对象
          File f = new File("myFile/java.txt");
  
          //public boolean isDirectory()：测试此抽象路径名表示的File是否为目录
          //public boolean isFile()：测试此抽象路径名表示的File是否为文件
          //public boolean exists()：测试此抽象路径名表示的File是否存在
          System.out.println(f.isDirectory());
          System.out.println(f.isFile());
          System.out.println(f.exists());
  
          //public String getAbsolutePath()：返回此抽象路径名的绝对路径名字符串
          //public String getPath()：将此抽象路径名转换为路径名字符串
          //public String getName()：返回由此抽象路径名表示的文件或目录的名称
          System.out.println(f.getAbsolutePath());
          System.out.println(f.getPath());
          System.out.println(f.getName());
          System.out.println("--------");
  
          //public String[] list()：返回此抽象路径名表示的目录中的文件和目录的名称字符串数组
          //public File[] listFiles()：返回此抽象路径名表示的目录中的文件和目录的File对象数组
          File f2 = new File("/Volumes/DATA1/000-develop/IdeaProjects/myFile");
  
          String[] strArray = f2.list();
          for(String str : strArray) {
              System.out.println(str);
          }
          System.out.println("--------");
  
          File[] fileArray = f2.listFiles();
          for(File file : fileArray) {
              //System.out.println(file);
              //System.out.println(file.getName());
              if(file.isFile()) {
                  System.out.println(file.getName());
              }
          }
      }
  }

File类删除功能

方法分类

• public boolean delete() 删除由此抽象路径名表示的文件或目录

  public class FileDemo03 {
      public static void main(String[] args) throws IOException {
          //File f1 = new File("/Volumes/DATA1/000-develop/IdeaProjects/myFile/java.txt");
          //需求1：在当前模块目录下创建java.txt文件
          File f1 = new File("myFile/java.txt");
          System.out.println(f1.createNewFile());
  
          //需求2：删除当前模块目录下的java.txt文件
          System.out.println(f1.delete());
          System.out.println("--------");
  
          //需求3：在当前模块目录下创建itcast目录
          File f2 = new File("myFile/itcast");
          System.out.println(f2.mkdir());
  
          //需求4：删除当前模块目录下的itcast目录
          System.out.println(f2.delete());
          System.out.println("--------");
  
          //需求5：在当前模块下创建一个目录itcast,然后在该目录下创建一个文件java.txt
          File f3 = new File("myFile/itcast");
          System.out.println(f3.mkdir());
          File f4 = new File("myFile/itcast/java.txt");
          System.out.println(f4.createNewFile());
  
          //需求6：删除当前模块下的目录itcast
          System.out.println(f4.delete());
          System.out.println(f3.delete());
      }
  }

IO流

字节流写数据

字节流抽象基类

InputStream：这个抽象类是表示字节输入流的所有类的超类
OutputStream：这个抽象类是表示字节输出流的所有类的超类
子类名特点：子类名称都是以其父类名作为子类名的后缀
字节输出流

FileOutputStream(String name)：创建文件输出流以指定的名称写入文件
使用字节输出流写数据的步骤

创建字节输出流对象(调用系统功能创建了文件，创建字节输出流对象，让字节输出流对象指向文件)
调用字节输出流对象的写数据方法
释放资源(关闭此文件输出流并释放与此流相关联的任何系统资源)

public class FileOutputStreamDemo01 {
    public static void main(String[] args) throws IOException {
        //创建字节输出流对象
        //FileOutputStream(String name)：创建文件输出流以指定的名称写入文件
        FileOutputStream fos = new FileOutputStream("myByteStream/fos.txt");
        /*
            做了三件事情：
                A:调用系统功能创建了文件
                B:创建了字节输出流对象
                C:让字节输出流对象指向创建好的文件
         */

        //void write(int b)：将指定的字节写入此文件输出流
        fos.write(97);
//        fos.write(57);
//        fos.write(55);

        //最后都要释放资源
        //void close()：关闭此文件输出流并释放与此流相关联的任何系统资源。
        fos.close();
    }
}

字节流写数据的三种方式

• void write(int b) 将指定的字节写入此文件输出流 一次写一个字节数据
• void write(byte[] b) 将 b.length字节从指定的字节数组写入此文件输出流 一次写一个字节数组数据
• void write(byte[] b, int off, int len) 将
  len字节从指定的字节数组开始，从偏移量off开始写入此文件输出流 一次写一个字节数组的部分数据

  public classFileOutputStreamDemo02 {
      public static void main(String[] args) throws IOException {
          //FileOutputStream(String name)：创建文件输出流以指定的名称写入文件
          FileOutputStream fos = new FileOutputStream("myByteStream/fos.txt");
          //new File(name)
  //        FileOutputStream fos = new FileOutputStream(new File("myByteStream/fos.txt"));
  
          //FileOutputStream(File file)：创建文件输出流以写入由指定的 File对象表示的文件
  //        File file = new File("myByteStream/fos.txt");
  //        FileOutputStream fos2 = new FileOutputStream(file);
  //        FileOutputStream fos2 = new FileOutputStream(new File("myByteStream/fos.txt"));
  
          //void write(int b)：将指定的字节写入此文件输出流
  //        fos.write(97);
  //        fos.write(98);
  //        fos.write(99);
  //        fos.write(100);
  //        fos.write(101);
  
  //        void write(byte[] b)：将 b.length字节从指定的字节数组写入此文件输出流
  //        byte[] bys = {97, 98, 99, 100, 101};
          //byte[] getBytes()：返回字符串对应的字节数组
          byte[] bys = "abcde".getBytes();
  //        fos.write(bys);
  
          //void write(byte[] b, int off, int len)：将 len字节从指定的字节数组开始，从偏移量off开始写入此文件输出流
  //        fos.write(bys,0,bys.length);
          fos.write(bys,1,3);
  
          //释放资源
          fos.close();
      }
  }

字节缓冲流

字节缓冲流构造方法

字节缓冲流介绍

lBufferOutputStream：该类实现缓冲输出流。 通过设置这样的输出流，应用程序可以向底层输出流写入字节，而不必为写入的每个字节导致底层系统的调用

lBufferedInputStream：创建BufferedInputStream将创建一个内部缓冲区数组。 当从流中读取或跳过字节时，内部缓冲区将根据需要从所包含的输入流中重新填充，一次很多字节

构造方法：
BufferedOutputStream(OutputStream out) 创建字节缓冲输出流对象
BufferedInputStream(InputStream in) 创建字节缓冲输入流对象

public class BufferStreamDemo {
    public static void main(String[] args) throws IOException {
        //字节缓冲输出流：BufferedOutputStream(OutputStream out)
 
        BufferedOutputStream bos = new BufferedOutputStream(new 				                                       FileOutputStream("myByteStream/bos.txt"));
        //写数据
        bos.write("hello\r\n".getBytes());
        bos.write("world\r\n".getBytes());
        //释放资源
        bos.close();
    

        //字节缓冲输入流：BufferedInputStream(InputStream in)
        BufferedInputStream bis = new BufferedInputStream(new                                                          FileInputStream("myByteStream/bos.txt"));

        //一次读取一个字节数据
//        int by;
//        while ((by=bis.read())!=-1) {
//            System.out.print((char)by);
//        }

        //一次读取一个字节数组数据
        byte[] bys = new byte[1024];
        int len;
        while ((len=bis.read(bys))!=-1) {
            System.out.print(new String(bys,0,len));
        }

        //释放资源
        bis.close();
    }
}

字符流

字符流写数据的5种方式

void write(int c) 写一个字符
void write(char[] cbuf) 写入一个字符数组
void write(char[] cbuf, int off, int len) 写入字符数组的一部分
void write(String str) 写一个字符串
void write(String str, int off, int len) 写一个字符串的一部分

刷新和关闭的方法
flush() 刷新流，之后还可以继续写数据
close() 关闭流，释放资源，但是在关闭之前会先刷新流。一旦关闭，就不能再写数据

public class OutputStreamWriterDemo {
    public static void main(String[] args) throws IOException {
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("myCharStream/osw.txt"));

        //void write(int c)：写一个字符
//        osw.write(97);
//        osw.write(98);
//        osw.write(99);

        //void writ(char[] cbuf)：写入一个字符数组
        char[] chs = {'a', 'b', 'c', 'd', 'e'};
//        osw.write(chs);

        //void write(char[] cbuf, int off, int len)：写入字符数组的一部分
//        osw.write(chs, 0, chs.length);
//        osw.write(chs, 1, 3);

        //void write(String str)：写一个字符串
//        osw.write("abcde");

        //void write(String str, int off, int len)：写一个字符串的一部分
//        osw.write("abcde", 0, "abcde".length());
        osw.write("abcde", 1, 3);

        //释放资源
        osw.close();
    }
}

字符流读数据的2种方式

方法介绍
int read() 一次读一个字符数据
int read(char[] cbuf) 一次读一个字符数组数据

public class InputStreamReaderDemo {
    public static void main(String[] args) throws IOException {
   
        InputStreamReader isr = new InputStreamReader(new FileInputStream("myCharStream/ConversionStreamDemo.java"));

        //int read()：一次读一个字符数据
//        int ch;
//        while ((ch=isr.read())!=-1) {
//            System.out.print((char)ch);
//        }

        //int read(char[] cbuf)：一次读一个字符数组数据
        char[] chs = new char[1024];
        int len;
        while ((len = isr.read(chs)) != -1) {
            System.out.print(new String(chs, 0, len));
        }

        //释放资源
        isr.close();
    }
}