03File类与IO流

1. File类

1.0 什么是字节和字符

  1. byte即字节的意思,是java中的基本数据类型(整数),用来申明字节型的变量,一个字节包含8个位,所以,byte类型的取值范围是-128~127

,字节为计算机文件大小的基本计算单位

  1. bit是Binary digit(二进制数位)的缩写,意为"位"或者"比特",是计算机运算的基础 和字节(byte)的关系是 1byte = 8bit
  3. 为什么要有字符,原因机器只知道字节,而字符确实语意上的单位,他是有编码的,一个字节可能编程成1个2个甚至3个4个字节.这根字符集编码有关系,英文字母和数字是单字节的,但汉字这些自然语言中的字符是多字节的.一个字节只能表示255个字符,不可能用于全球那么多种自然语言的处理,因此肯定就需要多字节的存储方式.如汉字按UNICODE标准所有字符都占2个字节.

1.1 File类描述目录文件和路径的对象

  1. public class FileTest1 {
  2.   /*
  3.    * File类
  4.    * 文件夹 Directory:存储文件的容器,放置文件重名而设置,文件归类,文件夹本身不存储任何数据,计算机专业术语称为:目录
  5.    * 文件 File:存储数据的,同一个目录中的文件名不能相同
  6.    * 路径 Path:一个目录或者文件在磁盘中的位置 例如: E:\java\day3 是目录的路径  E:\java\day3\day3.iml 是文件的位置
  7.    * File类 :描述目录文件和路径的对象
  8.    * 和平台无关性 */
  9.   public static void main(String[] args) {
  10.     fileMethod3();
  11.   }
  12.   // 直接传入最终的路径
  13.   public static void fileMethod() {
  14.     // 字符串的路径,变成File对象 => 把day3下所有的文件和文件夹都读取出来了
  15.     File file = new File("E:\\java\\day3");
  16.     System.out.println(file);
  17.   }
  18.   // 拼接字符串路径,会自动加上分割符
  19.   public static void fileMethod2() {
  20.     String path1 = "E:\\java";
  21.     String path2 = "day3";
  22.     File file = new File(path1, path2);
  23.     System.out.println("第二个方法");
  24.     System.out.println(file);
  25.   }
  26.   // file实例拼接字符串
  27.   public static void fileMethod3() {
  28.     File file = new File("E:\\java");
  29.     String path = "day3";
  30.     File f2 = new File(file, path);
  31.     System.out.println(f2);
  32.   }
  33. }

1.2 File类的创建方法

  1. public class FileTest2 {
  2.   /*
  3.    * File类的创建方法
  4.    * 1. Boolean createNewFile() => 创建一个文件,文件路径写在File的构造方法中
  5.    * 2. Boolean mkdirs()创建目录,目录的位置和名字写在File的构造方法中 */
  6.   public static void main(String[] args) {
  7.     createFn2();
  8.   }
  9.   // 创建文件夹
  10.   public static void createFn1() {
  11.     File file = new File("E:\\java\\day3\\1.txt"); // 文件夹是可以加"."这个符号的
  12.     boolean b = file.mkdirs(); // 创建成功的返回true,失败false
  13.     System.out.println(b + "b");
  14.   }
  15.   // 创建文件
  16.   public static void createFn2() {
  17.     File file = new File("E:\\java\\day3\\1"); // 文件是可以不加"."的,后缀名是用来解析的
  18.     boolean b = false; // 创建成功的返回true,失败false
  19.     try {
  20.       b = file.createNewFile();
  21.     } catch (IOException e) {
  22.       e.printStackTrace();
  23.     }
  24.     System.out.println(b + "b");
  25.   }
  26. }

1.3 File类的删除方法

  1. public class FileTest3 {
  2.   // File类删除文件和文件夹的操作
  3.   public static void main(String[] args) {
  4.     // 注意:删除的方法不会进入回收站,直接从磁盘中删除,有误删的风险
  5.     File file = new File("E:\\java\\day3\\1");
  6.     Boolean b = file.delete();
  7.     System.out.println(b);
  8.   }
  9. }

1.4 File类的判断方法

  1. public class FileTest {
  2.   /*
  3.    * File类判断方法
  4.    * 1. Boolean exists() 判断构造方法中的路径是否存在
  5.    * 2. Boolean isDirectory() 判断构造方法中的路径是不是文件夹
  6.    * 3. Boolean isFile() 判断构造方法中的路径是不是文件
  7.    * 4. Boolean isAbsolute() 判断构造方法中的路径是不是绝对路径*/
  8.   public static void main(String[] args) {
  9.     fileFn1();
  10.     fileFn2();
  11.     fileFn3();
  12.     fileFn4();
  13.   }
  14.   // 1. Boolean exists() 判断构造方法中的路径是否存在
  15.   public static void fileFn1() {
  16.     File file = new File("E:\\java\\day3\\day4");
  17.     boolean b = file.exists();
  18.     System.out.println("路径是否存在" + b);
  19.   }
  20.   // 2. Boolean isDirectory() 判断构造方法中的路径是不是文件夹
  21.   public static void fileFn2() {
  22.     File file = new File("E:\\java\\day3\\day3.iml");
  23.     boolean b = file.isDirectory();
  24.     System.out.println("是不是文件夹" + b);
  25.   }
  26.   // 3. Boolean isFile() 判断构造方法中的路径是不是文件
  27.   public static void fileFn3() {
  28.     File file = new File("E:\\java\\day3");
  29.     boolean b = file.isFile();
  30.     System.out.println("是不是文件" + b);
  31.   }
  32.   // Boolean isAbsolute() 判断构造方法中的路径是不是绝对路径*/
  33.   public static void fileFn4() {
  34.     File file = new File("E:\\java\\day3");
  35.     boolean b = file.isAbsolute();
  36.     System.out.println("是不是绝对路径" + b);
  37.   }
  38. }

1.5 File类的获取方法

  1. public class Filetest1 {
  2.   /*
  3.    * File类获取的方法
  4.    * 1.File getAbsoluteFile(),返回值是file类型
  5.    * 2.File getParentFile() 获取父路径,返回值是File类型
  6.    * 3.String getName() 获取名字,File构造方法中的路径名字
  7.    * 4.String getPath() 获取File构造方法中的路径,完整的路径转为String返回
  8.    * 5.long length()获取文件的字节数
  9.    * 6.File[] listFile() 返回值是File[] 数组 , 存储了多个File对象, 方法的作用是遍历当前的文件夹*/
  10.   public static void main(String[] args) {
  11.     fn2();
  12.   }
  14.   public static void fn() {
  15.     File file = new File("E:\\java\\day3");
  16.     File f1 = file.getAbsoluteFile(); // 获取绝对路径
  17.     System.out.println(f1);
  18.     File f2 = file.getParentFile(); // 获取父路径
  19.     System.out.println(f2);
  20.     String f3 = file.getName(); // 获取名字
  21.     System.out.println(f3);
  22.     String f4 = file.getPath(); // 获取路径,但是是String类型的
  23.     System.out.println(f4);
  24.     Long f5 = file.length(); // 文件字节数
  25.     System.out.println(f5);
  26.   }
  28.   public static void fn2() {
  29.     File file = new File("E:\\java\\day3");
  30.     File[] arr = file.listFiles();
  31.     System.out.println(arr);
  32.   }
  33. }

2. IO流

2.1 IO流对象的分类

  1. /*
  2.    * IO:Input Output IO作用是将数据从一个设备中流入到另一个设备
  3.    * 数据文件:从磁盘中流向内存中,从磁盘中流向移动存储设备,从一台电脑流向另一台电脑
  4.    * 一切都是字节:任何数据文件都是字节组成,字节是计算机中最小的存储单元*/
  5.   /*
  6.    * IO流对象的分类
  7.    * 1.按照操作的文件类型分类
  8.    *   文本类型文件--选择流对象字符流 文本文件:使用文本工具,记事本打开文件后可以直接阅读的
  9.    *   非文本类型文件--选择流对象字节流
  10.    * 2按照数据的流向分类
  11.    *    输入流:Java程序从其他地方读取数据
  12.    *    输出流:Java程序中的数据,写入到其他地方
  13.    * 3.IO流对象的分类归纳
  14.    *    字节输出流:OutputStream 抽象类
  15.    *    字节输入流:InputStream 抽象类
  16.    *    字符输出流: Writer 抽象类
  17.    *    字符输入流: Reader 抽象类*/

2.2 IO流 字节流 输出(写)

  1. /*
  2.    * java.io.OutputStream是所有字节输出流的超类:可以写入任何类型文件
  3.    * 写入字节的方法 write
  4.    *   void write(int b)写入单个字节
  5.    *   void write(byte[] b) 写入字节数组
  6.    *   void write(byte[] b,int off,int len) 写入数组的一部分,开始索引,写入的个数*/
  7.   /*
  8.    * FileOutputStream
  9.    * 构造方法:FileOutputStream(File file)
  10.    * 构造方法:FileOutputStream(Sting file)
  11.    *   创建字节输出流对象,绑定参数就是要写入的数据目的
  12.    * 任何一个操作系统都具备IO的能力,JVM依赖操作系统实现IO的功能,IO流对象使用完后,要释放资源*/
  13.   /*
  14.    * 字节输出流写入文件的步骤
  15.    *   1.创建字节输出流对象,构造方法中,绑定文件路径,写入目的
  16.    *   2.调用流对象的方法write写入数据
  17.    *   3.释放资源*/
  18.   public static void main(String[] args) throws IOException {
  19.     //    fn1();
  20.     //    fn2();
  21.     fn3();
  22.   }
  23.   // 写入单个字节
  24.   public static void fn1() throws IOException {
  25.     // 普通创建文件,但是不能写入
  26.     /*File file = new File("E:\\java\\day3\\1.txt");
  27.     boolean b = false;
  28.     try {
  29.       b = file.createNewFile();
  30.     } catch (IOException e) {
  31.       e.printStackTrace();
  32.     }
  33.     System.out.println(b);*/
  34.     // 使用FileOutputStream 字节输出流对象,构造方法中,绑定文件路径,写入目的
  35.     FileOutputStream output = null;
  36.     output = new FileOutputStream("E:\\java\\day3\\1.txt");
  37.     if (output != null) {
  38.       output.write(45);
  39.       output.write(49);
  40.       output.write(48);
  41.       output.write(48); // 在方法未执行完之数据会追加
  42.       output.close(); // 释放资源
  43.       System.out.println("写入完成");
  44.     } else {
  45.       System.out.println("写入出错了");
  46.     }
  47.   }
  48.   // 写入数组字节
  49.   public static void fn2() throws IOException {
  50.     FileOutputStream output = new FileOutputStream("E:\\java\\day3\\1.txt");
  51.     byte[] bytes = {97, 98, 99, 100, 101, 102};
  52.     output.write(bytes);
  53.     output.write("我是一个小学生".getBytes());
  54.     // 写入数组的一部分
  55.     output.write(bytes, 1, 2);
  56.     output.close();
  57.     System.out.println("输出成功");
  58.   }
  59.   // 追加写入和换行
  60.   public static void fn3() throws IOException {
  61.     // 追加写入,在FileOutputStream构造方法中将第二个参数设为true
  62.     // 换行就需要系统的换行符号 \r\n
  63.     FileOutputStream output = new FileOutputStream("E:\\java\\day3\\1.txt", true);
  64.     output.write("你好啊".getBytes()); // 没有从头覆盖
  65.     output.write("\r\n我不好".getBytes());
  66.     output.close();
  67.     System.out.println("写入完毕");
  68.   }
  69. }

2.3 IO流 字节流 输入(读)

  1. public class IOTestRead {
  2.   /*
  3.    * 字节输入流
  4.    * java.io.InputStream是所有字节输入流的超类:可以读取任何类型文件
  5.    * 读取字节的方法 read()
  6.    * int read()读取单个字节,读取到流的末尾返回-1
  7.    * int read(byte[] b)读取字节数组,读取到流的末尾返回 -1*/
  8.   /*
  9.    * FileInputStream
  10.    * 构造方法:FileInputStream(File file)
  11.    * 构造方法:FileInputStream(String file)
  12.    *    创建字节输入流对象,绑定参数就是要读取的数据源文件*/
  13.   public static void main(String[] args) throws IOException {
  14.     //    fn1();
  15.     fn2();
  16.   }
  17.   // 字节输入流,读取单个字节 => int read()读取单个字节
  18.   public static void fn1() throws IOException {
  19.     FileInputStream input = new FileInputStream("E:\\java\\day3\\1.txt");
  20.     int num = 0;
  21.     while ((num = input.read()) != -1) {
  22.       //      System.out.println(num); //返回的是字节码,可以使用char转换
  23.       System.out.println((char) num);
  24.     }
  25.     input.close();
  26.   }
  27.   // 字节输入流,读取字节数组 int read(byte[] b) 返回读取到的字节的个数
  28.   // String类的构造方法=>new String(字节数组,开始索引,转换个数)
  29.   public static void fn2() throws IOException {
  30.     FileInputStream input = new FileInputStream("E:\\java\\day3\\1.txt");
  31.     ArrayList list = new ArrayList();
  32.     int code = 0;
  33.     while ((code = input.read()) != -1) {
  34.       list.add(code);
  35.     }
  36.     Object[] arr = new Object[list.size()];
  37.     list.toArray(arr);
  38.     for (Object num : arr) {
  39.       System.out.println((char) ((int) num));
  40.     }
  41.     input.close();
  42.   }
  43. }

2.4 IO流 字节流 读写(复制)

  1. public class IOTestReadAndWrite {
  2.   /*
  3.    * 文件复制就是IO流对象的读写
  4.    */
  5.   public static void main(String[] args) throws IOException {
  6.     //    fn1();
  7.     fn2();
  8.   }
  9.   // 单个读取和写入
  10.   public static void fn1() throws IOException {
  11.     FileInputStream input = new FileInputStream("E:\\java\\day3\\1.txt");
  12.     FileOutputStream output = new FileOutputStream("E:\\java\\day3\\2.txt");
  13.     int code = 0;
  14.     while ((code = input.read()) != -1) { // 读取字节码
  15.       output.write(code); // 写入字节码
  16.     }
  17.     input.close();
  18.     output.close(); // 释放资源
  19.     System.out.println("读写完成");
  20.   }
  21.   // 提高效率使用数组
  22.   public static void fn2() throws IOException {
  23.     File file = new File("E:\\java\\day3\\1.txt");
  24.     long count = file.length(); // 获取文件字节数
  25.     byte[] bytes = new byte[(int) count];
  26.     FileOutputStream output = new FileOutputStream("E:\\java\\day3\\2.txt");
  27.     FileInputStream input = new FileInputStream("E:\\java\\day3\\1.txt");
  28.     int code = 0;
  29.     while ((code = input.read(bytes)) != -1) {
  30.       // 字节输出流,写入字节数组,0索引开始,写入读取到的个数
  31.       output.write(bytes, 0, code);
  32.     }
  33.     input.close();
  34.     output.close();
  35.     System.out.println("读写成功");
  36.   }
  37. }

2.5 IO流 字节流 缓冲流

  1. public class IOTestBuffered {
  2.   /*
  3.    * 字节流的缓冲流
  4.    * 使用字节流的缓冲流,提高原有流对象的读写性能
  5.    * 字节流缓冲流本质也是字节流
  6.    * BufferedOutputStream 继承OutputStream
  7.    *    方法write()写入单个字节或者字节数组
  8.    * BufferedOuputStream 构造方法 传递字节输出流
  9.    *    new BufferedOuputStream (new FileOutputStream()) 传递哪个基础流,就对哪个基础流高效操作
  10.    * BufferedInputStream 继承InputStream
  11.    *    方法read()读取单个字节,读取字节数组
  12.    * BufferedInputStream(InputStream in) 传递字节输入流
  13.    *    new BufferedInputStream(new FileInputStream())*/
  14.   public static void main(String[] args) throws IOException {
  15.     fn1();
  16.   }
  18.   public static void fn1() throws IOException {
  19.     File file =
  20.         new File(
  21.             "D:\\BaiduNetdiskDownload\\高级二期\\01JavaSE阶段的教学视频笔记【完结】\\day01\\video\\01-Java概述-从项目到代码.mp4");
  22.     int count = (int) file.length(); // 拿到字节长度
  23.     byte[] bytes = new byte[count];
  24.     FileInputStream input =
  25.         new FileInputStream(
  26.             "D:\\BaiduNetdiskDownload\\高级二期\\01JavaSE阶段的教学视频笔记【完结】\\day01\\video\\01-Java概述-从项目到代码.mp4"); // 读取流
  27.     BufferedInputStream binput = new BufferedInputStream(input); // 读取缓冲流
  28.     FileOutputStream output =
  29.         new FileOutputStream(
  30.             "D:\\BaiduNetdiskDownload\\高级二期\\01JavaSE阶段的教学视频笔记【完结】\\day01\\video\\01测试读取操作.mp4"); // 写入流
  31.     BufferedOutputStream boutput = new BufferedOutputStream(output);
  32.     int code = 0;
  33.     while ((code = binput.read(bytes)) != -1) { // 读取
  34.       boutput.write(bytes, 0, code); // 写入
  35.     }
  36.     binput.close();
  37.     boutput.close(); // 释放
  38.     System.out.println("缓冲流读写完成");
  39.   }
  40. }

2.6 IO流 字符流

  1. public class IOTestCharacter {
  2.   /*
  3.    * 字符流
  4.    * 只能操作文本文件
  5.    * Write类,是所有字符输出流的父类(写入文本文件)
  6.    *    write()写入字符
  7.    *    flush()刷新该流的缓冲(写入数据,先写到内存),只有刷新了才会写入文件中
  8.    * Read类,是所有字符输入流的父类(读取文本文件)
  9.    *    int read()读取单个字符/读取字符数组*/
  10.   /*
  11.    * OutputStreamWriter类=>继承Writer,是字符的输出流,同时又是转换流
  12.    *    构造方法:OutputStreamWrite(OutputStream out)传递任意字节输出码
  13.    *    构造方法:OutputStreamWrite(OutputStream out,String 编码表名)传递任意字节输出码
  14.    * InputStreamReader继承Reader,字符输入流,读取文本文件
  15.    *    构造方法:InputStreamReader(InputStream out)传递任意字节输入流
  16.    *    构造方法:InputStreamReader(InputStream out,String 编码表名)传递任意字节输入流*/
  17.   public static void main(String[] args) throws IOException {
  18.     //    fn1();
  19.     //    fn2();
  20.     //    fn3();
  21.     //    fn4();
  22.     //    fn5();
  23.     fn6();
  24.   }
  25.   // 字符输出流
  26.   public static void fn1() throws IOException {
  27.     // 创建字节流
  28.     FileOutputStream output = new FileOutputStream("E:\\java\\day3\\2.txt");
  29.     // 创建转换流对象,构造方法传递字节的输出流
  30.     OutputStreamWriter osw = new OutputStreamWriter(output, "gbk");
  31.     // 写入字符串
  32.     osw.write("你好啊");
  33.     // 刷新流
  34.     osw.flush();
  35.     // 资源释放
  36.     osw.close();
  37.     System.out.println("写入完成");
  38.   }
  39.   // 字符读取流
  40.   public static void fn2() throws IOException {
  41.     // 创建字节流输入对象
  42.     FileInputStream input = new FileInputStream("E:\\java\\day3\\1.txt");
  43.     // 创建字符流对象,绑定字节输入流,指定编码
  44.     InputStreamReader isr = new InputStreamReader(input);
  45.     // 查询当前文件字节数,创建一个大小相同的数组
  46.     File file = new File("E:\\java\\day3\\1.txt");
  47.     int count = (int) file.length();
  48.     char[] chars = new char[count];
  49.     // 保存read的返回值
  50.     int r = 0;
  51.     r = isr.read(chars);
  52.     // 数组转为字符串
  53.     System.out.println(new String(chars, 0, r));
  54.     isr.close();
  55.     System.out.println("读取成功");
  56.   }
  57.   // 便携类 输出
  58.   public static void fn3() throws IOException {
  59.     /*
  60.      * FileWrite继承OutputStreamWrite
  61.      *   是字符的输出流,写入文本文件
  62.      *   采取默认的编码表
  63.      *   FileWrite构造方法直接传递字符串的文件名即可*/
  64.     FileWriter fw = new FileWriter("E:\\java\\day3\\fw.txt");
  65.     // 写入字符串就完事
  66.     fw.write("你好吗");
  67.     fw.close();
  68.   }
  69.   // 便携类 读取
  70.   public static void fn4() throws IOException {
  71.     /*
  72.      * FileReader继承InputStreamRead
  73.      *   是字符的输入流,读取文本文件
  74.      *   采取默认的编码表
  75.      *   FileReader构造方法直接传递字符串的文件名即可*/
  76.     FileReader fw = new FileReader("E:\\java\\day3\\fw.txt");
  77.     File file = new File("E:\\java\\day3\\fw.txt");
  78.     char[] chars = new char[(int) file.length()];
  79.     int r = 0;
  80.     while ((r = fw.read(chars)) != -1) {
  81.       System.out.println(new String(chars, 0, r));
  82.     }
  83.     System.out.println("读取完成");
  84.     fw.close();
  85.   }
  86.   // 缓冲流 输出
  87.   public static void fn5() throws IOException {
  88.     /*BufferedWriter : 字符流的缓冲流,继承Writer,写入文本文件
  89.     特殊的方法 : newLine() 写入文本换行符,平台无关性
  90.     构造方法: BufferedWriter(Writer w)可以传递任意字符输出流*/
  91.     FileWriter fw = new FileWriter("E:\\java\\day3\\2.txt");
  92.     BufferedWriter bw = new BufferedWriter(fw);
  93.     bw.write("第一行");
  94.     bw.newLine();
  95.     bw.write("第二行");
  96.     bw.close();
  97.     System.out.println("写入成功");
  98.   }
  99.   // 缓冲流 读取
  100.   public static void fn6() throws IOException {
  101.     /*BufferedReader : 字符流的缓冲流,继承Reader,读取文本文件
  102.     特殊的方法 :String readLine() 读取文本一行,平台无关性
  103.     构造方法: BufferedReader (Reader r)可以传递任意字符输入流*/
  104.     FileReader fr = new FileReader("E:\\java\\day3\\2.txt");
  105.     File file = new File("E:\\java\\day3\\2.txt");
  106.     char[] chars = new char[(int) file.length()];
  107.     BufferedReader br = new BufferedReader(fr);
  108.     /* String str = null;
  109.     while ((str = br.readLine()) != null) { //按行来读取
  110.       System.out.println(str);
  111.     }*/
  112.     int r = 0;
  113.     while ((r = br.read(chars)) != -1) {
  114.       System.out.println(new String(chars, 0, r)); // 全部读取
  115.     }
  116.     br.close();
  117.   }
  118. }

2.7 IO流 打印流

  1. public class IOTestPrint {
  2.   public static void main(String[] args) throws IOException {
  3.     /*
  4.      * 打印流
  5.      *   PrintStream:字节输出流
  6.      *   PrintWriter:字符输出流
  7.      * 打印流特性:
  8.      * 打印流负责输出打印,不关心数据源
  9.      * 方便的打印各种形式数据
  10.      * 打印流永远不会抛出IOException异常
  11.      * 具有自动刷新*/
  12.     fn1();
  13.   }
  15.   public static void fn1() throws IOException {
  16.     /*
  17.      * 打印流输出,在打印流的构造方法中,传递流(字节,字符)
  18.      * 自动刷新:构造方法中第一个参数必须是IO流对象,不能是字符串,第二个方法为true 意思是自动刷新
  19.      * 调用方法:printf,println,format 三个其中一个,启用自动刷新*/
  20.     FileWriter fw = new FileWriter("E:\\java\\day3\\1.txt");
  21.     PrintWriter pw = new PrintWriter(fw, true);
  22.     pw.println(1.5);
  23.     pw.close();
  24.   }
  25. }