java.io流的基本常用类

Java.io包下面的类主要是对文件的操作

包括File，inputStream，OutputStream,Reader和Writer及其子类。

1. FLie类

• File类常用构造函数：

  String parentPath = "C:\\Users\\Administrator\\Desktop";
  String demoPath = "C:\\Users\\Administrator\\Desktop\\demo.txt";
  //1 以文件路径字符串创建File对象
  File file1 = new File(demoPath);
  //2 第一个参数代表父目录字符串，第二个参数代表子目录或者文件字符串
  File file2 = new File(parentPath,"/dir1");
  //3 第一个代表父文件对象，第二个是子目录或者文件字符串
  File file3 = new File(file2,"/dir2");
  

• file类的其他常用方法：

  package file类的使用;
  
  import java.io.File;
  import java.io.IOException;
  
  /**我们发现，无论创建文件夹还是文件时，创建路径和目的文件都是写在new后面*/
  public class 文件及文件夹的crud {
      public static void main(String[] args) throws IOException {
          /**路径分隔符Windows：分号; Linux：冒号 ：  */
          String pathSeparator = File.pathSeparator;
          System.out.println(pathSeparator);
          /**文件名称分隔符：Windows：反斜杠\ Linux：正斜杠：/  */
          String separator = File.separator;
          System.out.println(separator);
          File f = new File("F:\\Javastudy\\idea\\base\\base", ".txt");
          File absoluteFile = f.getAbsoluteFile();
          /**绝对路径*/
          System.out.println(absoluteFile + "absolutefile");
          String name = f.getName();
          /**获取文件名或最后一个层目录名称*/
          System.out.println(name + "getname");
          String path = f.getPath();
          /**获取路径的字符串*/
          System.out.println(path + "getpath");
          boolean exists = f.exists();
          /**判断f构造方法路径是否存在*/
          System.out.println(exists);
          boolean directory = f.isDirectory();
          /**判断f是否为目录*/
          System.out.println(directory);
          /***注意：下方法在创建对象的时候创建新文件*/
          File f1 = new File("F:\\Javastudy\\idea\\base\\base", "2.txt");
          /**此处会抛出异常，我们throws就行了*/
          boolean newFile = f1.createNewFile();
          System.out.println(newFile);
          /**创建单级文件夹*/
          boolean mkdir = f1.mkdir();
          System.out.println(mkdir);
          /**创建多级文件夹*/
          boolean mkdirs = f1.mkdirs();
          System.out.println(mkdirs);
          /**删除不会经过回收站，删除要谨慎*/
          boolean delete = f1.delete();
          System.out.println(delete);
          File f2 = new File("F:\\Javastudy\\idea");
          /**遍历一级目录和文件*/
          String[] list = f2.list();
          for (String s : list) {
              System.out.println(s);
          }
          /**遍历目录全称和文件*/
          File[] files = f2.listFiles();
          for (File file : files) {
              System.out.println(file);
          }
      }
  }
  
  

2. 抽象基类InputStream和OutputStream

• 字节流主要是以字节的方式读取或者写入文件。

• 此处以其子类FileInputStream和FileOutputStream表示。

  class InPutStream{
      public static void main(String[] args) throws IOException {
          FileInputStream fis = new FileInputStream("IO流");
          byte[] aa = new byte[1024];//第一步，创建一个byte数组，存储读取的字节。
          int len = 0;//记录读取到的字节.
          while ((len = fis.read(aa)) !=-1){
              System.out.println(new String(aa,0,aa.length));//这里调用了String中byte转换为String类型的方法。
          }
          fis.close();
      }
  }
  class OutPutStream{
      public static void main(String[] args) throws IOException {
          FileOutputStream fos = new FileOutputStream("IO流",true);//append是续写开关，true表示续写开关开启。
          byte[] bytes = "你是猪".getBytes(StandardCharsets.UTF_8);//把"你是猪"转换为字节写入
          byte[] a = {55,78,98,97,99};//一次性写入多个字节
          fos.write(a,0,a.length);//写入方式，理解三个参数的含义
          fos.write(bytes,0,bytes.length);
          fos.close();//最后记得关闭流
      }
  }
  

3. 缓冲流BufferedInputStream,BufferedOutputStream

• 在平常的底层流（字节输入流）的使用中，效率较低，cpu与io的互动慢。我们把多个字节的数据放入内存，让cpu直接与内存互动，可以提高效率。

• 在使用缓冲流时，还可以使用字节数组进一步提高效率，两者互不影响。

  class 缓冲流文件复制{
      public static void main(String[] args) throws IOException {
          long s = System.currentTimeMillis();
          BufferedInputStream bis = new BufferedInputStream(new FileInputStream("C:\\Users\\Administrator\\Pictures\\Screenshots\\NEW.png"));
          BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("C:\\Users\\Administrator\\Pictures\\NEe.png"));
          byte[] aa = new byte[1024];//使用字节数组，一个byte数组创建1024个字节的空间
          int len = 0;
          while ((len = bis.read(aa))!=-1){
              bos.write(aa,0,aa.length);
          }
          bos.close();
          bis.close();
          long e = System.currentTimeMillis();
          System.out.println((e-s)+"毫秒");
      }
  }
  

4. 字符流Reader和Writer

• 字符流与字节流的区别在于，字符流每次读或写是以char为单位，而不是byte，说明速度更快。
• 字符流只能对字符对象进行输入输出，这里不再赘述。

5. 转换流

• OutputSreamWriter：字符 ->字节

  public class 转码 {
     public static void main(String[] args) throws IOException {
         OutputStreamWriter osw= new OutputStreamWriter(new FileOutputStream("IO流"),"GBK");
         osw.write("my name is lucy");
         osw.close();
     }
  }
  

• InputSreamReader：字节 ->字符

  同上。

6. Java IO流相关的类的分类

1. 按照数据来源去向分类：
是文件： FileInputStream, FileOutputStream, FileReader, FileWriter
是byte[]：ByteArrayInputStream, ByteArrayOutputStream
是Char[]: CharArrayReader, CharArrayWriter
是String: StringBufferInputStream, StringReader, StringWriter
网络数据流：InputStream, OutputStream, Reader, Writer

2. 按是否格式化输出分：
要格式化输出：PrintStream, PrintWriter

3. 按是否要缓冲分：
要缓冲：BufferedInputStream, BufferedOutputStream, BufferedReader, BufferedWriter。

4. 按数据格式分：
二进制格式（只要不能确定是纯文本的,称为字节流）: InputStream, OutputStream及其所有带Stream结束的子类
纯文本格式（含纯英文与汉字或其他编码方式，称为字符流）；Reader, Writer及其所有带Reader, Writer的子类

5. 按输入输出分：
输入：Reader, InputStream类型的子类；
输出：Writer, OutputStream类型的子类