基本概念

操作系统中，信息可以持久化的存储在硬盘上，存储在硬盘上的数据就是文件
文件夹是用于将不同的文件进行分类的单位
在JDK中提供了java.io.File类对文件进行相关的操作

文件的基本操作

创建一个文件对象（并不代表在硬盘上就创建一个文件，只是将这个文件的基本信息存储在内存中而已）

      //绝对路径
      File file1 = new File("d:/temp/a.txt");
      File file2 = new File("d:\\temp\\a.txt");
      //相对路径,相对是当前的工程目录src
      File file3 = new File("a.txt");

需要通过相关的代码才可以真正的创建文件

    //判断文件是否存在
      if(file3.exists()){
          System.out.println("file3存在");
      }else{
          System.out.println("file3并不存在，创建一个新的");
          //在硬盘上创建一个文件
          file3.createNewFile();
      }

文件的相关api操作 :::info createNewFile()//创建一个新文件
mkdir()//创建一个新目录
delete()//删除文件或空目录
exists()//判断File对象所对象所代表的对象是否存在
getAbsolutePath()//获取文件的绝对路径
getName()//取得名字
getParent()//获取文件/目录所在的目录
isDirectory()//是否是目录
isFile()//是否是文件
length()//获得文件的长度
listFiles()//列出目录中的所有内容
renameTo()//修改文件名为 :::

文件的增删改查操作

查询文件夹下所有的文件

  public static void showAllFile(File folder){
      //判断是否是文件夹
      if(folder.isDirectory()){
          File[] files =  folder.listFiles();//获取当前文件夹下所有的文件
          for (File file :files) {
              System.out.println(file.getAbsoluteFile());
          }
      }else{
          System.out.println("当前的文件不是文件夹");
      }
  }

创建文件夹

  public static void createFolder(String folderPath){
      File file = new File(folderPath);
      if(!file.exists()){
          file.mkdir();
          System.out.println("创建文件夹成功");
      }
  }

修改名称
file.renameTo(dist);

删除文件夹

  //要支持删除文件夹
  public static void deleteFile(File file){
      if(file.isDirectory()){
          //是文件夹
          File[] files = file.listFiles();
          for (File f :files) {
              deleteFile(f);//删除当前目录下所有的文件
          }
      }
      file.delete();//删除当前文件
      System.out.println(file.getAbsoluteFile()+"被删除了");
  }

流操作

基本概述

流的操作，就是实现了两个媒介之间的信息通信，总的来说主要是内存和其他存储设备之间的数据传递
根据方向可以分为两类
- 输入流（InputStream）：参照物体是内存，指的是从其他媒介将数据输入到内存中。
- 输出流（OutputStream）：参照物体是也是内存，指的是从内存中向其他的媒介输出数据
按照单位进行分类
- 字节流：就是二进制的文件，存储的数据是byte，例如音频，视频，等等一切文件
- 字符流：就是以char字符的文件，主要存储的是字符串，方便字符串的操作，不可以传递音频，视频只能传递文本
  字节流的操作
文件夹流是对一般的流的子类实现，主要是对文件进行操作

文件的读取（输入流的使用）

基本的读取操作

File file = new File("a.txt");
   //通过文件创建一个输入
   InputStream is = new FileInputStream(file);
   //将文件中的内容读取出来
   int size = is.available();
   byte[] buffer = new byte[size];
   is.read(buffer);//读取数据
   is.close();//关闭流
   System.out.println("文件内容的大小:"+size);
   System.out.println("文件中的内容:"+new String(buffer));

文件的写入操作

基本操作

  File file = new File("a.txt");
   //打开一个输出流，第二参数是append是否是新增
   OutputStream os = new FileOutputStream(file,true);
   os.write("这个是新添加的内容".getBytes(StandardCharsets.UTF_8));
   os.close();;

实现文件的复制

  public static void copy(File srcFile, File distFile){
      try {
          //1,打开读取流
          InputStream in = new FileInputStream(srcFile);
          //2,打开输出流
          OutputStream os = new FileOutputStream(distFile);
          //将数据出来放在内存的缓存中
          byte[] buffer = new byte[in.available()];
          in.read(buffer);
          //将buffer中的数据输出到dist文件中
          os.write(buffer);
          //关闭流
          in.close();
          os.close();
          System.out.println("复制完毕");
      } catch (FileNotFoundException e) {
          e.printStackTrace();
      } catch (IOException e) {
          e.printStackTrace();
      }
  }

字节缓冲流

为什么要使用缓存流？

就是为了减少io的次数

不使用available读取数据(会带上000多余的数据)

File file = new File("a.txt");
   InputStream in = new FileInputStream(file);
   byte[] buffer = new byte[1024];
   StringBuilder sb = new StringBuilder();
   //获取每次堆区数据的长度
   while(in.read(buffer)!=-1){
       //每次读取完毕，都将buffer中的数据放入到StringBuffer
       sb.append(new String(buffer));
   }
   //读取数据完毕
   in.close();
   System.out.println(sb.toString());

解决多余的000的问题

   File file = new File("a.txt");
   InputStream in = new FileInputStream(file);
   byte[] buffer = new byte[1024];
   StringBuilder sb = new StringBuilder();
   //获取每次堆区数据的长度
   int len;
   while( (len=in.read(buffer))!=-1){
       //每次读取完毕，都将buffer中的数据放入到StringBuffer
       sb.append(new String(buffer,0,len));
   }
   //读取数据完毕
   in.close();
   System.out.println(sb.toString());

缓存读取流

      File file = new File("a.txt");
      InputStream in = new FileInputStream(file);
      //使用缓存流，减少io的次数
      BufferedInputStream bis = new BufferedInputStream(in);
      byte[] buffer = new byte[1024];
      StringBuilder sb = new StringBuilder();
      //获取每次堆区数据的长度
      int len;
      while( (len=bis.read(buffer))!=-1){
          //每次读取完毕，都将buffer中的数据放入到StringBuffer
          sb.append(new String(buffer,0,len));
      }
      //读取数据完毕
      bis.close();
      in.close();
      //输出结果
      System.out.println(sb.toString());

缓存输出流

File file = new File("e:/2.mp4");
      File distFile = new File("b.mp4");
      InputStream in = new FileInputStream(file);
      //使用缓存流，减少io的次数
      BufferedInputStream bis = new BufferedInputStream(in);
      //创建输出流
      OutputStream os = new FileOutputStream(distFile);
      BufferedOutputStream bos = new BufferedOutputStream(os);
      byte[] buffer = new byte[1024];
      //获取每次堆区数据的长度
      int len;
      while( (len=bis.read(buffer))!=-1){
          bos.write(buffer,0,len);//输出到缓存中
      }
      bos.flush();//确保缓存流中的数据输出到文件中
      bos.close();
      os.close();
      //读取数据完毕
      bis.close();
      in.close();
      System.out.println("复制完毕");

字符流

是为了简化对字符串的操作,字符流只能对字符串进行操作，不可以对文件进行操作
- Reader：读取字符到内存中
- Writer：从内存中输出字符

字符读取流的使用

基本使用

File file = new File("a.txt");
   Reader reader = new FileReader(file);
   //创建缓存流
   BufferedReader br= new BufferedReader(reader);
   StringBuilder sb = new StringBuilder();
   String line;
   while( (line=br.readLine())!=null){
       sb.append(line +"\n");
   }
   System.out.println(sb.toString());

缓存流的使用（BufferedReader）

File file = new File("a.txt");
   Reader reader = new FileReader(file);
   //创建缓存流
   char[] ch = new char[1024];
   StringBuilder sb = new StringBuilder();
   int len;
   while((len =reader.read(ch))>0){
     sb.append(new String(ch,0,len));
   }
   System.out.println(sb.toString());

字符在输出的时候，可以使用打印流（PrintWriter）

      File file = new File("b.txt");
      PrintWriter printWriter = new PrintWriter(file);
      printWriter.println("第一行数据");
      printWriter.print("1，小明；");
      printWriter.print("2，小黑;");
      printWriter.close();

文件流

可以直接将对象输出到文件中

创建一个对象，必须要实现序列化

public class UserEntity implements Serializable {
String name;
String password;
}

实现对象的输出

  UserEntity userEntity = new UserEntity("小明","123");
   File file = new File("d:/user.dat");
   //文件输出流
   OutputStream os = new FileOutputStream(file);
   //对象输出流
   ObjectOutputStream oos = new ObjectOutputStream(os);
   //输出对象
   oos.writeObject(userEntity);
   oos.flush();//清除缓存流
   //关闭流
   oos.close();
   os.close();
   System.out.println("对象保存到文件中");

也可以从文件中读取对象

      File file = new File("d:/user.dat");
      //根据文件创建输入流
      InputStream is = new FileInputStream(file);
      //创建对象输入流
      ObjectInputStream ois = new ObjectInputStream(is);
      //读取对象
      UserEntity userEntity = (UserEntity) ois.readObject();
 System.out.println(userEntity.getName()+":"+userEntity.getPassword());

什么是序列化？
- 对象在内存中存储的数据不一定是连续，这样在传递的数据（脱离内存）的时候并不方便
- 需要将内存的数据进行压缩排序，一次性发送
- 有序列化就会有反序列化
  - 由于序列化的对象只存储数据，可能会在反序列化的时候出现混淆的问题
  - 这个时候可以使用serialVersionUID 为每个不同的类进行标识

public static final long serialVersionUID = 3121231L;

可以通过idea设置自动生成序列化的UID
Properties

主要用于java的配置文件的设置
可以在java工程创建创建后缀名称为properties的文件
- 在文件中以key=value的形式存储内容

name=小王

在代码中通过Properties对象读取数据

   //创建一个Properties
   Properties ps = new Properties();
   //加载properties文件
   //从src目录下获取
   InputStream in = TestProperties.class.getClassLoader().getResourceAsStream("com/java2022/io/ps/my.properties");
   //可以从当前类所在的包下打开一个文件的io流
   //InputStream in = TestProperties.class.getResourceAsStream("my.properties");
   /*
   File file = new File("my.properties");
   InputStream in = new FileInputStream(file);*/
   ps.load(in);
   //加载完毕之后直接可以key获取值
   String name = ps.getProperty("name");
   System.out.println("名称:"+name);

Java 进阶知识

IO流基础操作

基本概念

文件的基本操作

文件的增删改查操作

流操作

基本概述

字节流的操作

字节缓冲流

字符流

文件流

Properties