    public static void main(String[] args)throws IOException 
        // 创建输入流对象
        FileInputStream a = new FileInputStream("a.txt");
        // 定义临时变量，每次读取数据让变量记录
         int i;
         // 读取到-1的时候说明读取结束，跳出循环
        while ((i=a.read())!=-1)
            System.out.print((char) i+" ");
        
        // 关闭流释放资源
        a.close();

字节流写出文件?

    public static void main(String[] args)throws IOException 
        // 创建字节输出流对象   不清楚原有内容加上true
        FileOutputStream a = new FileOutputStream("a.txt",true);
        //   写入的字符串返回字节数组写入
        a.write("Hello,world".getBytes());
        // 关闭流释放资源
        a.close();

字节流缓冲区拷贝文件？

    public static void main(String[] args) throws IOException 
        // 创建字节输入输出流对象
        FileInputStream a = new FileInputStream("a.txt");
        FileOutputStream b = new FileOutputStream("b.txt");
        byte [] arr = new byte[1024];
        // 创建临时变量
        int i;
        while ((i=a.read(arr))!=-1)
            // 读取的数据写入进去  完成文件拷贝
            b.write(arr,0,i);  // 数组 从0开始 到i结束写入
        
        // 关闭流释放资源
        a.close();b.close();

字节流缓冲流拷贝文件？

    public static void main(String[] args) throws IOException 
        // 创建字节输入输出缓冲流对象
        BufferedInputStream a = new BufferedInputStream(new FileInputStream("a.txt"));
        BufferedOutputStream b = new BufferedOutputStream(new FileOutputStream("b.txt"));
        // 创建临时变量
        int i;
        while ((i = a.read()) != -1) 
            // 读取的数据写入进去  完成文件拷贝
            b.write(i);  //
        
        // 关闭流释放资源
        a.close();
        b.close();

字符流图解：

输入流

输出流

字符流读取文件？

    public static void main(String[] args) throws IOException 
        // 创建字符流对象
        FileReader fileReader = new FileReader("E:\\\\a.txt");
        // 创建临时变量 存储数据
        int i;
        while ((i=fileReader.read())!=-1)
            System.out.println((char) i);

        
        // 关闭流释放资源
        fileReader.close();

字符流写出文件？

  public static void main(String[] args) throws IOException 
        // 创建字符输出流对象 写入文件
        FileWriter fileWriter = new FileWriter("E:\\\\b.txt");
        // 写入 
        fileWriter.write("你好,世界");
        // 关闭流释放系统资源
        fileWriter.close();

字符流拷贝文件？

 public static void main(String[] args) throws IOException 
        // 创建输入输出流对象
        FileReader a = new FileReader("E:\\\\a.txt");
        FileWriter b = new FileWriter("E:\\\\b.txt");
        // 定义临时变量
        int i ;
        // 读取到的写入进去
        while ((i=a.read())!=-1)
            b.write(i);
        
        // 关闭流释放系统资源
         a.close();b.close();

字符缓冲区拷贝文件？

    public static void main(String[] args) throws IOException 
        // 创建输入输出流对象
        FileReader a = new FileReader("E:\\\\a.txt");
        FileWriter b = new FileWriter("E:\\\\b.txt");
        // 定义字符数组
        char[] chars = new char[1024];
        // 定义临时变量
        int i ;
        // 读取到的存储到数组在写入数据
        while ((i=a.read(chars))!=-1)
            b.write(i);
        
        // 关闭流释放系统资源
         a.close();b.close();

字符缓冲流拷贝文件？

    public static void main(String[] args) throws IOException 
        // 创建缓冲流对象
        BufferedReader a = new BufferedReader(new FileReader("a.txt"));
        BufferedWriter b = new BufferedWriter(new FileWriter("b.txt"));
        // 定义临时变量
        String c = null;
        //  循环每次读取一行文本
        // readLine不会读取到回车换行符  new Line可以读取到回车换行符
        while ((c=a.readLine())!=null)
            b.write(c);
            b.newLine();
        
        // 关闭流释放系统资源
        a.close();b.close();

字符流底层是什么？？

解决问题：字符流底层通过字节流 + 编号表的形式读取。

编号表： GBK-> 一个中文占2个字符

UTF-8-> 一个中文占3个字符

例如windows txt文件默认是utf-8，java编译时也应该是utf-8，否则会出现乱码问题。

转换流

当文件含有中文、英文、数字时，使用字节流将文件内容在内存中显示，英文和数字显示正常，中文却现实乱码，可以使用转换流将其转化为字符流显示在内存中。

转换流：InputStreamReader: 将InputStream转换为Reader

OutputStreamWriter: 将Writer转换为OutputStream

作用：

文本文件在硬盘中以字节流的形式存储时，

通过InputStreamReader读取后转化为字符流给程序处理，程序处理的字符流通过OutputStramWriter转化为字节流保存。

特点：

读取到的字节数据经过指定编码转换为字符。

可对读取到的字符数据经过指定编码转换成字节。

何时使用转换流？

当字节和字符之间有转换动作时；

流操作的数据需要编码或解码时；

作用：提供字节流与字符流之间的转换，很多时候使用转换流来处理文件乱码问题，实现编码和解码的功能。

解码：字节，字节数组->字符、字符数组

编码：字符，字符数组->字节、字节数组

 public static void main(String[] args) throws IOException 
        // 创建缓冲流对象 指定编码格式
        InputStreamReader a = new InputStreamReader(new FileInputStream("a.txt"), "utf-8");
        OutputStreamWriter b = new OutputStreamWriter(new FileOutputStream("b.txt"), "utf-8");
        // 创建 字符缓冲流
        BufferedReader c = new BufferedReader(a);
        BufferedWriter d = new BufferedWriter(b);
        String e;
        while ((e=c.readLine())!=null)
            d.write(e);
            d.newLine();
        
        // 关闭流释放系统资源
        c.close();d.close();

三、File类

File类可以做什么？

定义：File类是I/O包中唯一代表磁盘文件本身的对象。向文件名、路径、目录等等

作用：用于封装一个路径，提供了一系列的方法用于操作该路径所指向的文件。

File类的构造方法

    public static void main(String[] args) throws IOException 
        // 指定路径创建文件夹对象
        File file = new File("E:\\\\a.txt");
        //  父路径 子路径 创建文件夹对象
        File file2 = new File("E:","a.txt");
        // File类的父路径   子路径
        File file3 = new File(new File("E:"),"a.txt");

File类的常用方法

    public static void main(String[] args)throws IOException 
        // 创建目录对象
        File file = new File("E:\\\\a.txt");
        // 判断目录或文件是否存在，存在true,反之false
        System.out.println(file.exists());
        // 删除目录或文件夹
        System.out.println("E:\\\\a.txt");
        // 当File对应的文件或目录不存在时，创建一个新的文件，成功true，反之false。
        System.out.println(file.createNewFile());
        // 返回文件夹或文件名称
        System.out.println(file.getName());
        //  返回file对象对应的路径
        System.out.println(file.getPath());
        // 返回file对象对应的绝对路径
        System.out.println(file.getAbsoluteFile());
        // 返回路file对象对应的父目录
        System.out.println(file.getParent());
        //判断文件是否可读
        System.out.println(file.canRead());
        //判断文件是否可写
        System.out.println(file.canWrite());
        // 判断是否是文件
        System.out.println(file.isFile());
        // 判断是否是文件夹
        System.out.println(file.isDirectory());
        // 判断对应的文件是否是绝对路径
        System.out.println(file.isAbsolute());
        //返回1970年1月1日0时0分0秒最后修改时间的毫秒值
        System.out.println(new Date(file.lastModified()));
        // 返回文件的长度
        System.out.println(file.length());

File遍历文件夹

    public static void main(String[] args)throws IOException 
        //  String [ ] list : 列出指定目录的全部内容，只是列出名称
        File file = new File("E:");
        String[] list = file.list();
        for (String a:list)
            System.out.println(a);
        
        // String [] list  FilenameFilterfilter  接受一个FilenameFilter参数，通过该参数可以列出符合条件的文件
        File file2 = new File("E:");
        String[] list1 = file2.list(new FilenameFilter() 
            @Override
            public boolean accept(File dir, String name) 
                File file1 = new File(dir,name);
                return name.endsWith("txt");
            
        );
        //  File [] listFiles    返回一个包含了File对象所有子文件和子目录的File数组
        System.out.println(Arrays.toString(list1));
        File file3 = new File("E:");
        File[] files = file3.listFiles();
        System.out.println(Arrays.toString(files));

   public static void main(String[] args) throws IOException 
        //  遍历文件夹
        File file = new File("E:");
        // 判断是否是文件夹
        if (file.isDirectory()) 
            // 创建数组
            String[] list = file.list();
            // 转换流循环遍历
            Arrays.stream(list).forEach((s -> System.out.println(s)));
        

        // 筛选文件夹
        File file2 = new File("E:");
        // 判断是否是文件夹
        if (file2.isDirectory()) 
            String[] list2 = file.list((dir, name) -> name.endsWith("txt"));
            Arrays.stream(list2).forEach((s -> System.out.println(s)));
        

       // 遍历指定目录下的文件名称
        bian(new File("E:"));
    
      public static void bian(File dir)
          File[] files = dir.listFiles();
          for (File a:files)
              if(a.isFile())
                  System.out.println(a.getName());
               else if (a.isDirectory()) 
                  if((a.listFiles())!=null)
                      bian(a);

递归删除文件及目录

    public static void main(String[] args) throws IOException 
     //在使用该方法时需要判断当前目录下是否存在文件，如果存在则需要先删除内部文件然后在删除空的文件夹
        shan(new File("E:"));
    
    public static void shan(File dir)
        // 创建File数组
        File[] files = dir.listFiles();
        // 循环遍历
        for (File a:files)
            // 判断是否为文件
            if(a.isFile())
                a.delete();
                // 判断是否为文件夹
            else if(a.isDirectory())
                // 判断文件夹是否为空
                if ((a.listFiles())!=null)
                    shan(a);
                
            
            a.delete();

RandomAccesseFile

定义：不属于流类，但具有读写文件数据的功能。

作用：可以随机从文件的任何位置开始并以指定的操作权限（只读、写入）执行读取数据的操作。

实现原理：

（1）新建RandomAccessFile对象时，该对象的文件记录指针会在文件开始出（表示为0的位置）

（2）读写的n个字节后，文件记录指针会向后移动n个字节。

（3）除了按顺序读写外，RandomAccseeFile对象还可以自由的移动记录指针，既可以向前移动，也可以向后移动。

    public static void main(String[] args) throws IOException 
        // 创建对象， 写入的方式写入。
        RandomAccessFile c = new RandomAccessFile("a.txt", "rw");
        // ReadLine   从指针文件当去指针读取下一行内容
        String s = c.readLine();
        // 字符串转换为int类型 -1 
        int i = Integer.parseInt(s) - 1;
        if (i > 0) 
            System.out.println("剩余" + i + "次");
            // seek，设定读写指针的位置，与文件开头相隔pos个字节数
            c.seek(2);  // 与开头相隔2个
            // 转换为字节数组写入
            c.write((i + "").getBytes());
         else 
            System.out.println("没了");
        
        c.close();

对象序列化

定义：java对象转换成一个I/O流中字节序列的过程

作用：可以将对象中的数据保存到磁盘上。

功能类

public class Day_01 implements Serializable 
    private static final long serialVersionUID = 1L;
  private String name;
  private  int age;

    public Day_01(String name, int age) 
        this.name = name;
        this.age = age;
    

    @Override
    public String toString() 
        return "Day_01" +
                "name='" + name + '\\'' +
                ", age=" + age +
                '';

测试类

    public static void main(String[] args) throws Exception 
        write();
        read();
    

    public static void write() throws IOException 
        ObjectOutputStream b = new ObjectOutputStream(new FileOutputStream("a.txt"));
        Day_01 day_01 = new Day_01("a", 15);
        b.writeObject(day_01);
        b.close();
    

    public static void read() throws IOException, ClassNotFoundException 
        ObjectInputStream c = new ObjectInputStream(new FileInputStream("a.txt"));
        Object o = c.readObject();
        System.out.println(o);
        c.close();

NIO

NIO了解

定义：NIO即new n/o，处理输入输出的新功能。

NIO的三大核心

Buffer（缓冲器）：是一个数组缓冲器，读取或写出到channnel中的对象都会先放在Buffer中（它是双向的）。

Channel(通道)：对传统的输入/输出的模拟，在NIO中，所有的数据都需要通过通道流的形式传输。

Selecter(选择器)：用于监听多个通道的时间，主要作用于线程（多线程进行讲解）。

注意：通道本身不能完成传输，需要依赖于缓冲器，两者是并存的。

Buffer缓冲器

作用：主要用于和Channel通道配合，完成数据的传输。

说明:Buffer是一个抽象类，它需要使用其子类：ByteBuffer、charBuffer、DoubleBuffer、FloatBuffer、IntBuffer、LongBuffer和shortBuffer。

方法：

Capacity() 容量

Limit() 可以操作到哪个索引（界限）

Position() 当前准备操作的索引

Mark() 标记，用来记录当前position 的值

Reset() 如果position的值发生了变化，那么通道随reset可以反馈mark记录的那个值

Put() 向缓冲器中添加数据

Get() 获取缓冲器中的数据

    public static void main(String[] args) throws Exception 
        // 写入模式,缓冲器放入2个字节，容量为5，界限为5，准备索引为2
        ByteBuffer allocate = ByteBuffer.allocate(5); // 分配新的字节缓冲区
        allocate.put("a".getBytes());
        allocate.put("b".getBytes());
        System.out.println(allocate.capacity());  // 容量
        System.out.println(allocate.limit()); // 可以操作到哪个索引
        System.out.println(allocate.position());  // 准备操作的索引
        // 切换读取模式
        allocate.flip();
        System.out.println(allocate.capacity());
        System.out.println(allocate.limit());
        System.out.println(allocate.position());
        // 标记
        allocate.mark();
        // 放入字节数组，转为字符串读取
        byte[] bytes = new byte[2];
        allocate.get(bytes);
        System.out.println(new String(bytes));
        System.out.println(allocate.capacity());
        System.out.println(allocate.limit());
        System.out.println(allocate.position());
        // mark 反馈记录的值
        allocate.reset();
        allocate.get(bytes);
        System.out.println(new String(bytes));
        System.out.println(allocate.capacity());
        System.out.println(allocate.limit());
        System.out.println(allocate.position());

channel通道

定义：Channel是一个接口对象，从Channel中读取数据，也可以将数据写道Channel中。

方法：

Int write() 从给定的缓冲区写入这个通道的字节序列

Long size() 返回该通道文件的当前大小

Int read() 从这个通道读取一个字节序列到给定的缓冲区

Long transferTo() 读取该通道文件中给定位置的字节数，将它们写入目标通道中

案例：使用通道缓冲器实现对文件的拷贝

    public static void main(String[] args) throws Exception 
        // 创建对象
        FileInputStream a = new FileInputStream("a.txt");
        FileOutputStream b = new FileOutputStream("b.txt");
        // 创建通道
        FileChannel c = a.getChannel();
        FileChannel d = b.getChannel();
        //创建缓冲器
        ByteBuffer allocate = ByteBuffer.allocate(1024);
      // 读取到的数据放进通道中，切换读取模式，写入通道，清楚缓冲器数据。
        while ((c.read(allocate)) != -1) 
            allocate.flip();
            d.write(allocate);
            allocate.clear();
        
        // 关闭流释放系统资源
        a.close();
        b.close();
        c.close();
        d.close();

案例:使用RandomAccessFile创建通道拷贝文件

    public static void main(String[] args) throws Exception 
         // 创建对象
        RandomAccessFile a = new RandomAccessFile("a.txt","rw");
        RandomAccessFile b = new RandomAccessFile("a.txt","rw");
       //  创建通道
        FileChannel c= a.getChannel();
        FileChannel d = b.getChannel();
        //  读取该通道文件中给定位置的字节数，将它们写入目标通道中。
        long l = c.transferTo(0, c.size(), d);
        if(l>0)
            System.out.println("拷贝成功");

NIO.2 path接口和Files工具类

Files工具类

常用方法：

createDirectories( ) 创建多级文件夹

createFile（）创建文件

write( ) 将文本写入文件，并以传入指定的写入方式。

readllLines( ) 从文件中读取所有行

size( ) 返回文件的大小，以字节为单位

    public static void main(String[] args) throws Exception 
        // 创建多级文件夹
        Path c = Paths.get("E:\\\\DD\\\\CC");
        Files.createDirectories(c);
        // 创建多级文件
        Path path = Paths.get("E:\\\\a.txt");
        Files.createFile(path);
        // 从文件中读取所有行，并传入指定的写入方式
        ArrayList<String> d = new ArrayList<>();
        d.add("D行");
        d.add("李S");
        Files.write(path, d, StandardOpenOption.APPEND); // 路径  内容 枚举
        // 从文件中读取所有行
        List<String> strings = Files.readAllLines(path);
        System.out.println(strings);
        // 返回文件的大小，以字节为单位。
        long size = Files.size(path);
        System.out.println(size);