File类与字节流

IO

• 内存<->磁盘之间的一个读写的一个过程

  • 输入：磁盘->内存

  • 输出：内存->磁盘

• 使用IO流的一般步骤如下：

  1. 创建流对象：

     • 对于输入操作，需要创建相应的输入流对象，如InputStream或Reader。

     • 对于输出操作，需要创建相应的输出流对象，如OutputStream或Writer。

  2. 打开流：

     • 如果是从文件中读取或写入数据，需要将流与文件关联，可以使用FileInputStream、FileOutputStream、FileReader或FileWriter等类来实现。

  3. 读取或写入数据：

     • 使用流对象提供的方法进行读取或写入操作。

  4. 关闭流：

     • 当读取或写入操作完成后，应该关闭流以释放资源和确保操作的完整性。

• File

  • 新建、删除、重命名等文件目录

  public static void main(String[] args){
      File file = new File("F:\\文件目录\\文件目录\\文件名");
      //进行判断路径是否存在,不存在则创建
      if(!file.exists()){
          file.mkdirs();
          System.out.println("------------");
      }
      
      File file1 = new File(file,"test.txt(文件名)");
      if(!file1.exists()){
          file1.createNewFile();
      }
      
      File file2 = new File(file,"test.txt(文件名)");
      file2.delete();
  }

  • 注意：如修改文件名的时候，

    • 如果路径相同，则修改文件名称

    • 如果路径不同，则是进行改名并且剪切

  public static void main(String[] args) throws Exception{
     HelloWorld01 hello = new HelloWorld();
      hello.getVoid01();
  }
  ​
  public void getVoid01() throws EXception{
      File file = new File("F:\\文件目录\\文件目录\\文件名");
      //进行判断路径是否存在,不存在则创建
      if(!file.exists()){
          file.mkdirs();
          System.out.println("------------");
      }
      
      File file1 = new File("F:\\文件目录\\文件目录\\文件名1");
      File file2 = new File("F:\\文件目录\\文件目录\\文件名2");
     
      //file1的文件名改为了file2的文件名
      System.out.println(file1.renameTo(file2));
      
      //file2的文件名改为了file1的文件名，并剪切到file1所对于的文件路径下  
      System.out.println(file2.renameTo(file1));
  } 

• 字节流（Byte Stream）

  • 以字节为单位进行读取和写入操作

  • InputStream和OutputStream是抽象类，用于处理字节流

  • FileInputStream和FileOutputStream是常用的字节流类，用于从文件中读取和写入字节数据

  • 可以进行读取任意的文件

//读
public void getVoid02() throws Exception{
     FileInputStream fileInputStream = new FileInputStream("F:\\文件目录\\文件目录\\文件名");
    int b;
    while((b=fileInputStream.read())!=-1){
        System.out.println("b = " + b);//码表的值
    }
    //注意：使用了IO流一定要关闭
    fileInputStream.close();
}
​
//写
public void getVoid03() throws Exception{
    //true相当于使写文件追加，否则会重写
    FileOutputStream fileOutputStream = new FileOutputStream("F:\\文件目录\\文件目录\\文件名",true);
    fileOutPutStream.write("读书少不要骗我".getBytes());
    
    fileOutputStream.close();
    
    //读
    System.out.println("-----------");
    FileInputStream fileInputStream1 = new FileInputStream("F:\\文件目录\\文件目录\\文件名");
    byte[] arr = new byte[1024];
    int i;
    while((i=fileInputStream1.read(arr))!=-1){
        System.out.println(new String(arr,0,i));
    }
    fileInputStream1.close();
}

• 字符流（Character Stream）

  • 以字符为单位进行读取和写入操作

  • Reader和Writer是抽象类，用于处理字符流

  • FileReader和FileWriter是常用的字符流类，用于从文件中读取和写入字符数据

  • 只能读取字符相关的文件

  • 执行流程：先读取到字节，转换为字符

public void getVoid04() throws Exception{
    //写
    FileWriter fileWriter = new FileWriter("F:\\文件目录\\文件目录\\文件名",true);
    fileWriter.write("我是中国人");
    fileWriter.close();
    
    System.out.println("-----------");
    
    //读
    FileReader fileReader = new FileReader("F:\\文件目录\\文件目录\\文件名");
    int i;
    while((i=fileReader.read())!=-1){
        System.out.println((char)i);
    }
    fileReader.close();
}

• 缓冲流（Buffered Stream）

  • 以缓冲区作为中间存储，通过预先从底层流读取或写入一定数量的数据到缓冲区，减少了实际与底层流的交互次数，提高了读写性能

  • 文件 <-读或者写-> 缓冲区 <-读或者写-> 磁盘

  • BufferedReader和BufferedWriter是用于处理字符流的缓冲流类

  • BufferedInputStream和BufferedOutputStream是用于处理字节流的缓冲流类

public void getVoid05() throws Exception{
    //写
    //true相当于使写文件追加，否则会重写
    BufferedOutputStream fileOutputStream = new BufferedOutputStream(new FileOutputStream("F:\\文件目录\\文件目录\\文件名",true));
    fileOutPutStream.write("读书少不要骗我".getBytes());
    
    fileOutputStream.close();
    
    //读
    System.out.println("-----------");
    BufferedIntputStream fileInputStream1 = new BufferedIntputStream(new FileInputStream("F:\\文件目录\\文件目录\\文件名"));
    byte[] arr = new byte[1024];
    int i;
    while((i=fileInputStream1.read(arr))!=-1){
        System.out.println(new String(arr,0,i));
    }
    fileInputStream1.close();
}

public void getVoid06() throws Exception{
    //写
    BufferedWriter fileWriter = new BufferedWriter(new FileWriter("F:\\文件目录\\文件目录\\文件名",true));
    fileWriter.write("我是中国人");
    fileWriter.close();
    
    System.out.println("-----------");
    
    //读
    BufferedReader fileReader = new BufferedReader(new FileReader("F:\\文件目录\\文件目录\\文件名"));
    String s;
    while((s = fileReader.readLine())!=null){
        System.out.println("s = " + s);
    }
    fileReader.close();
}

public void getVoid07() throws Exception{
    HashMap<String,String> hashMap = new HashMap<>();
    BufferedReader fileReader = new BufferedReader(new FileReader("F:\\文件目录\\文件目录\\文件名"));
    String s;
    while((s=fileReader.readLine())!=null){
        System.out.println("s = " + s);
        String[] array = s.split("\\.");
        hashMap.put(array[0],array[1]);
    }
    fileReader.close();
    
    BufferedWriter fileWriter = new BufferedWriter(new FileWriter("F:\\文件目录\\文件目录\\文件名",true));
    Set<String> strings = hashMap.ketSet();
    String l;
    for(String string : strings){
        String s1 = hashMap.get(string);
        l = string + "." + s1;
        fileWriter.write(1);
        fileWriter.newLine();//换行
    }
    fileWriter.close();
}

• 转换流（Reader/Writer Stream）

  • 用于将字节流和字符流进行转换

  • InputStreamReader和OutputStreamWriter是用于将字节流转换为字符流的转换流类

    • InputStreamReader：读取字节，进行解码成字符

    • OutputStreamWriter：写出字符，进行编码为字节

  • 它们可以指定字符集，实现字符集的编码和解码

public void getVoid08(){
    
    BufferedReader fileReader = new InputStreamReader(new FileReader("F:\\文件目录\\文件目录\\文件名"));
    
    //写出字符，转换为字节
    OutputStreamWriter outputStreamWriter = new OutputStreamWriter(new BufferedOutputStream(new FileOutputStream("F:\\文件目录\\文件目录\\文件名",true)));
    
    System.out.println("-----------");
    
    //读取字节，转换为字符
    InputStreamReader inputStreamReader = new InputStreamReader(new BufferedIntputStream(new FileInputStream("F:\\文件目录\\文件目录\\文件名")));
    
    int i;
    while((i=inputStreamReader.read())!=-1){
        System.out.println("i = " + i);
        outputStreamWriter.write(i);
    }
}

public void getVoid09() throws Exception{
    //字节的
	BufferedWriter outputStreamWriter = new BufferedWriter(new OutPutStreamWriter(new BufferedOutputStream(new FileOutputStream("F:\\文件目录\\文件目录\\文件名",true))));
    
	System.out.println("-----------");
    
	BufferedReader inputStreamReader = new BufferedReader(new InputStreamReader(new BufferedIntputStream(new FileInputStream("F:\\文件目录\\文件目录\\文件名"))));
    
    int i;
    while((i=inputStreamReader.read())!=-1){
        System.out.println("i = " + i);
        outputStreamWriter.write(i);
    }
    outputStreamWriter.flush();
    outputStreamWriter.close();
    inputStreamReader.close();
}

• 数据流（Data Stream）

  • 提供了对基本数据类型和字符串的高级输入输出功能

  • 它们提供了方法来读取和写入不同类型的数据，如整数、浮点数、布尔值等

  • DataInputStream和DataOutputStream是用于处理字节流的数据流类

public void getVoid10() throws Exception{
    DataOutputStream dataOutputStream = new DataOutpitStream(new FileOutputStream("F:\\文件目录\\文件目录\\文件名"));
    
    //写
    dataOutputStream.writeUTF("姓名");
    dataOutputStream.writeInt(23);
    dataOutputStream.close();
    
    //读
    DataInputStream dataInputStream = new DataInputStream(new FileInputStream("F:\\文件目录\\文件目录\\文件名"));
    
    String s = dataInputStream.readUTF();
    int i = dataInputStream.readInt();
    System.out.println("s + \"=\"+i = " + s + "=" + i);
}

• 对象流（Object Stream）

  • 用于以对象为单位进行高级输入输出操作，可以将完整的对象序列化到流中，或从流中反序列化出完整的对象

  • 字节 ----反序列化 将对应的字节进行重新构建一个对象-----> 对象

  • 对象 ----序列化 将对象转换为对应的字节----->字节

  • ObjectInputStream和ObjectOutputStream是用于处理字节流的对象流类

  • 它们提供了方法来读取和写入对象，包括自定义对象

  • 实体对象上需要进行加上如下常量，并且实现Serializable接口：

  //进行规范序列化和反序列化的一个版本不兼容的问题
  private static final long serialVersionUID = 1L;

public void getVoid11() throws Exception{
    //写（序列化）
    ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("F:\\文件目录\\文件目录\\文件名"));
    Users users = new Users("小王",25);
    objectOutputStream.writeObject(users);
    objectOutputStream.flush();
    objectOutputStream.close();
    
    //读（反序列化）
    ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("F:\\文件目录\\文件目录\\文件名"));
    Users object = (Users)objectInputStream.readObject();
    System.out.println(object);
    objectInputStream.flush();
    objectInputStream.close();
}