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

系统管理员 2023-09-25 13:13 56阅读 0赞

#### 这里写目录标题 ####

*   *  File类
     *   *  File类概述和构造方法
         *  File类创建功能
         *  File类判断和获取功能
         *  File类删除功能
     *  IO流
     *   *  字节流写数据
         *  字节流写数据的三种方式
     *  字节缓冲流
     *   *  字节缓冲流构造方法
     *  字符流
     *   *  字符流写数据的5种方式
         *  字符流读数据的2种方式

### 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();
        }
    }