第31天学习打卡（File类。字符流读写文件）

File类

概念

文件，文件夹，一个file对象代表磁盘上的某个文件或者文件夹

构造方法

 File(String pathname)
 File(String parent,String child)
 File(File parent, String child)

成员方法

 creatNewFile():创建文件
 mkdir()和mkdirs():创建目录（即创建文件夹）
 isDirectory():判断File对象是否为目录
 isFile():判断File对象是否为文件
 exicts()：判断File对象是否存在

 package cn.itcast.demo20;
 /*
 File类：
     概述：
        文件，文件夹，一个File对象代表磁盘上的某个文件夹。也就是用来操作文件（夹）路径的。
     构造方法：
         File(String pathname) 根据给定的字符串路径创建其对应的File对象
         File(String parent, String child)根据给定的字符串形式的父目录和子文件（夹）名创建File对象
         File(File parent, String child)根据给定的父母目录对象和子文件（夹）名创建File对象
     成员方法：
         创建功能：如果不存在就创建，返回true,否则就不存在，返回false
              createNewFile():创建文件夹
              mkdir(): 创建单级目录
              mkdirs():创建目录
         判断功能：
              isDirectory():判断File对象是否为目录
              isFile():判断File对象是否为文件
              exists():判断File对象是否存在
 ​
  */
 ​
 import java.io.File;
 import java.io.IOException;
 ​
 public class Test {
     public static void main(String[] args) throws IOException {
         //需求: 将 D:\abc\1.txt 封装成File对象.
         //方式一: 根据字符串形式的路径获取File对象.
         //File file1 = new File("D:\\abc\\1.txt");
         File file1 = new File("D:/abc/1.txt");
         System.out.println("file1: " + file1);
 ​
         //方式二: 根据字符串形式的父目录以及子目录创建File对象.
         File file2 = new File("D:/abc/", "1.txt");
         System.out.println("file2: " + file2);
 ​
         //方式三: 根据父目录对象, 以及字符串形式的子目录来获取File对象.
         File file3 = new File("D:/abc/");
         File file4 = new File(file3, "1.txt");
         System.out.println("file4: " + file4);
         System.out.println("-----------------------------");
         System.out.println("创建功能");
         //需求: 在f:盘下创建 b.txt文件(我的在D盘里面创建不了b.txt 文件，会报错， 所有要换一个文件的路径改为f盘或者其他盘。不区分盘的大小写)
         File file5 = new File("f:/b.txt");
         boolean flag1 = file5.createNewFile();
         System.out.println("flag1: " + flag1);
 ​
         //需求: 在D:盘下创建 a文件夹
        File file6 = new File("D:/a");
        boolean flag2 = file6.mkdir();//make directory:创建单级目录
         System.out.println("flag2:" + flag2);
 ​
         //需求：在D盘创建a/b/c文件夹：即文件夹a下包含文件夹b，文件夹b下包含文件夹c.即创建多级路径
         File file7 = new File("D:/a/b/c");
         boolean flag3 = file7.mkdirs();//mkdirs可以创建多级目录也可以创建单级目录
         System.out.println("flag3:" + flag3);
 ​
         System.out.println("==============");
         System.out.println("测试判断功能");
         File file8 = new File("D:/a/b");
        /* boolean flag4 = file8.isDirectory();
         System.out.println("测试file8是否是文件夹:" + flag4);*/
         //上面注释的是标准的写法
         System.out.println("测试file8是否是文件夹:" + file8.isDirectory());
         System.out.println("测试file8是否是文件:" +file8.isFile());
         System.out.println("测试file8是否是存在:" + file8.exists());
 ​
     }
 }
 ​

 

成员方法

 getAbsolutePath():获取绝对路径
 绝对路径：以盘符开头的路径
 例如：D:/1.txt
 getPath():获取文件的相对路径
 相对路径：一般是相对于当前项目路径来讲的。
 例如：1.txt
 getName():获取文件名
 list():获取指定目录下所有文件（夹）名称数组
 listFiles():获取指定目录下所有文件（夹）File数组

 

 package cn.itcast.demo21;
 /*
 File类的获取功能:
         getAbsolutePath():获取绝对路径
         getPath():获取文件的相对路径
         getName():获取指定目录下所有文件（夹）名称数组
         list():获取指定目录下所有文件(夹)File数组
         listFile():获取指定目录下所有文件（夹）File数组
 Java中路径的划分：
         绝对路径：
              以盘符开头的路径，固定的，写“死”的路径
         相对路径：
              意思是相对某个路径而言，Java中的相对路径是指：相对于当前项目的路径来讲的
  */
 ​
 import java.io.File;
 ​
 public class Test {
     public static void main(String[] args) {
 ​
         File file1 = new File("lib/1.txt");
 ​
         //获取file1的绝对路径
        String path1 = file1.getAbsolutePath();
         System.out.println("绝对路径: " + path1);
 ​
 ​
         //获取file1的相对路径
         String path2 = file1.getPath();
         System.out.println("相对路径:" + path2);
 ​
         //获取文件名
         String fileName = file1.getName();
         System.out.println("文件名:" + fileName);
 ​
         //获取lib文件夹下所有的文件（夹）的：名称数组String[]
         File file2 = new File("lib");
         String[] names = file2.list();
         for (String name : names){
             System.out.println(name);
         }
         System.out.println("==================");
 ​
         //获取lib文件夹下所有的文件（夹）的：File对象数组File[]
         File[] files= file2.listFiles();
         for(File file:files){
             System.out.println(file);
 ​
         }
 ​
     }
 }
 ​

输出结果：

绝对路径: C:\Users\HP\Desktop\besttj\lib\1.txt 相对路径:lib\1.txt 文件名:1.txt 1.txt a

abc

lib\1.txt lib\a lib\abc

Process finished with exit code 0

 

字符流读写文件

字符流读数据-按单个字符读取

创建字符流读文件对象：

 Reader reader = new FileReader("readme.txt");

调用方法读取数据：

 int data = reader.read();

读取一个字符，返回该字符代表的整数，若到达流的末尾，返回-1

异常处理：

 throws IOException

关闭资源：

 reader.close();

 

 package cn.itcast.demo22;
 /*
 字符流读数据：
       Reader 类中的方法：
               int read(): 读一个字符，返回该字符对应的ASCII码值，读不到返回-1
       FileReader类的构造方法：
                public FileReader(String pathname):根据传入的字符串形式的路径，获取字符输入流对象
 ​
  */
 ​
 import java.io.FileNotFoundException;
 import java.io.FileReader;
 import java.io.IOException;
 import java.io.Reader;
 ​
 public class ReaderDemo01 {
     public static void main(String[] args) throws FileNotFoundException, IOException {
         //需求：通过字符流读取数据
         //1.创建字符输入流对象
         Reader reader = new FileReader("lib/1.txt");
 ​
 ​
         //2.读取数据
         int ch1 = reader.read();
         System.out.println(ch1);//输出了lib/1.txt文件中abc 中a的ascii值97
 ​
         int ch2 = reader.read();
         System.out.println(ch2);//输出了lib/1.txt文件中abc 中b的ascii值98
 ​
         int ch3 = reader.read();
         System.out.println(ch3);//输出了lib/1.txt文件中abc 中c的ascii值99
 ​
         int ch4 = reader.read();
         System.out.println(ch4);//输出-1,因为已经到字符串末尾了
 ​
 ​
         //3.释放资源
         reader.close();
     }
 }
 ​

 

 package cn.itcast.demo22;
 /*
 字符流读数据：
       Reader 类中的方法：
               int read(): 读一个字符，返回该字符对应的ASCII码值，读不到返回-1
       FileReader类的构造方法：
                public FileReader(String pathname):根据传入的字符串形式的路径，获取字符输入流对象
 ​
  */
 ​
 import java.io.FileNotFoundException;
 import java.io.FileReader;
 import java.io.IOException;
 import java.io.Reader;
 ​
 public class ReaderDemo01 {
     public static void main(String[] args) throws FileNotFoundException, IOException {
         //需求：通过字符流读取数据
         //1.创建字符输入流对象
         Reader reader = new FileReader("lib/1.txt");
 ​
 ​
         //2.读取数据
         /*int ch1 = reader.read();
         System.out.println(ch1);//输出了lib/1.txt文件中abc 中a的ascii值97
 ​
         int ch2 = reader.read();
         System.out.println(ch2);//输出了lib/1.txt文件中abc 中b的ascii值98
 ​
         int ch3 = reader.read();
         System.out.println(ch3);//输出了lib/1.txt文件中abc 中c的ascii值99
 ​
         int ch4 = reader.read();
         System.out.println(ch4);//输出-1,因为已经到字符串末尾了*/
         /*
         优化上述的读法，用循环改进
         又因为不知道循环的次数，所有用while循环
          */
         //定义变量，用来接收读取到的字符
         int ch;
         /*
         (ch=reader.read())!= -1 这句代码做了三件事
                1.执行reader.read() 去文件中读取一个字符
                2.执行ch=reader.read()将读取到的字符赋值变量
                3.（ch=reader.read()）！= -1，用读取到的字符（内容）和-1进行比较
          */
         while((ch=reader.read())!= -1){
             //ch = reader.read();
             System.out.println(ch);
 ​
         }
 ​
 ​
         //3.释放资源
         reader.close();
     }
 }
 ​

 

 

创建字符流读数据-按字符数组读取

创建字符流读文件对象：

 Reader reader = new FileReader("readme.txt");

调用方法读取数据：

 char[] chs = new char[2048];
 int len = r.read(chs);

读取字符到数组中，返回读取的字符数，若到达流的末尾，返回-1

异常处理

 throws IOException

关闭资源：

 reader.close();

 

 package cn.itcast.demo22;
 /*
   字符流读数据：
         Reader类中的方法：
         int read(char[] chs): 一次读一个字符数组，将读取到的内容存入到数组中
                              并返回读取到的有效字符流，读不到返回-1
         FileReader类的构造方法:
               Public FileReader(String pathname):根据传入的字符串形式的路径，获取字符输入流对象
 ​
 ​
 ​
  */
 ​
 import java.io.FileNotFoundException;
 import java.io.FileReader;
 import java.io.IOException;
 import java.io.Reader;
 ​
 public class ReaderDemo02 {
     public static void main(String[] args) throws IOException {
         //需求：通过字符流读取数据，一次读取一个字符数据
         //1.创建字符输入流对象  2.txt里面只有abcdefg这个字符串
         Reader reader = new FileReader("lib/2.txt");
 ​
         //2.读取数据
         char[] chs = new char[3];//字符数组初始长度为3
         int len1 = reader.read(chs);
         System.out.println(chs);//a,b,c
         System.out.println(len1);//返回值为3
 ​
 ​
         int len2 = reader.read(chs);
         System.out.println(chs);//d,e,f
         System.out.println(len2);//返回值为3
 ​
 ​
         int len3 = reader.read(chs);
         System.out.println(chs);//g,e,f 最后只剩g所以返回值为1，但是要返回三个，那么前面的def只有d被g覆盖了，其余的不变，因为没有字母进行e和f的覆盖
         System.out.println(len3);//返回值为1
 ​
         int len4 = reader.read(chs);
         System.out.println(chs);//g,e,f
         System.out.println(len4);//返回值为-1
 ​
         //3.释放资源
         reader.close();
     }
 }
 ​

 

 

 package cn.itcast.demo22;
 /*
   字符流读数据：
         Reader类中的方法：
         int read(char[] chs): 一次读一个字符数组，将读取到的内容存入到数组中
                              并返回读取到的有效字符流，读不到返回-1
         FileReader类的构造方法:
               Public FileReader(String pathname):根据传入的字符串形式的路径，获取字符输入流对象
 ​
 ​
 ​
  */
 ​
 import java.io.FileNotFoundException;
 import java.io.FileReader;
 import java.io.IOException;
 import java.io.Reader;
 ​
 public class ReaderDemo02 {
     public static void main(String[] args) throws IOException {
         //需求：通过字符流读取数据，一次读取一个字符数据
         //1.创建字符输入流对象
         Reader reader = new FileReader("lib/2.txt");
 ​
         //2.读取数据
         /*char[] chs = new char[3];//字符数组初始长度为3
         int len1 = reader.read(chs);
         System.out.println(chs);//a,b,c
         System.out.println(len1);//返回值为3
 ​
 ​
         int len2 = reader.read(chs);
         System.out.println(chs);//d,e,f
         System.out.println(len2);//返回值为3
 ​
 ​
         int len3 = reader.read(chs);
         System.out.println(chs);//g,e,f
         System.out.println(len3);//返回值为1
 ​
         int len4 = reader.read(chs);
         System.out.println(chs);//g,e,f
         System.out.println(len4);//返回值为-1*/
         /*
         优化上述的代码，while循环
          */
         //定义字符数组
         char[] chs = new  char[3];
         //定义一个变量，记录读取到的有效字符数
         int len;
         while((len = reader.read(chs))!=-1){
             //将读取到的内容，转换成字符串，然后打印
             /*
              chs :表示要操作的数组
              0:表示起始索引
              len:表示要操作的字符个数
              */
             String s = new String(chs,0,len);//传字符数组、起始索引、长度
             System.out.println(s);
 ​
         }
 ​
 ​
         //3.释放资源
         reader.close();
     }
 }
 ​

 

 

字符流写数据-按单个字符写入

创建字符流写文件对象：

 Writer writer = new FileWriter("dest.txt");

调用方法写入数据

 int x = '中';
 writer.write(x);
 写一个字符

异常处理

 throws IOException

 

关闭资源

 writer.close();

 package cn.itcast.demo23;
 /*
 字符流写数据：
      Writer类中的方法：
              void write(int ch):  一次写一个字符
              void write(char[] chs,int index,int len):一次写一个指定的字符数组
              void write(String str):一次写一个字符串
 ​
      FileWriter 类的构造方法:
               public FileWriter(String pathname):根据传入的字符串形式的路径，获取字符输出流对象
  */
 ​
 import java.io.FileWriter;
 import java.io.IOException;
 import java.io.Writer;
 ​
 public class WriterDemo01 {
     public static void main(String[] args) throws IOException {
         //需求：通过字符流写数据
         //1.创建字符输出流对象
         Writer writer = new FileWriter("lib/1.txt");
         //2.写数据
         //一次写一个字符
         writer.write('好');//把原来1.txt文件里面的abc给覆盖了  abc被覆盖为好
 ​
 ​
         //3.释放资源
         writer.close();
     }
 }
 ​

 

 

字符流写数据-按字符数组写入

创建字符流写文件对象：

 Writer writer = new FileWriter("dest.txt");

调用方法写数据：

 char[] chs = {'橙','心','橙','意'};
 writer.write(chs);
 写一个字符数组

异常处理：

 throws IOException

关闭资源：

 writer.close();

 package cn.itcast.demo23;
 /*
 字符流写数据：
      Writer类中的方法：
              void write(int ch):  一次写一个字符
              void write(char[] chs,int index,int len):一次写一个指定的字符数组
              void write(String str):一次写一个字符串
 ​
      FileWriter 类的构造方法:
               public FileWriter(String pathname):根据传入的字符串形式的路径，获取字符输出流对象
  */
 ​
 import java.io.FileWriter;
 import java.io.IOException;
 import java.io.Writer;
 ​
 public class WriterDemo01 {
     public static void main(String[] args) throws IOException {
         //需求：通过字符流写数据
         //1.创建字符输出流对象
         Writer writer = new FileWriter("lib/1.txt");
         //2.写数据
         //一次写一个字符
        // writer.write('好');//把原来1.txt文件里面的abc给覆盖了  abc被覆盖为好
 ​
         //一次写一个指定的字符数组
         char[] chs = {'黑','马','程','序','员'};
         writer.write(chs,2,3);
 ​
 ​
         //3.释放资源
         writer.close();
     }
 }
 ​

 

字符流写数据-按字符串写入

创建字符流写文件对象：

 Writer writer = new FileWriter("dest.txt");

调用方法写入数据：

 writer.write("小黑爱学习");
 写入一个字符串

异常处理：

 throws IOException

 

关闭资源：

 writer.close();

 package cn.itcast.demo23;
 /*
 字符流写数据：
      Writer类中的方法：
              void write(int ch):  一次写一个字符
              void write(char[] chs,int index,int len):一次写一个指定的字符数组
              void write(String str):一次写一个字符串
 ​
      FileWriter 类的构造方法:
               public FileWriter(String pathname):根据传入的字符串形式的路径，获取字符输出流对象
  */
 ​
 import java.io.FileWriter;
 import java.io.IOException;
 import java.io.Writer;
 ​
 public class WriterDemo01 {
     public static void main(String[] args) throws IOException {
         //需求：通过字符流写数据
         //1.创建字符输出流对象
         Writer writer = new FileWriter("lib/1.txt");
         //2.写数据
         //一次写一个字符
        // writer.write('好');//把原来1.txt文件里面的abc给覆盖了  abc被覆盖为好
 ​
         //一次写一个指定的字符数组
        /* char[] chs = {'黑','马','程','序','员'};
         writer.write(chs,2,3);*/
 ​
         //一次写一个字符串
         writer.write("好好学习，知识改变命运");
 ​
 ​
 ​
         //3.释放资源
         writer.close();
     }
 }
 ​

 

 

字符流读写数据

字符流拷贝文件-按单个字符读写

创建字符流读文件对象：

 Reader reader = new FileReader("readme.txt");

创建字符流写文件对象

 Writer writer = new FileWriter("dest.txt");

调用方法读取数据

 int data = reader.read();

调用方法写入数据

 writer.write(data);

异常处理

 throws IOException

关闭资源

 reader.close();
 writer.close();

 

 package cn.itcast.demo24;
 ​
 import java.io.FileNotFoundException;
 import java.io.FileReader;
 import java.io.FileWriter;
 import java.io.IOException;
 ​
 public class CopyFile1 {
     public static void main(String[] args) throws IOException {
         //需求：通过字符流拷贝文件，一次读写一个字符
         //例如。将1.txt文件中的内容复制到2.txt文件中
         /*
         IO流拷贝文件核心六步：
             1.创建字符输入流对象，关联数据源文件
             2.创建字符输出流对象，关联目的地文件
             3.定义变量，记录读取的内容
             4.循环读取，只要条件满足就一直读，并将读取到的内容赋值给变量
             5.将读取到的数据写入到目的地文件中
             6.释放资源
          */
         //1.创建字符输入流对象，关联数据源文件
         //Reader reader = new FileReader("lib/1.txt");下面是这个代码的优化写法
 ​
         FileReader fr = new FileReader("lib/1.txt");
         //2.创建字符输出流对象，关联目的地文件
         FileWriter fw = new FileWriter("lib/3.txt");//细节：如果目的地文件不存在，程序会自动创建
         //3.定义变量，记录读取的内容
         int len;
         //4.循环读取，只要条件满足就一直读，并将读取到的内容赋值给变量
         while ((len = fr.read())!=-1){
             //5.将读取到的数据写入到目的地文件中
             fw.write(len);
 ​
         }
 ​
         //6.释放资源
         fr.close();
         fw.close();
     }
 }
 ​

 

 

字符流拷贝文件-按字符数组读写

创建字符流读文件对象：

 Reader reader = new FileReader("reader.txt");

创建字符流写文件对象：

 Writer writer = new FileWriter("dest.txt");

 

调用方法读取数据：

 char[] chs = new char[2048];//字符数组的长度最好定义为1024的整数倍， 计算机底层的换算单位是1024的整数倍
 int len = reader.read(chs);

调用方法写数据：

 writer.write(chs,0,len);

异常处理：

 throws IOException

关闭资源

 reader.close();
 writer.close();

 

 package cn.itcast.demo24;
 ​
 import java.io.FileNotFoundException;
 import java.io.FileReader;
 import java.io.FileWriter;
 import java.io.IOException;
 ​
 public class CopyFile2 {
     public static void main(String[] args) throws IOException {
         //需求：通过字符流拷贝文件，一次读写一个字符数组
         //例如：将1.txt文件中的内容复制到2.txt文件中
         /*
         IO流核心六步：
                   1.创建字符流输入流对象，关联数据源文件
                   2.创建字符输出流对象，关联目的地文件
                   3.创建变量，用来记录读取到的有效字符数
                   4.通过循环进行读取，只要条件满足就一直读，并将读取到的有效数赋值给变量
                   5.将读取到的数据写入到目的地文件中
                   6.释放资源
 ​
          */
         //1.创建字符流输入流对象，关联数据源文件
         FileReader fr = new FileReader("lib/1.txt");
         //2.创建字符输出流对象，关联目的地文件
         FileWriter fw = new FileWriter("lib/2.txt");
         //3.创建变量，用来记录读取到的有效字符数
         char[] chs = new char[1024];
         //用来记录读取到的有效字符数
         int len;
         //4.通过循环进行读取，只要条件满足就一直读，并将读取到的有效数赋值给变量
         while ((len = fr.read(chs))!= -1){
             //5.将读取到的数据写入到目的地文件中
             fw.write(chs,0,len);
 ​
         }
 ​
         //6.释放资源
         fr.close();
         fw.close();
     }
 }
 ​