File类

File构造方法：

  • File(pathname );
  • File(parent child);
  • File file = new File(pathname);
  • File file = new File(file);

File文件创建方法

  • public boolean createNewFile():当具有该名称的文件不存在时，创建一个由该抽象路径命名的新文件
  • public boolean mkdir()：创建由此抽象路径名命名的目录
  • public boolean midirs()：帮你创建父目录
  1.         //三种构造方法
  2.         File f1 = new File("Controller1.txt");
  4.         File f2 = new File("F:\\testFile","Controller2.txt");
  6.         File f3 = new File("F:\\testFile");
  7.         File f4 = new File(f3,"Controller3.txt");

定位一个目录获取这个目录下所有的子文件

  1. File f1 = new File("F:/testFile");
  2. String[] names = f1.list();
  3. for(String name:names){
  4.     System.out.println(name);
  5. }
  1. 字符串常见的字符底层组成是什么样
    • 英文和数字等在任何国家的字符集中都占1个字节
    • GBK字符中一个中文字符占2个字节
    • UTF-8编码中一个中文一般占3个字节
  2. 编码前的字符集和编码后的字符集有什么要求
    • 必须一致，否则出现中文字符乱码
    • 英文和数字在任何国家的编码中都不会乱码因为他们只有一个字节

字节

97代表的是一个字节

中文UTF-8中 “我” 字三个字节为-26,-120-,111这才叫三个字节

  1. //编码
  2. String str = "abc我爱你中国";
  3. //编码 返回的就是byte[]数组
  4. byte[] bytes = str.getBytes();
  6. //解码
  7. String sr = new String(bytes);
  8. System.out.println(sr);

总结：

字节流在输出控制台的时候会乱码但是写到文件中并不会乱码

文件字节输入流，每次读取一个字节数组的api是哪个？

  • read(byte[] buffer);

解决乱码问题

  1. package com.hhm.b_stream_byte;
  3. import java.io.File;
  4. import java.io.FileInputStream;
  5. import java.io.InputStream;
  7. /*
  8.  *   使用文件字节输入流一次读完文件的全部字节 可以解决乱码问题
  9.  * */
  10. public class FileInputStreamDemo03 {
  11.     public static void main(String[] args) throws Exception {
  12.         //1、创建一个文件字节输入流管道
  13.         File file = new File("data.txt");
  14.         InputStream in = new FileInputStream(file);
  16.         //一次读完一个文件的 一次获取一个文件的长度
  17.         byte[] bytes = new byte[(int) file.length()];
  18.         int len = in.read(bytes);
  21.         System.out.println("这一次直接获取了多少个字节：="+len);
  22.         System.out.println(new String(bytes));
  25.     }
  26. }
  27. 第二种API
  28.     readAllBytes();

OutputStream：

  • 如果想写中文进去的话必须要把中文编码在写入否则就是乱码使用
    • byte[] b = “我爱中国”.getByte();
      • os.write(b);

字节流可以任何文件的拷贝，唯独不适合做中文的输出

finally

  1. 无论代码出现什么异常都会执行这里
  2. 除了虚拟机挂掉 无论什么情况包括return 都会执行finally代码块
  3. 关闭之前必须做非空校验
  4. 哪怕上面有return语句执行，也必须执行finally 如果finally加了return 这个程序永远返回的都是finally的数据
  1. //代码
  2.   package com.hhm.b_stream_byte;
  4. import java.io.*;
  6. public class FileCopyFinally {
  9.     public static void main(String[] args) {
  10.         InputStream in = null;
  11.         OutputStream os = null;
  12.         //创建读取流
  14.         try {
  15.             in = new FileInputStream("F:\\MySQL安装包.zip");
  17.             //创建写入流
  18.              os = new FileOutputStream("F:\\testFile\\copy.zip");
  20.             long l = System.currentTimeMillis();
  22.             //使用一个数组来转移数组
  23.             byte[] b = new byte[1024];
  24.             int len ;
  25.             //有数组的时候 len代表的是长度 没有的时候代表的是一个字节
  26.             while ((len = in.read(b)) != -1) {
  28.                 os.write(b,0,len);
  29.             }
  30.             long l1 = System.currentTimeMillis();
  31.             System.out.println("文件拷贝"+(l1 - l)/1000+"秒完成");
  34.         } catch (Exception e) {
  35.             e.printStackTrace();
  36.         }finally {
  37.             //无论代码出现什么异常都会执行这里
  38.             //除了虚拟机挂掉 无论什么情况包括return 都会执行finally代码块
  39.             //关闭之前必须做非空校验
  40.             //哪怕上面有return语句执行，也必须执行finally 如果finally加了return 这个程序永远返回的都是finally的数据
  42.             try {
  43.                 if(os != null)os.close();
  46.             } catch (IOException e) {
  47.                 e.printStackTrace();
  48.             }
  49.             try {
  50.                 if(in!=null)in.close();
  51.             } catch (IOException e) {
  52.                 e.printStackTrace();
  53.             }
  54.         }
  56.     }
  57. }
  60. //代码简化try(里面写资源对象)     JDK7的方案
  62.    //创建读取流
  63.         try (
  64.                 /*这里面只能放资源对象，用完会自动关闭：自动调用close方法关闭资源(即使出现了异常也会关闭资源)*/
  65.                 InputStream in = new FileInputStream("F:\\MySQL安装包.zip");
  66.                 OutputStream os = new FileOutputStream("F:\\testFile\\copy.zip");
  68.         ) {
  69.             long l = System.currentTimeMillis();
  70.             //使用一个数组来转移数组
  71.             byte[] b = new byte[1024];
  72.             int len;
  73.             //有数组的时候 len代表的是长度 没有的时候代表的是一个字节
  74.             while ((len = in.read(b)) != -1) {
  75.                 os.write(b, 0, len);
  76.             }
  77.             long l1 = System.currentTimeMillis();
  78.             System.out.println("文件拷贝" + (l1 - l) / 1000 + "秒完成");
  79.         } catch (Exception e) {
  80.             e.printStackTrace();
  81.         }
  82.     }
  84. //代码简化JDK9方案
  85. //定义一个输入流对象
  86. //定义一个输出流对象
  87. try(输入流对象;输出流对象){
  88.     可能出现异常的代码
  89. }catch(异常类名 变量名){
  90.     异常的处理代码
  91. }
  92. //资源用完最终自动释放

资源对象就是实现了 Closeable接口的都是资源

FileReader

FileReader rd = new FileReader(“xxx.txt”);

每次读取一个字符

rd.read();

  • 字符流的好处
    • 读取中文符不会出现乱码(前提编码一致)
  • 一次读取一个字符数组
    • char[] c = new char[1024];
    • re.read(c);