JAVA~~IO流和文件

​​​​​​​​

Io流的分类
有多种分类方式:
一种方式是按照流的方向进行分类:
以内存作为参照物,
往内存中去，叫做输入(Input)。或者叫做读(Read)。
从内存中出来，叫做输出(Output)。或者叫做写(Write)。
另一种方式是按照读取数据方式不同进行分类:
有的流是按照字节的方式读取数据，一次读取1个字节byte,等同于一次读取8个二进制 这种流是万能的，什么类型的文件都可以读取。包括:文本文件，图片，声音文件，视 假设文件file1. txt,采用字节流的话是这样读的:
a中国bc张三fe 第一次读:一一个字节，正好读到’a’ 第二次读: -一个字节，正好读到中字符的一一半。
第三次读:一个字节，正好读到，中字符的另外一一半。

有的流是按照字符的方式读取数据的，一次读取一个字符，这种流是为了方便读取普通文本文件而存在的，这种流不能读取:图片、声音、视频等文件。只能读取纯文本文件，连word文件都无法读取。 假设文件file1.txt,采用字符流的话是这样读的: a中国bc张三三fe 第一次读: 'a’字符 (
'a’字符在windows系统中占用1个字节。) 第二次读: '中’字符( '中’字符在windows系统中占用2个字节。)

综上所述：流的分类

输入流、输出流

字节流、字符流

Java中的Io流都已经写好了，我们程序员不需要关心,我们最主要还是掌握,
在java中已经提供了哪些流，每个流的特点是什么，每个流对象上的常用方法有 哪些???
java中所有的流都是在:
java.io.*;下。
java中主要还是研究:
怎么new流对象。
调用流对象的哪个方法是读，哪个方法是写。

java Io流这块有四大家族:
四大家族的首领:
java. io. Inputstream 字节输入流
java. io.Outputstrean 字节输出流
java. io. Reader 字符输入流 这
java. io. Writer 字符输出流

四大家族的首领都是抽象类。(abstract class)
所有的流都实现了:
java. io. Closeable接口，都是可关闭的，都有close() 方法。
流毕竟是一一个管道，这个是内存和硬盘之间的通道，用完之后一定要关闭,
不然会耗费(占用)很多资源。养成好习惯，用完流一定要关闭。
注意:在java中只要"类名”以stream结尾的都是字节流。以"Reader/writer"结尾的都是字符流

• 我们要想实现IO的操作，就必须知道硬盘上文件的表现形式。

• 而Java就提供了一个类File供我们使用。

• File:文件和目录(文件夹)路径名的抽象表示形式

• 构造方法：

•  File(String pathname)：根据一个路径得到File对象
  

•  File(String parent, String child):根据一个目录和一个子文件/目录得到File对象
  

•  File(File parent, String child):根据一个父File对象和一个子文件/目录得到File对象
  

package 文件;

import java.io.File;
import java.io.IOException;

public class FileCreate {
    public static void main(String[] args) {
       FileCreate f=new FileCreate();
       f.creat01();
       f.creat02();
       f.create03();

    }

    //方式1：new File(String pathname)
    public void creat01() {
        String filePath = "d:\\news1.txt";
        File file = new File(filePath);
        try {
            file.createNewFile();
            System.out.println("文件创建成功！");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    //方式 2 new File(File parent,String child) //根据父目录文件+子路径构建
    public void creat02(){
        File parentFile=new File("d:\\");
        String fileName="news2.txt";
    //这里的 file 对象，在 java 程序中，只是一个对象
   //只有执行了 createNewFile 方法，才会真正的，在磁盘创建该文件
        File file = new File(parentFile, fileName);
        try {
            file.createNewFile();
            System.out.println("创建成功~");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    //方式 3 new File(String parent,String child) //根据父目录+子路径构建
    public void create03() {
        String parentPath = "d:\\";
        String fileName = "news4.txt";
        File file = new File(parentPath, fileName);
        try {
            file.createNewFile();
            System.out.println("创建成功~");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

创建功能：

• public boolean createNewFile():创建文件 如果存在这样的文件，就不创建了

• public boolean mkdir():创建文件夹 如果存在这样的文件夹，就不创建了

• public boolean mkdirs():创建文件夹,如果父文件夹不存在，会帮你创建出来

package 文件;
import java.io.File;
import java.io.IOException;
public class FileDemo {
    public static void main(String[] args)throws IOException {
        // File(String pathname)：根据一个路径得到File对象
        // 把e:\\demo\\a.txt封装成一个File对象
        File file1 = new File("E:\\demo\\a.txt");
        // File(String parent, String child):根据一个目录和一个子文件/目录得到File对象
        File file2 = new File("E:\\demo", "a.txt");
        // File(File parent, String child):根据一个父File对象和一个子文件/目录得到File对象
        File file3 = new File("e:\\demo");
        File file4 = new File(file3, "a.txt"); // 以上三种方式其实效果一样

        // 需求：我要在e盘目录下创建一个文件夹demo
        File f1=new File("D:\\demo");
        System.out.println("mkdir"+f1.mkdir());
        /*需求：我要在D盘目录demo下创建一个a.txt*/
        File f2=new File("D:\\demo\\a.txt");
        System.out.println("createFileFile:"+f2.createNewFile());
        /*
        mkdirtrue
       createFileFile:true

         */
        // 需求：我要在e盘目录test下创建一个文件b.txt
        // Exception in thread "main" java.io.IOException: 系统找不到指定的路径。
        // 注意：要想在某个目录下创建内容，该目录首先必须存在。
          File f3 = new File("e:\\test\\b.txt");
         System.out.println("createNewFile:" + file3.createNewFile());

    }
}

• 删除功能:public boolean delete()
  注意：
  A:如果你创建文件或者文件夹忘了写盘符路径，那么，默认在项目路径下。
  B:Java中的删除不走回收站。
  C:要删除一个文件夹，请注意该文件夹内不能包含文件或者文件夹

创建文件
        File file=new File("D:\\a.txt");
       System.out.println("creatNewFile:"+file.createNewFile());
        //不小心写成这个样子
        File file=new File("a.txt");
        System.out.println("creatNewFile:"+file.createNewFile());

//删除功能：我要删除a.txt这个文件
        File file3=new File("a.txt");
          System.out.println("delet:"+file3.delete());

//创建文件夹
        File file2=new File("aaa\\bbb\\ccc");
        System.out.println("mkdirs:"+file2.mkdirs());

  //删除功能：我要删除ccc这个1文件夹
        File file4=new File("aaa\\bbb\\ccc");
        System.out.println("delet:"+file4.delete());

        //删除功能：我要删除aaa这个文件夹
        //直接删除不行，aaa下面还有子目录bbb.
        //File file5=new File("aaa");
        //System.out.println("delete:"+file5.delete());//false

        File file6=new File("aaa\\bbb");
         File file7=new File("aaa");
        System.out.println("delete:"+file6.delete());
        System.out.println("delete:"+file7.delete());

   重命名功能:public boolean renameTo(File dest)
	如果路径名相同，就是改名。
	如果路径名不同，就是改名并剪切。
    路径以盘符开始：绝对路径	c:\\a.txt
    路径不以盘符开始：相对路径	a.txt

	//相对路径
 //创建一个文件对象
        File file=new File("a.txt");
        //需求：我要修改这个文件的昵称
        File newFile=new File("b.txt");
        System.out.println("renameTo:"+file.renameTo(newFile));

		//绝对路径
     File file2=new File("D:\\a.txt");
        File  newFile=new File("D:\\aaa.txt");
        System.out.println("renameTo:"+file2.renameTo(newFile));

• 判断功能:
• public boolean isDirectory():判断是否是目录
• public boolean isFile():判断是否是文件
• public boolean exists():判断是否存在
• public boolean canRead():判断是否可读
• public boolean canWrite():判断是否可写
• public boolean isHidden():判断是否隐藏
• public String getAbsolutePath()：获取绝对路径
• public String getPath():获取相对路径
• public String getName():获取名称
• public long length():获取长度。字节数
• public long lastModified():获取最后一次的修改时间，毫秒值

public class FileDemo1 {
    public static void main(String[] args){
         File f1=new File("D:\\PPT.txt");
        System.out.println("文件名："+f1.getName());
         //判断是否是目录
        System.out.println("isDirectory："+f1.isDirectory());
        //判断是否是文件
        System.out.println("isFile："+f1.isFile());
        //判断是否存在
        System.out.println("exists:" + f1.exists()); 
        //判断是否可写
        System.out.println("canRead:" + f1.canRead()); 
        //判断是否可读
        System.out.println("canWrite:" + f1.canWrite()); 
        //判断是否隐藏
        System.out.println("isHidden:" + f1.isHidden()); 
        //获取文件最后一次修改时间
        long haomiao=f1.lastModified();//这个毫秒是从1970年到现在的总毫秒数
        Date time=new Date(haomiao);
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd  HH:mm:ss SSS");
        String strTime=sdf.format(time);
        System.out.println(strTime);
        //获取文件的大小
        System.out.println(f1.length());
        // 获取绝对路
        System.out.println("getAbsolutePath:" + f1.getAbsolutePath());
        // 获取相对路径
        System.out.println("getPath:" + f1.getPath());
/*
文件名：PPT.txt
isDirectory：false
isFile：true
exists:true
canRead:true
canWrite:true
isHidden:false
2022-03-28  17:09:00 232
740
getAbsolutePath:D:\PPT.txt
getPath:D:\PPT.txt

进程已结束,退出代码0
*/
      


    }

}

• 获取功能：
• public String[] list(): 获取指定目录下的所有文件或者文件夹的名称数组
• public File[] listFiles() :获取指定目录下的所有文件或者文件夹的File数组

import java.io.File;
/*
/*
 * 获取功能：
 * public String[] list():获取指定目录下的所有文件或者文件夹的名称数组
 * public File[] listFiles():获取指定目录下的所有文件或者文件夹的File数组
 */

public class FileTest03 {
    public static void main(String[] args){
      /*  //File[] listFile()
        //获取当前目录下所有的子文件
        File f=new File("D:\\");
        File[] files=f.listFiles();
        //foreach
        for(File f1: files){
            System.out.println(f1.getAbsolutePath());
        }*/

        //指定目录
        File file=new File("D:\\");
        String[] strArry=file.list();
        for(String s: strArry){
            System.out.println(s);
        }
       System.out.println("-----------");
        File[] fileArray=file.listFiles();
        for(File f: fileArray){
            System.out.println(f);
        }
/*
$RECYCLE.BIN
.temp
360downloads
360RecycleBin
360安全浏览器下载
360驱动大师目录
aaa.txt
BaiduNetdiskDownload
CloudMusic
C语言网大练习库
dd2daccb603dac59abbd25be61e1ea01
demo
Drivers
DumpStack.log
DumpStack.log.tmp
Idea
JavaProgram
Java文件
Java文件夹
JAVA核心技术代码
JAVA核心技术（全）课件.zip
JetBrains 2022 最新版本全家桶激活
LenovoSoftstore
Linux
Mathlab1
Mathlab2
MobileEmuMaster
MultiMediaOpt
pagefile.sys
PPT.txt
Program Files (x86)
QQMusicCache
System Volume Information
tempfile.txt
脚本.txt
腾讯会议
金山文档
-----------
D:\$RECYCLE.BIN
D:\.temp
D:\360downloads
D:\360RecycleBin
D:\360安全浏览器下载
D:\360驱动大师目录
D:\aaa.txt
D:\BaiduNetdiskDownload
D:\CloudMusic
D:\C语言网大练习库
D:\dd2daccb603dac59abbd25be61e1ea01
D:\demo
D:\Drivers
D:\DumpStack.log
D:\DumpStack.log.tmp
D:\Idea
D:\JavaProgram
D:\Java文件
D:\Java文件夹
D:\JAVA核心技术代码
D:\JAVA核心技术（全）课件.zip
D:\JetBrains 2022 最新版本全家桶激活
D:\LenovoSoftstore
D:\Linux
D:\Mathlab1
D:\Mathlab2
D:\MobileEmuMaster
D:\MultiMediaOpt
D:\pagefile.sys
D:\PPT.txt
D:\Program Files (x86)
D:\QQMusicCache
D:\System Volume Information
D:\tempfile.txt
D:\脚本.txt
D:\腾讯会议
D:\金山文档

进程已结束,退出代码0*/

    }
}

• 判断D盘目录下是否有后缀名为.txt的文件，如果有，就输出此文件名称
• A:先获取所有的，然后遍历的时候，依次判断，如果满足条件就输出。
• B:获取的时候就已经是满足条件的了，然后输出即可。
• 要想实现这个效果，就必须学习一个接口：文件名称过滤器
• public String[] list(FilenameFilter filter)
• public File[] listFiles(FilenameFilter filter)

		File file=new File("D:\\");
        String[] strArray=file.list(new FilenameFilter() {
            @Override
            public boolean accept(File dir, String name) {
                return new File(dir,name).isFile()&&name.endsWith(".txt");
            }
        });
        for(String s: strArray){
            System.out.println(s);
        }

想要更加详细，请点击我
java.io包下需要掌握的流有16个:.

文件专属:
java. io. File Inputstream
java. io. FileOutputstream
java. io. FileReader
java. io. FileWriter
转换流:(将字节流转换成字符流)
java. io. InputStreamReader
java. io. OutputStreamWriter
缓冲流专属:
java. io . BufferedReader
java. io . BufferedWriter
java. io. BufferedInputstream
java. io. BufferedOutputstream
数据流专属:
java. io. DataInputs tream
java. io. DataOutputstream
标准输出流:
java. io. PrintWriter
java. io. Printstream
对象专属流:
java. io. ObjectInputStream
java. io. objectOutputStream

java. io. File Inputstream

​
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class FileputStreamTest01  {
    public static void main(String[] args){
        FileInputStream fis=null;
        try{
            fis=new FileInputStream("D:\\PPT.txt");
            while(true){
                int readData=fis.read();
                if(readData==-1){
                    break;
                }
            }
        }catch (FileNotFoundException e){
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(fis!=null){
                try{
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

​

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

/*
int read(byte[] b)
    一次最多读取b.lebgth个字节。
    减少硬盘和内存的交互，提高程序的执行效率
    往byte[]数组当中读
 */
public class FileputStreamTest012 {
    public static void main(String[] args){
        FileInputStream fis=null;
        try{
            //相对路径的话呢？相对路径一定是从当前所在的位置作为起点开始找！
            fis=new FileInputStream("D:\\tempfile.txt");
           /* //改造while循环
            int readData=0;
            while((readData= fis.read())!=-1){
                System.out.println(readData);
            }*/
            byte[] bytes=new byte[229];
            while(true){
                int readcount= fis.read();
                if(readcount==-1){
                    break;
                }
                System.out.println(new String(bytes,0,readcount));
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(fis!=null){
                try{
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

完善代码（以及我的困惑—在改造中里的困惑–明明跟方法02类似为啥会报错呢）

package 文件;

import javax.imageio.stream.FileImageInputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

//要求: 请使用 FileInputStream 读取 hello.txt 文件，并将文件内容显示到控制台.
public class FileInputStream_ {
    public static void main(String[] args) {
/**
 * 演示读取文件...
 * 单个字节的读取，效率比较低
 * -> 使用 read(byte[] b)
 */
        FileInputStream_ fileInputStream_ = new FileInputStream_();
       // fileInputStream_.readFile01();
        //fileInputStream_.readFil02();
        fileInputStream_.readFil022();//为啥这个不行呢？
    }

    public static void readFile01(){
        String filePath = "d:\\hello.txt";
        int readData = 0;
        FileInputStream fileInputStream = null;
        try {
            //创建FileInputStream 对象，用于读取文件
            fileInputStream = new FileInputStream(filePath);
            //从该输入流读取一个字节的数据。 如果没有输入可用，此方法将阻止。
            //如果返回-1 , 表示读取完毕
            while ((readData = fileInputStream.read()) != -1) {
                System.out.println((char)readData);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //关闭文件流，释放资源
            try {
                fileInputStream.close();
            }catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    /**
     * 使用 read(byte[] b) 读取文件，提高效率
     */
    public static void readFil02() {
        String filePath = "d:\\hello.txt";
        //字节数组
        byte[] buf = new byte[8];//一次读取8个字节
        int readLen = 0;
        FileInputStream fileInputStream = null;
        try {
            //创建 FileInputStream 对象，用于读取 文件
            fileInputStream = new FileInputStream(filePath);
            //从该输入流读取最多 b.length 字节的数据到字节数组。 此方法将阻塞，直到某些输入可用。
            //如果返回-1 , 表示读取完毕
            //如果读取正常, 返回实际读取的字节数
            while ((readLen = fileInputStream.read(buf)) != -1) {
                System.out.print(new String(buf, 0, readLen));//显示
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //关闭文件流，释放资源.
            try {
                fileInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
     //改造readFil02()方法
        public static void readFil022(){
            FileInputStream fis=null;
            try {
                fis=new FileInputStream("d:\\hello.txt");

                byte[] bytes=new byte[8];//一次读取8个字节
                while(true){
                    int readCount=fis.read();
                    if(readCount==-1){
                        break;
                    }
                    System.out.println(new String(bytes,0,readCount));
                }
            } catch (IOException e) {
                e.printStackTrace();
            }finally {
                if(fis!=null){
                    try{
                        fis.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
}

java. io. FileOutputstream

package 文件;

import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;

public class FileOutputStream01 {
    public static void main(String[] args) {
        /**
         * 要求: 请使用 FileOutputStream 在 a.txt 文件，
         * 中写入 “hello，world”. [老师代码演示],
         * 如果文件不存在，会创建
         * 文件(注意：前提是目录已经存在.)
         */
        //创建FileOutputStream 对象
        String filePath="d:\\a.txt";
        FileOutputStream fileOutputStream=null;
        try{
            //得到FileOutStream 对象
            /**
             * 1.new FileOutputStream(filePath) 创建方式，
             * 当写入内容是会覆盖原来的内容
             * 2.new FileOutputStream(filePath,true)创建方式，
             * 当写入内容是追加到文件后面
             */
            fileOutputStream = new FileOutputStream(filePath,true);
            //写入一个字符
            //fileOutputStream.write('H');
             //fileOutputStream.write('G');
            //写入一个字节
            String str="zouzou,world";
            //str.getBytes();//可以把字符串->字节数组
           // fileOutputStream.write(str.getBytes());
            /*
            write(byte[] b, int off, int len)
            将 len 字节从位于偏移量 off 的指定字节数组写入此文件输出流
           */
            fileOutputStream.write(str.getBytes(),0,5);
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try{
                fileOutputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

点击详细内容

上菜——文件的拷贝
首先从简单入手：
要求: 编程完成图片/音乐 的拷贝

package 文件;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileCopy {
    public static void main(String[] args) throws IOException {
        /*
        1、现在在C盘中放有一个名为MultiFile的文件夹，
        请编写程序将此文件夹下的所有文件夹和文件复制到D盘的MultiFileCopy文件夹下。
        注意：要求MultiFile文件夹下至少含有三层以上的文件夹，
        且每层文件夹中均要求含有至少一个java文件和非java文件(如txt文件)。
         */
        //1.创建文件的输入流，将文件读入到程序
        //2.创建文件的输出流，将读取到的文件数据，写入到指定的文件
        String srcFilePath="C:\\微信图片_20201122144441.jpg";
        String destFilePath="D:\\MultiMediaOpt\\Image";
        FileInputStream fileInputStream=null;
        FileOutputStream fileOutputStream=null;
            try {
                fileInputStream=new FileInputStream(srcFilePath);
                fileOutputStream=new FileOutputStream(destFilePath);
                //定义一个字节数组，提高读取效果
                byte[] buf=new byte[1024];
                int readLen=0;
                while((readLen=fileInputStream.read(buf))!=-1){
                    //读取到后，就写入到文件 通过fileOutStream
                    //即，是一边读一边写
                    fileOutputStream.write(buf,0,readLen);
                }
                System.out.println("拷贝 ok~");
            } catch (IOException e) {
                e.printStackTrace();
            }finally {
                try {
                   if(fileInputStream!=null){
                    fileInputStream.close();
                   }
                   if(fileOutputStream!=null){
                        fileOutputStream.close();
                      }
                 }catch (IOException e) {
                        e.printStackTrace();
                }
            }


    }


}

进阶般来临，你做好准备了嘛？

package 文件;

import java.io.*;

public class CopyAll {
    public static void main(String[] args){
        //拷贝源
        File srcFile=new File("D:\\MultiFile");
        //拷贝目标
        File destFile=new File("C:\\MultiFileCopy");
        //调用方法拷贝
        copyDir(srcFile,destFile);
    }

    private static void copyDir(File srcFile, File destFile) {
      String path=(destFile.getAbsolutePath().endsWith("\\")? destFile.getAbsolutePath() : "//"+destFile.getAbsolutePath())+srcFile.getAbsolutePath().substring(3);
       if(srcFile.isFile()){
           //srcFile如果是一个文件的话，递归结束
           //是文件的时候需要拷贝。
           //....边读边写。
           FileInputStream in=null;
           FileOutputStream out=null;
           try{
               //读这个文件
               in=new FileInputStream(srcFile);
               //写到这个文件中
               out=new FileOutputStream(path);
               byte[] bytes=new byte[1024*1024];
               int readCount=0;
               while((readCount=in.read(bytes))!=-1){
                   out.write(bytes,0,readCount);
               }
               out.flush();
           }catch (FileNotFoundException E){
               E.printStackTrace();
           } catch (IOException e) {
               e.printStackTrace();
           } finally {
               if(out!=null){
                   try{
                       out.close();
                   } catch (IOException e) {
                       e.printStackTrace();
                   }
               }

           }
           return ;
       }
        //获取源下面的子目录
        File[] files=srcFile.listFiles();
       for(File file:files){

           //递归调用
           if(file.isDirectory()){
               //新建对应的目录
               String srcDir=file.getAbsolutePath().substring(3);
               //System.out.println(srcDir);
               String destDir=(destFile.getAbsolutePath().endsWith("\\")? destFile.getAbsolutePath() : "//"+destFile.getAbsolutePath())+srcDir;
               System.out.println(destDir);
               File newFile=new File(destDir);
               if(!newFile.exists()){
                   newFile.mkdirs();
               }
           }
           copyDir(file,destFile);
       }
    }
}

节点流和处理流的区别与联系

1.节点流是底层流/低级流,直接跟数据源相接。

2.处理流(包装流)包装节点流，既可以消除不同节点流的实现差异，也可以提供更方
便的方法来完成输入输出。[源码理解]

3.处理流(也叫包装流)对节点流进行包装，使用了修饰器设计模式，不会直接与数据源相连[模拟修饰器设计模式=》小伙伴就会非常清楚]

处理流的功能主要体现在以下两个方面

1.性能的提高:主要以增加缓冲的方式来提高输入输出的效率。
2. 操作的便捷:处理流可能提供了一系列便捷的方法来一 次输入输出大批量的数据，使
用更加灵活方便

package 文件;
import java.io.BufferedReader;
import java.io.FileReader;

/**使用BuffferedReader读取文本文件，并显示在控制台*/
public class BufferedReader_ {

    public static void main(String[] args) throws Exception {
        String filePath = "D:\\匿名类.java";
    //创建 bufferedReader
        BufferedReader bufferedReader = new BufferedReader(new FileReader(filePath));

    //读取
        String line; //按行读取, 效率高
    //说明
//1. bufferedReader.readLine() 是按行读取文件
//2. 当返回 null 时，表示文件读取完毕
        while ((line = bufferedReader.readLine()) != null) {
            System.out.println(line);
        }
//关闭流, 这里注意，只需要关闭 BufferedReader ，因为底层会自动的去关闭 节点流
//FileReader。
/*
public void close() throws IOException {
synchronized (lock) {
if (in == null)
return;
try {
in.close();//in 就是我们传入的 new FileReader(filePath), 关闭了.
} finally {
in = null;
cb = null;
}
}
}
*/

        bufferedReader.close();
    }
}

package 文件;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
    /**
     * 演示 BufferedWriter 的使用
     */
    public class BufferedWriter_ {
        public static void main(String[] args) throws IOException {
            String filePath = "e:\\ok.txt";
    //创建 BufferedWriter
    //说明:
    //1. new FileWriter(filePath, true) 表示以追加的方式写入
    //2. new FileWriter(filePath) , 表示以覆盖的方式写入
            BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(filePath));
            bufferedWriter.write("hello, 韩顺平教育!");
            bufferedWriter.newLine();//插入一个和系统相关的换行
            bufferedWriter.write("hello2, 韩顺平教育!");
            bufferedWriter.newLine();
            bufferedWriter.write("hello3, 韩顺平教育!");
            bufferedWriter.newLine();
     //说明：关闭外层流即可 ， 传入的 new FileWriter(filePath) ,会在底层关闭
            bufferedWriter.close();
        }
    }

package com.hspedu.writer_;
import java.io.*;
public class BufferedCopy_ {
public static void main(String[] args) {
//老韩说明
//1. BufferedReader 和 BufferedWriter 是安装字符操作
//2. 不要去操作 二进制文件[声音，视频，doc, pdf ], 可能造成文件损坏
//BufferedInputStream
//BufferedOutputStream
	String srcFilePath = "e:\\a.java";
	String destFilePath = "e:\\a2.java";
// String srcFilePath = "e:\\0245_韩顺平零基础学 Java_引出 this.avi";
// String destFilePath = "e:\\a2 韩顺平.avi";
	BufferedReader br = null;
	BufferedWriter bw = null;
	String line;
	try {
		br = new BufferedReader(new FileReader(srcFilePath));
		bw = new BufferedWriter(new FileWriter(destFilePath));
//说明: readLine 读取一行内容，但是没有换行
	while ((line = br.readLine()) != null) {
	//每读取一行，就写入
		bw.write(line);
	//插入一个换行
		bw.newLine();
	}
	System.out.println("拷贝完毕...");
	} catch (IOException e) {
	e.printStackTrace();
} finally {
//关闭流
	try {
	if(br != null) {
		br.close();
	}
	if(bw != null) {
		bw.close();
	}
} catch (IOException e) {
	e.printStackTrace();
	}
  }
 }
}

总结:总体来说，关于这一章的内容，我自认为是做的比较乱，还有就是这部分内容，知识点比较多，要掌握的也是挺多的，希望各位小伙伴能够好好掌握，有错请及时指正哈！！！