基础复习第二十三天 File类与IO流的使用

最新推荐文章于 2024-05-23 15:45:10 发布

保佑无BUG

最新推荐文章于 2024-05-23 15:45:10 发布

阅读量459

点赞数

分类专栏：笔记文章标签： java jvm 服务器 Powered by 金山文档

本文链接：https://blog.csdn.net/m0_61477124/article/details/129263888

版权

笔记专栏收录该内容

39 篇文章 1 订阅

订阅专栏

java.io.File类:

文件或文件目录路径的抽象表现形式，与平台无关。

概述

File能新建、删除、重命名文件或目录，但File不能访问文件内容本身。如果需要访问文件内容本身，则需要使用输入/输出流。

想要在Java程序中表示一个真实存在的文件或目录，那么必须有一个File对象，但是Java程序中的一个File对象，可能没有一个真实存在的文件或目录。

File对象可以作为参数传递给流的构造器。

在API中File的解释是文件和目录路径名的抽象表示形式，即File类是文件或目录的路径，而不是文件本身，因此File类不能直接访问文件内容本身，如果需要访问文件内容本身，则需要使用输入/输出流。

File类代表磁盘或网络中某个文件或目录的路径名称，如：/javase/io/叮咚.jpg
但不能直接通过File对象读取和写入数据，如果要操作数据，需要IO流。File对象好比是到水库的“路线地址”，要“存取”里面的水到你“家里”，需要“管道”。

构造方法

File类的实例化方式:

public File(String pathname):通过将给定的路径名字符串转换为抽象路径名来创建新的 File 实例。

public File(String parent, String child):从父路径名字符串和子路径名字符串创建新的 File 实例。

public File(File parent, String child):从父抽象路径名和子路径名字符串创建新的 File 实例。

 @Test
    public void test1(){
        //File类的实例化方式:
        //1.public File(String pathname):通过将给定的路径名字符串转换为抽象路径名来创建新的 File 实例。
        File file1 = new File("D:\\Application\\workspaces1");
        System.out.println(file1);
        //2.public File(String parent, String child):从父路径名字符串和子路径名字符串创建新的 File 实例。
        File file2 = new File("D:\\Application\\workspaces1","\\test\\mo");
        System.out.println(file2);
        //3.public File(File parent, String child):从父抽象路径名和子路径名字符串创建新的 File 实例。
        File file3 = new File(file2,"\\tt\\hh.text");
        System.out.println(file3);

    }

File类的获取功能

一个File对象代表硬盘中实际存在的一个文件或者目录。
无论该路径下是否存在文件或者目录，都不影响File对象的创建

File类的获取功能:
File getAbsoluteFile():返回此抽象路径名的绝对形式。等效于 new File（this.getAbsolutePath）。
String getAbsolutePath():返回此抽象路径名的绝对路径名字符串。
long getFreeSpace():返回由此抽象路径名命名的分区中未分配的字节数。
String getName():返回由此抽象路径名表示的文件或目录的名称。
String getParent():返回此抽象路径名的父级的路径名字符串，如果此路径名未命名父目录，则返回 null。
File getParentFile():返回此抽象路径名的父级的抽象路径名，如果此路径名未命名父目录，则返回 null。
String getPath():将此抽象路径名转换为路径名字符串。
long getTotalSpace():返回由此抽象路径名命名的分区的大小。
long getUsableSpace():返回此抽象路径名命名的分区上此虚拟机可用的字节数。
long lastModified():返回此抽象路径名所表示的文件上次修改的时间。
long length():返回由此抽象路径名表示的文件的长度。如果此路径名表示目录，则未指定返回值。
public String[] list():返回一个字符串数组，用于命名此抽象路径名所表示的目录中的文件和目录。
public File[] listFiles():返回一个抽象路径名数组，该数组表示此抽象路径名所表示的目录中的文件。

{
        //实例化
        File file1 = new File("D:\\es-windows\\helloworld.txt");
        //1.public File getAbsoluteFile():返回此抽象路径名的绝对形式。等效于 new File（this.getAbsolutePath）。
        File absoluteFile = file1.getAbsoluteFile();
        //2.public String getAbsolutePath():返回此抽象路径名的绝对路径名字符串。
        String absolutePath = file1.getAbsolutePath();
        System.out.println(absoluteFile);
        System.out.println(absolutePath);
        //3.public long getFreeSpace():返回由此抽象路径名命名的分区中未分配的字节数。
        System.out.println(file1.getFreeSpace());
//        4.String getName():返回由此抽象路径名表示的文件或目录的名称。
//        5.String getParent():返回此抽象路径名的父级的路径名字符串，如果此路径名未命名父目录，则返回 null。
//        6.File getParentFile():返回此抽象路径名的父级的抽象路径名，如果此路径名未命名父目录，则返回 null。
//        7.String getPath():将此抽象路径名转换为路径名字符串。
        System.out.println(file1.getName());//helloworld.txt
        System.out.println(file1.getParent());//D:\es-windows
        System.out.println(file1.getPath());//D:\es-windows\helloworld.txt
        System.out.println(file1.getParentFile());//D:\es-windows
        /*
         long getTotalSpace():返回由此抽象路径名命名的分区的大小。即当前文件所在分区的总大小(字节数)
         long getUsableSpace():返回此抽象路径名命名的分区上此虚拟机可用的字节数。即当前文件所在分区还可用容量大小(字节数)
         */
        System.out.println(file1.getTotalSpace());
        System.out.println(file1.getUsableSpace());
        /*
        long lastModified():返回此抽象路径名所表示的文件上次修改的时间。毫秒数
        long length():返回由此抽象路径名表示的文件的长度。如果此路径名表示目录，则未指定返回值。字节数
         */
        System.out.println(file1.length());//17
        long modified = file1.lastModified();
        System.out.println(modified);//1677578261068
        System.out.println(new Date(modified));//Tue Feb 28 17:57:41 CST 2023
        File file2 = new File("D:\\es-windows");
        /*
        public String[] list():返回一个字符串数组，用于命名此抽象路径名所表示的目录中的文件和目录。
    public File[] listFiles():返回一个抽象路径名数组，该数组表示此抽象路径名所表示的目录中的文件。
         */
        System.out.println("=============");
        String[] list = file2.list();
        for(String s1:list){
            System.out.println(s1);
        }
        System.out.println("=============");
        File[] files = file2.listFiles();
        for(File s2:files){
            System.out.println(s2);
        }

    }

File类的重命名功能

File类的重命名功能:
public boolean renameTo(File dest)：重命名此抽象路径名表示的文件。将当前文件名重新命名为dest文件路径所在的名字
例如:file1.renameTo(file2):
要想保证返回值为true，则必须保证file1在硬盘的对应路径下必须存在，且file2在硬盘的对应路径下不能存在。

  /**
     * File类的重命名功能:
     * public boolean renameTo(File dest)：重命名此抽象路径名表示的文件。将当前文件名重新命名为dest文件路径所在的名字
     * 例如:file1.renameTo(file2):
     * 要想保证返回值为true，则必须保证file1在硬盘的对应路径下必须存在，且file2在硬盘的对应路径下不能存在。
     */
    @Test
    public void test3(){
        File file1 = new File("abc.text");
        File file2 = new File("D:\\es-windows\\helloworld.txt");
        boolean b = file1.renameTo(file2);
        System.out.println(b);//true
    }

File类的判断功能

File类的判断功能:
boolean isDirectory():判断此抽象路径名表示的文件是否为目录。
boolean isFile():判断此抽象路径名表示的文件是否为普通文件。
boolean exists():判断此抽象路径名表示的文件或目录是否存在。
boolean canRead():判断该文件或目录是否为可读。
boolean canWrite():判断该文件或目录是否为可写。
boolean isHidden():判断该文件或目录是否为隐藏文件。

 @Test
    public void test4() {
        //当该文件是一个普通文件时
        File file1 = new File("day23.iml");
        boolean file1Directory = file1.isDirectory();
        boolean file1File = file1.isFile();
        boolean exists = file1.exists();
        boolean canRead = file1.canRead();
        boolean canWrite = file1.canWrite();
        boolean file1Hidden = file1.isHidden();
        System.out.println(file1Directory);//false
        System.out.println(file1File);//true
        System.out.println(exists);//true
        System.out.println(canRead);//true
        System.out.println(canWrite);//true
        System.out.println(file1Hidden);//false


    }

    @Test
    public void test5() {
        //当该文件是一个文件目录时
        File file1 = new File("D:\\Application");
        boolean file1Directory = file1.isDirectory();
        boolean file1File = file1.isFile();
        boolean exists = file1.exists();
        boolean canRead = file1.canRead();
        boolean canWrite = file1.canWrite();
        boolean file1Hidden = file1.isHidden();
        System.out.println(file1Directory);//true
        System.out.println(file1File);//false
        System.out.println(exists);//true
        System.out.println(canRead);//true
        System.out.println(canWrite);//true
        System.out.println(file1Hidden);//false
    }

File类的创建功能

File类的创建功能:
boolean createNewFile():创建一个新的空文件，当该文件不存在时。如果文件存在则不创建，并且返回false。
boolean mkdir():创建由此抽象路径名命名的目录。如果该目录的上层目录不存在或该目录已存在，则不创建，返回false。
boolean mkdirs():创建由此抽象路径名命名的目录，如果该目录的上层目录不存在，则创建上层目录和该目录；
如果该目录存在返回false。

/**
     * File类的创建功能:
     * boolean createNewFile():创建一个新的空文件，当该文件不存在时。如果文件存在则不创建，并且返回false。
     * boolean mkdir():创建由此抽象路径名命名的目录。如果该目录的上层目录不存在或该目录已存在，则不创建，返回false。
     * boolean mkdirs():创建由此抽象路径名命名的目录，如果该目录的上层目录不存在，则创建上层目录和该目录；
     * 如果该目录存在返回false。
     */
    @Test
    public void test6() throws IOException {
        File renren = new File("renren.text");
        //判断文件是否存在
        if (!renren.exists()) {
            boolean newFile = renren.createNewFile();
            System.out.println("创建成功");
        } else {
            System.out.println("创建失败");
        }

    }
 @Test
    public void test7() throws IOException {
        /*
        boolean mkdir():创建由此抽象路径名命名的目录。如果该目录的上层目录不存在或该目录已存在，则不创建，返回false。
        boolean mkdirs():创建由此抽象路径名命名的目录，如果该目录的上层目录不存在，则创建上层目录和该目录；
        如果该目录存在返回false。
         */
        File file = new File("D:\\javacode\\abc\\def\\ddd\\bbb", "\\aaa");
        //假设该目录的上层目录不存在
        boolean mkdir1 = file.mkdir();
        System.out.println(mkdir1);//false
        boolean mkdir2 = file.mkdirs();
        System.out.println(mkdir2);//true


        System.out.println("=======================");
        File file2 = new File("D:\\javacode\\abc\\def\\ddd\\bbb\\aaa", "\\lll");
        //假设该目录的上层目录存在,且该目录不存在
        boolean mkdir3 = file2.mkdir();
        System.out.println(mkdir3);//true


    }

注意:如果要创建的文件或目录没有写盘符路径，那么默认在当前module路径下。

File类的删除功能

File类的删除功能:
public boolean delete():删除此抽象路径名表示的文件或目录。如果此路径名表示目录，则该目录必须为空才能删除。

 /*
    File类的删除功能:
    public boolean delete():删除此抽象路径名表示的文件或目录。如果此路径名表示目录，则该目录必须为空才能删除。
     */
    @Test
    public void test8() throws IOException {
        //当前目录不为空
        File file2 = new File("D:\\javacode\\abc\\def");
        System.out.println(file2.delete());//false
        //当前目录为空
        File file3 = new File("D:\\javacode\\abc\\def\\ddd\\bbb\\aaa\\lll");
        System.out.println(file3.delete());//true
    }

IO流

IO概述

什么是IO

生活中，你肯定经历过这样的场景。当你编辑一个文本文件，忘记了ctrl+s ，可能文件就白白编辑了。当你电脑上插入一个U盘，可以把一个视频，拷贝到你的电脑硬盘里。那么数据都是在哪些设备上的呢？键盘、内存、硬盘、外接设备等等。

我们把这种数据的传输，可以看做是一种数据的流动，按照流动的方向，以内存为基准，分为输入input 和输出output ，即流向内存是输入流，流出内存的输出流。

Java中I/O操作主要是指使用java.io包下的内容，进行输入、输出操作。输入也叫做读取数据，输出也叫做作写出数据。

IO的分类

根据数据的流向分为：输入流和输出流。

输入流：把数据从其他设备上读取到内存中的流。

以InputStream,Reader结尾

输出流：把数据从内存中写出到其他设备上的流。

以OutputStream、Writer结尾

根据数据的类型分为：字节流和字符流。

字节流：以字节为单位，读写数据的流。

以InputStream和OutputStream结尾

字符流：以字符为单位，读写数据的流。

以Reader和Writer结尾

根据IO流的角色不同分为：节点流和处理流。

节点流：可以从或向一个特定的地方（节点）读写数据。如FileReader.

处理流：是对一个已存在的流进行连接和封装，通过所封装的流的功能调用实现数据读写。如BufferedReader.处理流的构造方法总是要带一个其他的流对象做参数。一个流对象经过其他流的多次包装，称为流的链接。

这种设计是装饰模式（Decorator Pattern）也称为包装模式（Wrapper Pattern），其使用一种对客户端透明的方式来动态地扩展对象的功能，它是通过继承扩展功能的替代方案之一。在现实生活中你也有很多装饰者的例子，例如：人需要各种各样的衣着，不管你穿着怎样，但是，对于你个人本质来说是不变的，充其量只是在外面加上了一些装饰，有，“遮羞的”、“保暖的”、“好看的”、“防雨的”...

常用的节点流：　

文件 FileInputStream FileOutputStrean FileReader FileWriter 文件进行处理的节点流。

字符串 StringReader StringWriter 对字符串进行处理的节点流。

数组 ByteArrayInputStream ByteArrayOutputStream CharArrayReader CharArrayWriter 对数组进行处理的节点流（对应的不再是文件，而是内存中的一个数组）。

管道 PipedInputStream、PipedOutputStream、PipedReader、PipedWriter对管道进行处理的节点流。

常用处理流：

缓冲流：BufferedInputStream、BufferedOutputStream、BufferedReader、BufferedWriter---增加缓冲功能，避免频繁读写硬盘。

转换流：InputStreamReader、OutputStreamReader---实现字节流和字符流之间的转换。

数据流：DataInputStream、DataOutputStream -提供读写Java基础数据类型功能

对象流：ObjectInputStream、ObjectOutputStream--提供直接读写Java对象功能

4大顶级抽象父类，也称基类

	字节流	字符流
输入流	字节输入流InputStream	字符输入流Reader
输出流	字节输出流OutputStream	字符输出流Writer

流的体系结构:

抽象基类节点流(也称文件流) 缓冲流(处理流的一种)

InputStream FileInputStream BufferedInputStream

OutputStream FileOutputStream BufferedOutputStream

Reader FileReader BufferedReader

Writer FileWriter BufferedWriter

在main方法和测试方法中读取的相同的文件，但是读取到的路径是不同的。

public static void main(String[] args) {//在main方法中file表示当前工程下
        File file = new File("renren.text");
        System.out.println(file.getAbsoluteFile());//D:\Application\workspaces1\test\renren.text
    }

    @Test
    public void test1() {//在单元测试方法中file表示当前module下
        File file = new File("renren.text");
        System.out.println(file.getAbsoluteFile());//D:\Application\workspaces1\test\day23\renren.text
    }

读取文件的测试代码

 /**
     * 文件是以字符存储的，图片是以字节存储的
     * 将day23下的"renren.text"文件内容读取出来，该文件必须存在，否则会报java.io.FileNotFoundException
     */
    @Test
    public void test2() {
        //1.实例化，指明要操作的文件
        File file = new File("renren.text");
        //2.通过具体的流操作文件内容
        FileReader fileReader = null;
        try {
        /*
        public class FileReader extends InputStreamReader {}
        InputStreamReader:是从字节流到字符流的桥梁：它读取字节并使用指定的字符集将它们解码为字符。
         */

            fileReader = new FileReader(file);
            //3.数据的读取
            int read = fileReader.read();//读取单个字符。字符读取，如果已到达流的末尾，则为 -1
            //判断文件内容是否读完，如果返回-1，就是文件内容读完了。
            while (read != -1) {
                read = fileReader.read();
                System.out.print((char) read);//转换为字符输出
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            //如果流不用了，必须手动关闭流
            try {
                if (fileReader != null) {
                    fileReader.close();
                }
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }

    }

/**
     * read()的重载方法:
     * int read(char cbuf[]):返回每次读入cbuf数组中的字符个数，如果已到达流的末尾，则返回-1。
     */
    @Test
    public void test3(){
        //声明一个字符输入流
        FileReader fileReader = null;
        try {
            //1.File类的实例化
            File file = new File("renren.text");
            //2.FileReader流的实例化
            fileReader = new FileReader(file);
            //3.读取文件数据
            //int read(char cbuf[]):将字符读入数组,返回每次读入cbuf数组中的字符的个数；如果已到达流的末尾，则为 -1。
            char[] cbuf = new char[10];
            int length = fileReader.read(cbuf);
            System.out.println(length);
            //判断文件内容是否读完，读取的字符数，
            //错误的写法:
//            while (length != -1) {
//                //将每次读取到数组中的所有字符遍历出来
//                for (int i = 0; i < cbuf.length; i++) {//这里的循环条件cbuf.length是错误的
//                    System.out.print(cbuf[i]);//abcdefghijklmnopqrstuvwxyzqrst，文件本身内容是26个小写字母，现在输出的与实际不符；
//                    原因是每次读取的字符个数是固定的10个，当第三次读取的字符个数也是10个，但是文件中只有6个，这里的过程:文件中读取的6个字符替换掉第三次读取的前6个字符，后面的6个字符不变。
//                }
//               length = fileReader.read(cbuf);
//
//            }
            //正确的写法:
            while (length != -1) {
                for (int i = 0; i < length; i++) {
                    System.out.print(cbuf[i]);//abcdefghijklmnopqrstuvwxyz
                }
                length = fileReader.read(cbuf);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            //4.关闭流
            if (fileReader != null) {
                try {
                    fileReader.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }

写出文件的测试代码

 /*
    从内存中写出数据到硬盘文件中。
    说明:
    1.如果硬盘中不存在该文件，并不会报异常。
    2.
    File对应的硬盘中的文件如果不存在，在输出的过程中，会自动创建此文件。
    File对应的硬盘中的文件如果存在:
            如果流使用的构造器是FileWriter(file, false)/FileWriter(file):对文件实行的是文件的覆盖操作。
            如果流使用的构造器是FileWriter(file, true):在文件的末尾实行添加操作。
     */
    @Test
    public void test4()  {
        FileWriter fileWriter=null;
        try {
            //1.提供File的实例对象，指明写出的文件
            File file = new File("Hello.java");
            //2.创建写出流的对象，并将File实例作为参数传给流对象，指明流要操作的是哪个文件
           fileWriter = new FileWriter(file,true);
            //3.流的写出操作
            fileWriter.write("I have a dream.\n");
            fileWriter.write("I have 100 yuan.");
        } catch (IOException e) {
            throw new RuntimeException(e);
        }finally {
        //4.关闭流
            if (fileWriter!=null) {
                try {
                    fileWriter.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }

文件的复制操作测试代码

   /*
    文件的复制操作:
    第一步:将硬盘中的文件1数据读取到内存中
    第二部:将读取到内存中的数据写出到硬盘的文件2中。
     */
    @Test
    public void test5() {
        FileReader fileReader = null;
        FileWriter fileWriter = null;
        try {
            //1.创建File类对象，指明要读取的文件和要写出的文件
            File file1 = new File("Hello.java");
            File file2 = new File("Hello2.java");
  //不能使用字符流来处理图片等字节存储的数据
//            File file1 = new File("u=3354826066,550726194&fm=253&fmt=auto&app=138&f=JPEG.jpg");
//            File file2 = new File("EG.jpg");
            //2.创建输入流和输出流对象
            fileReader = new FileReader(file1);
            fileWriter = new FileWriter(file2);
            //3.数据的读取操作和写出操作
            char[] cbuf = new char[6];
            int len = fileReader.read(cbuf);//记录每次读取到cbuf数组中的字符个数

            while (len != -1) {
                    //每次写出len个字符
                    fileWriter.write(cbuf,0,len);
                    len = fileReader.read(cbuf);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            //4.输入流和输出流的关闭；流的关闭规则:先开启的后关闭，后开启的先关闭
            if (fileWriter != null) {
                try {
                    fileWriter.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            if (fileReader != null) {
                try {
                    fileReader.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }

注意:不能使用字符流来处理图片等字节存储的数据

图片的复制操作测试代码

   /*
 图片的复制操作:图片是以字节形式存储的
 第一步:将硬盘中的图片1数据读取到内存中
 第二部:将读取到内存中的数据写出到硬盘的图片2中。
 public int read(byte b[]):返回每次读入b数组中的字节个数，如果已到达流的末尾，则为 -1。
  */
    @Test
    public void test1() {
        FileInputStream inputStream = null;
        FileOutputStream outputStream = null;
        try {
            //1.创建File类对象，指明要读取的图片和写出的图片
            File file1 = new File("hh.jpg");
            File file2 = new File("gg.jpg");
            //2.创建字节输入流和输出流对象，指明要操作的是哪个图片的数据
            inputStream = new FileInputStream(file1);
            outputStream = new FileOutputStream(file2);
            //3.图片的读取操作和写出操作
            byte[] b = new byte[50];//每次读取的最大字节个数
            //public int read(byte b[]):返回每次读入b数组中的字节个数，如果已到达流的末尾，则为 -1。
            int len;//返回每次读入b数组中的字节个数
            while ((len = inputStream.read(b)) != -1) {
                    //写出操作
                    outputStream.write(b, 0, len);

            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            //4.关闭流
            if (outputStream != null) {
                try {
                    outputStream.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            if (inputStream != null) {
                try {
                    inputStream.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }

总结:

对于文本文件(.txt,.java,.c),使用字符流处理。

对于非文本文件(.jpg,.mp3,.mp4)，使用字节流处理

流的关闭规则:先开启的后关闭，后开启的先关闭

字节流

一切皆为字节

一切文件数据(文本、图片、视频等)在存储时，都是以二进制数字的形式保存，都一个一个的字节，那么传输时一样如此。所以，字节流可以传输任意文件数据。在操作流的时候，我们要时刻明确，无论使用什么样的流对象，底层传输的始终为二进制数据。

字节输出流【OutputStream】

java.io.OutputStream抽象类是表示字节输出流的所有类的超类，将指定的字节信息写出到目的地。它定义了字节输出流的基本共性功能方法。

public void close() ：关闭此输出流并释放与此流相关联的任何系统资源。

public void flush() ：刷新此输出流并强制任何缓冲的输出字节被写出。

public void write(byte[] b)：将 b.length字节从指定的字节数组写入此输出流。

public void write(byte[] b, int off, int len) ：从指定的字节数组写入 len字节，从偏移量 off开始输出到此输出流。

public abstract void write(int b) ：将指定的字节输出流。

小贴士：
close方法，当完成流的操作时，必须调用此方法，释放系统资源。

FileOutputStream类

OutputStream有很多子类，我们从最简单的一个子类开始。

java.io.FileOutputStream类是文件输出流，用于将数据写出到文件。

构造方法

public FileOutputStream(File file)：创建文件输出流以写入由指定的 File对象表示的文件。

public FileOutputStream(String name)：创建文件输出流以指定的名称写入文件。

当你创建一个流对象时，必须传入一个文件路径。该路径下，如果没有这个文件，会创建该文件。如果有这个文件，会清空这个文件的数据。

构造举例，代码如下：

public class FileOutputStreamConstructor throws IOException {
    public static void main(String[] args) {
            // 使用File对象创建流对象
        File file = new File("a.txt");
        FileOutputStream fos = new FileOutputStream(file);
      
        // 使用文件名称创建流对象
        FileOutputStream fos = new FileOutputStream("b.txt");
    }
}

写出字节数据

写出字节：write(int b) 方法，每次可以写出一个字节数据，代码使用演示：

public class FOSWrite {
    public static void main(String[] args) throws IOException {
        // 使用文件名称创建流对象
        FileOutputStream fos = new FileOutputStream("fos.txt");     
          // 写出数据
          fos.write(97); // 写出第1个字节
          fos.write(98); // 写出第2个字节
          fos.write(99); // 写出第3个字节
          // 关闭资源
        fos.close();
    }
}
输出结果：
abc

小贴士：
虽然参数为int类型四个字节，但是只会保留一个字节的信息写出。
流操作完毕后，必须释放系统资源，调用close方法，千万记得。

写出字节数组：write(byte[] b)，每次可以写出数组中的数据，代码使用演示：

public class FOSWrite {
    public static void main(String[] args) throws IOException {
        // 使用文件名称创建流对象
        FileOutputStream fos = new FileOutputStream("fos.txt");     
          // 字符串转换为字节数组
          byte[] b = "尚硅谷".getBytes();
          // 写出字节数组数据
          fos.write(b);
          // 关闭资源
        fos.close();
    }
}
输出结果：
尚硅谷

写出指定长度字节数组：write(byte[] b, int off, int len) ,每次写出从off索引开始，len个字节，代码使用演示：

public class FOSWrite {
    public static void main(String[] args) throws IOException {
        // 使用文件名称创建流对象
        FileOutputStream fos = new FileOutputStream("fos.txt");     
          // 字符串转换为字节数组
          byte[] b = "abcde".getBytes();
        // 写出从索引2开始，2个字节。索引2是c，两个字节，也就是cd。
        fos.write(b,2,2);
          // 关闭资源
        fos.close();
    }
}
输出结果：
cd

数据追加续写

经过以上的演示，每次程序运行，创建输出流对象，都会清空目标文件中的数据。如何保留目标文件中数据，还能继续添加新数据呢？

public FileOutputStream(File file, boolean append)：创建文件输出流以写入由指定的 File对象表示的文件。

public FileOutputStream(String name, boolean append)：创建文件输出流以指定的名称写入文件。

这两个构造方法，参数中都需要传入一个boolean类型的值，true 表示追加数据，false 表示清空原有数据。这样创建的输出流对象，就可以指定是否追加续写了，代码使用演示：

public class FOSWrite {
    public static void main(String[] args) throws IOException {
        // 使用文件名称创建流对象
        FileOutputStream fos = new FileOutputStream("fos.txt"，true);     
          // 字符串转换为字节数组
          byte[] b = "abcde".getBytes();
        // 写出从索引2开始，2个字节。索引2是c，两个字节，也就是cd。
        fos.write(b);
          // 关闭资源
        fos.close();
    }
}
文件操作前：cd
文件操作后：cdabcde

写出换行

Windows系统里，换行符号是\r\n 。把

以指定是否追加续写了，代码使用演示：

public class FOSWrite {
    public static void main(String[] args) throws IOException {
        // 使用文件名称创建流对象
        FileOutputStream fos = new FileOutputStream("fos.txt");  
          // 定义字节数组
          byte[] words = {97,98,99,100,101};
          // 遍历数组
        for (int i = 0; i < words.length; i++) {
              // 写出一个字节
            fos.write(words[i]);
              // 写出一个换行, 换行符号转成数组写出
            fos.write("\r\n".getBytes());
        }
          // 关闭资源
        fos.close();
    }
}

输出结果：
a
b
c
d
e

回车符\r和换行符\n ：
回车符：回到一行的开头（return）。
换行符：下一行（newline）。
系统中的换行：
Windows系统里，每行结尾是回车+换行，即\r\n；
Unix系统里，每行结尾只有换行，即\n；
Mac系统里，每行结尾是回车，即\r。从 Mac OS X开始与Linux统一。

字节输入流【InputStream】

java.io.InputStream抽象类是表示字节输入流的所有类的超类，可以读取字节信息到内存中。它定义了字节输入流的基本共性功能方法。

public void close() ：关闭此输入流并释放与此流相关联的任何系统资源。

public abstract int read()：从输入流读取数据的下一个字节。

public int read(byte[] b)：从输入流中读取一些字节数，并将它们存储到字节数组 b中。

小贴士：
close方法，当完成流的操作时，必须调用此方法，释放系统资源。

FileInputStream类

java.io.FileInputStream类是文件输入流，从文件中读取字节。

构造方法

FileInputStream(File file)：通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的 File对象 file命名。

FileInputStream(String name)：通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的路径名 name命名。

当你创建一个流对象时，必须传入一个文件路径。该路径下，如果没有该文件,会抛出FileNotFoundException 。

构造举例，代码如下：

public class FileInputStreamConstructor throws IOException{
    public static void main(String[] args) {
            // 使用File对象创建流对象
        File file = new File("a.txt");
        FileInputStream fis = new FileInputStream(file);
      
        // 使用文件名称创建流对象
        FileInputStream fis = new FileInputStream("b.txt");
    }
}

读取字节数据

读取字节：read方法，每次可以读取一个字节的数据，提升为int类型，读取到文件末尾，返回-1，代码使用演示：

public class FISRead {
    public static void main(String[] args) throws IOException{
          // 使用文件名称创建流对象
           FileInputStream fis = new FileInputStream("read.txt");
          // 读取数据，返回一个字节
        int read = fis.read();
        System.out.println((char) read);
        read = fis.read();
        System.out.println((char) read);
        read = fis.read();
        System.out.println((char) read);
        read = fis.read();
        System.out.println((char) read);
        read = fis.read();
        System.out.println((char) read);
          // 读取到末尾,返回-1
           read = fis.read();
        System.out.println( read);
        // 关闭资源
        fis.close();
    }
}
输出结果：
a
b
c
d
e
-1

循环改进读取方式，代码使用演示：

public class FISRead {
    public static void main(String[] args) throws IOException{
          // 使用文件名称创建流对象
           FileInputStream fis = new FileInputStream("read.txt");
          // 定义变量，保存数据
        int b ；
        // 循环读取
        while ((b = fis.read())!=-1) {
            System.out.println((char)b);
        }
        // 关闭资源
        fis.close();
    }
}
输出结果：
a
b
c
d
e

小贴士：
虽然读取了一个字节，但是会自动提升为int类型。
流操作完毕后，必须释放系统资源，调用close方法，千万记得。

使用字节数组读取：read(byte[] b)，每次读取b的长度个字节到数组中，返回读取到的有效字节个数，读取到末尾时，返回-1 ，代码使用演示：

public class FISRead {
    public static void main(String[] args) throws IOException{
          // 使用文件名称创建流对象.
           FileInputStream fis = new FileInputStream("read.txt"); // 文件中为abcde
          // 定义变量，作为有效个数
        int len ；
        // 定义字节数组，作为装字节数据的容器   
        byte[] b = new byte[2];
        // 循环读取
        while (( len= fis.read(b))!=-1) {
               // 每次读取后,把数组变成字符串打印
            System.out.println(new String(b));
        }
        // 关闭资源
        fis.close();
    }
}

输出结果：
ab
cd
ed

错误数据d，是由于最后一次读取时，只读取一个字节e，数组中，上次读取的数据没有被完全替换，所以要通过len ，获取有效的字节，代码使用演示：

public class FISRead {
    public static void main(String[] args) throws IOException{
          // 使用文件名称创建流对象.
           FileInputStream fis = new FileInputStream("read.txt"); // 文件中为abcde
          // 定义变量，作为有效个数
        int len ；
        // 定义字节数组，作为装字节数据的容器   
        byte[] b = new byte[2];
        // 循环读取
        while (( len= fis.read(b))!=-1) {
               // 每次读取后,把数组的有效字节部分，变成字符串打印
            System.out.println(new String(b，0，len));//  len 每次读取的有效字节个数
        }
        // 关闭资源
        fis.close();
    }
}

输出结果：
ab
cd
e

小贴士：
使用数组读取，每次读取多个字节，减少了系统间的IO操作次数，从而提高了读写的效率，建议开发中使用。

字符流

当使用字节流读取文本文件时，可能会有一个小问题。就是遇到中文字符时，可能不会显示完整的字符，那是因为一个中文字符可能占用多个字节存储。所以Java提供一些字符流类，以字符为单位读写数据，专门用于处理文本文件。

字符输入流【Reader】

java.io.Reader抽象类是表示用于读取字符流的所有类的超类，可以读取字符信息到内存中。它定义了字符输入流的基本共性功能方法。

public void close() ：关闭此流并释放与此流相关联的任何系统资源。

public int read()：从输入流读取一个字符。

public int read(char[] cbuf)：从输入流中读取一些字符，并将它们存储到字符数组 cbuf中。

FileReader类

java.io.FileReader类是读取字符文件的便利类。构造时使用系统默认的字符编码和默认字节缓冲区。

小贴士：
字符编码：字节与字符的对应规则。Windows系统的中文编码默认是GBK编码表。
eclipse中默认GBK，idea中默认UTF-8
字节缓冲区：一个字节数组，用来临时存储字节数据。

构造方法

FileReader(File file)：创建一个新的 FileReader ，给定要读取的File对象。

FileReader(String fileName)：创建一个新的 FileReader ，给定要读取的文件的名称。

当你创建一个流对象时，必须传入一个文件路径。类似于FileInputStream 。

构造举例，代码如下：

public class FileReaderConstructor throws IOException{
    public static void main(String[] args) {
            // 使用File对象创建流对象
        File file = new File("a.txt");
        FileReader fr = new FileReader(file);
      
        // 使用文件名称创建流对象
        FileReader fr = new FileReader("b.txt");
    }
}

读取字符数据

读取字符：read方法，每次可以读取一个字符的数据，提升为int类型，读取到文件末尾，返回-1，循环读取，代码使用演示：

public class FRRead {
    public static void main(String[] args) throws IOException {
          // 使用文件名称创建流对象
           FileReader fr = new FileReader("read.txt");
          // 定义变量，保存数据
        int b ；
        // 循环读取
        while ((b = fr.read())!=-1) {
            System.out.println((char)b);
        }
        // 关闭资源
        fr.close();
    }
}
输出结果：
尚
硅
谷

小贴士：虽然读取了一个字符，但是会自动提升为int类型。

使用字符数组读取：read(char[] cbuf)，每次读取b的长度个字符到数组中，返回读取到的有效字符个数，读取到末尾时，返回-1 ，代码使用演示：

public class FRRead {
    public static void main(String[] args) throws IOException {
          // 使用文件名称创建流对象
           FileReader fr = new FileReader("read.txt");
          // 定义变量，保存有效字符个数
        int len ；
        // 定义字符数组，作为装字符数据的容器
         char[] cbuf = new char[2];
        // 循环读取
        while ((len = fr.read(cbuf))!=-1) {
            System.out.println(new String(cbuf));
        }
        // 关闭资源
        fr.close();
    }
}
输出结果：
尚硅
谷硅

获取有效的字符改进，代码使用演示：

public class FISRead {
    public static void main(String[] args) throws IOException {
          // 使用文件名称创建流对象
           FileReader fr = new FileReader("read.txt");
          // 定义变量，保存有效字符个数
        int len ；
        // 定义字符数组，作为装字符数据的容器
        char[] cbuf = new char[2];
        // 循环读取
        while ((len = fr.read(cbuf))!=-1) {
            System.out.println(new String(cbuf,0,len));
        }
        // 关闭资源
        fr.close();
    }
}

输出结果：
尚硅
谷

字符输出流【Writer】

java.io.Writer抽象类是表示用于写出字符流的所有类的超类，将指定的字符信息写出到目的地。它定义了字节输出流的基本共性功能方法。

void write(int c) 写入单个字符。

void write(char[] cbuf)写入字符数组。

abstract void write(char[] cbuf, int off, int len)写入字符数组的某一部分,off数组的开始索引,len写的字符个数。

void write(String str)写入字符串。

void write(String str, int off, int len) 写入字符串的某一部分,off字符串的开始索引,len写的字符个数。

void flush()刷新该流的缓冲。

void close() 关闭此流，但要先刷新它。

FileWriter类

java.io.FileWriter类是写出字符到文件的便利类。构造时使用系统默认的字符编码和默认字节缓冲区。

构造方法

FileWriter(File file)：创建一个新的 FileWriter，给定要读取的File对象。

FileWriter(String fileName)：创建一个新的 FileWriter，给定要读取的文件的名称。

当你创建一个流对象时，必须传入一个文件路径，类似于FileOutputStream。

构造举例，代码如下：

public class FileWriterConstructor {
    public static void main(String[] args) throws IOException {
            // 使用File对象创建流对象
        File file = new File("a.txt");
        FileWriter fw = new FileWriter(file);
      
        // 使用文件名称创建流对象
        FileWriter fw = new FileWriter("b.txt");
    }
}

本写出数据

写出字符：write(int b) 方法，每次可以写出一个字符数据，代码使用演示：

public class FWWrite {
    public static void main(String[] args) throws IOException {
        // 使用文件名称创建流对象
        FileWriter fw = new FileWriter("fw.txt");     
          // 写出数据
          fw.write(97); // 写出第1个字符
          fw.write('b'); // 写出第2个字符
          fw.write('C'); // 写出第3个字符
          fw.write(30000); // 写出第4个字符，中文编码表中30000对应一个汉字。
      
          /*
        【注意】关闭资源时,与FileOutputStream不同。
           如果不关闭,数据只是保存到缓冲区，并未保存到文件。
        */
        // fw.close();
    }
}
输出结果：
abC田

小贴士：
虽然参数为int类型四个字节，但是只会保留一个字符的信息写出。
未调用close方法，数据只是保存到了缓冲区，并未写出到文件中。

关闭和刷新

因为内置缓冲区的原因，如果不关闭输出流，无法写出字符到文件中。但是关闭的流对象，是无法继续写出数据的。如果我们既想写出数据，又想继续使用流，就需要flush 方法了。

flush ：刷新缓冲区，流对象可以继续使用。

close:先刷新缓冲区，然后通知系统释放资源。流对象不可以再被使用了。

代码使用演示：

public class FWWrite {
    public static void main(String[] args) throws IOException {
        // 使用文件名称创建流对象
        FileWriter fw = new FileWriter("fw.txt");
        // 写出数据，通过flush
        fw.write('刷'); // 写出第1个字符
        fw.flush();
        fw.write('新'); // 继续写出第2个字符，写出成功
        fw.flush();
      
          // 写出数据，通过close
        fw.write('关'); // 写出第1个字符
        fw.close();
        fw.write('闭'); // 继续写出第2个字符,【报错】java.io.IOException: Stream closed
        fw.close();
    }
}

小贴士：即便是flush方法写出了数据，操作的最后还是要调用close方法，释放系统资源。

写出其他数据

写出字符数组：write(char[] cbuf) 和 write(char[] cbuf, int off, int len) ，每次可以写出字符数组中的数据，用法类似FileOutputStream，代码使用演示：

public class FWWrite {
    public static void main(String[] args) throws IOException {
        // 使用文件名称创建流对象
        FileWriter fw = new FileWriter("fw.txt");     
          // 字符串转换为字节数组
          char[] chars = "尚硅谷".toCharArray();
      
          // 写出字符数组
          fw.write(chars); // 尚硅谷
        
        // 写出从索引1开始，2个字节。索引1是'硅'，两个字节，也就是'硅谷'。
        fw.write(b,1,2); // 硅谷
      
          // 关闭资源
        fos.close();
    }
}

写出字符串：write(String str) 和 write(String str, int off, int len) ，每次可以写出字符串中的数据，更为方便，代码使用演示：

public class FWWrite {
    public static void main(String[] args) throws IOException {
        // 使用文件名称创建流对象
        FileWriter fw = new FileWriter("fw.txt");     
          // 字符串
          String msg = "尚硅谷";
      
          // 写出字符数组
          fw.write(msg); //尚硅谷
      
        // 写出从索引1开始，2个字节。索引1是'硅'，两个字节，也就是'硅谷'。
        fw.write(msg,1,2);    // 尚硅谷
          
        // 关闭资源
        fos.close();
    }
}

续写和换行：操作类似于FileOutputStream。

public class FWWrite {
    public static void main(String[] args) throws IOException {
        // 使用文件名称创建流对象，可以续写数据
        FileWriter fw = new FileWriter("fw.txt"，true);     
          // 写出字符串
        fw.write("尚");
          // 写出换行
          fw.write("\r\n");
          // 写出字符串
          fw.write("硅谷");
          // 关闭资源
        fw.close();
    }
}
输出结果:
尚
硅谷

小贴士：字符流，只能操作文本文件，不能操作图片，视频等非文本文件。
当我们单纯读或者写文本文件时使用字符流其他情况使用字节流

缓冲流

缓冲流,也叫高效流，按照数据类型分类：

字节缓冲流：BufferedInputStream，BufferedOutputStream

字符缓冲流：BufferedReader，BufferedWriter

缓冲流的基本原理，是在创建流对象时，会创建一个内置的默认大小的缓冲区数组，通过缓冲区读写，减少系统IO次数，从而提高读写的效率。

字节缓冲流

构造方法

public BufferedInputStream(InputStream in) ：创建一个新的缓冲输入流。

public BufferedOutputStream(OutputStream out)：创建一个新的缓冲输出流。

构造举例，代码如下：

// 创建字节缓冲输入流
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("bis.txt"));
// 创建字节缓冲输出流
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("bos.txt"));

效率测试

查询API，缓冲流读写方法与基本的流是一致的，我们通过复制大文件（375MB），测试它的效率。

基本流，代码如下：

public class BufferedDemo {
    public static void main(String[] args) throws IOException {
        // 记录开始时间
          long start = System.currentTimeMillis();
        // 创建流对象
        FileInputStream fis = new FileInputStream("jdk9.exe");
        FileOutputStream fos = new FileOutputStream("copy.exe");
            // 读写数据
        int b;
        while ((b = fis.read()) != -1) {
                fos.write(b);
        }
        
        fos.close();
        fis.close();
        
        // 记录结束时间
        long end = System.currentTimeMillis();
        System.out.println("普通流复制时间:"+(end - start)+" 毫秒");
    }
}

十几分钟过去了...

缓冲流，代码如下：

public class BufferedDemo {
    public static void main(String[] args) throws IOException {
        // 记录开始时间
          long start = System.currentTimeMillis();
        // 创建流对象
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("jdk9.exe"));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("copy.exe"));
        // 读写数据
        int b;
        while ((b = bis.read()) != -1) {
            bos.write(b);
        }
        
        bos.close();
        bis.close();
        
        // 记录结束时间
        long end = System.currentTimeMillis();
        System.out.println("缓冲流复制时间:"+(end - start)+" 毫秒");
    }
}

缓冲流复制时间:8016 毫秒

如何更快呢？

使用数组的方式，代码如下：

public class BufferedDemo {
    public static void main(String[] args) throws IOException {
          // 记录开始时间
        long start = System.currentTimeMillis();
        // 创建流对象
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("jdk9.exe"));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("copy.exe"));
              // 读写数据
        int len;
        byte[] bytes = new byte[8*1024];
        while ((len = bis.read(bytes)) != -1) {
            bos.write(bytes, 0 , len);
        }
        
        bos.close();
        bis.close();
        // 记录结束时间
        long end = System.currentTimeMillis();
        System.out.println("缓冲流使用数组复制时间:"+(end - start)+" 毫秒");
    }
}
缓冲流使用数组复制时间:666 毫秒

字符缓冲流

构造方法

public BufferedReader(Reader in) ：创建一个新的缓冲输入流。

public BufferedWriter(Writer out)：创建一个新的缓冲输出流。

构造举例，代码如下：

// 创建字符缓冲输入流
BufferedReader br = new BufferedReader(new FileReader("br.txt"));
// 创建字符缓冲输出流
BufferedWriter bw = new BufferedWriter(new FileWriter("bw.txt"));

特有方法

字符缓冲流的基本方法与普通字符流调用方式一致，不再阐述，我们来看它们具备的特有方法。

BufferedReader：public String readLine(): 读一行文字。

BufferedWriter：public void newLine(): 写一行行分隔符,由系统属性定义符号。

readLine方法演示，代码如下：

public class BufferedReaderDemo {
    public static void main(String[] args) throws IOException {
           // 创建流对象
        BufferedReader br = new BufferedReader(new FileReader("in.txt"));
        // 定义字符串,保存读取的一行文字
        String line  = null;
          // 循环读取,读取到最后返回null
        while ((line = br.readLine())!=null) {
            System.out.print(line);
            System.out.println("------");
        }
        // 释放资源
        br.close();
    }
}

newLine方法演示，代码如下：

public class BufferedWriterDemo throws IOException {
    public static void main(String[] args) throws IOException  {
          // 创建流对象
        BufferedWriter bw = new BufferedWriter(new FileWriter("out.txt"));
          // 写出数据
        bw.write("尚");
          // 写出换行
        bw.newLine();
        bw.write("硅");
        bw.newLine();
        bw.write("谷");
        bw.newLine();
        // 释放资源
        bw.close();
    }
}
输出效果:
尚
硅
谷

转换流

字符编码和字符集

字符编码

计算机中储存的信息都是用二进制数表示的，而我们在屏幕上看到的数字、英文、标点符号、汉字等字符是二进制数转换之后的结果。按照某种规则，将字符存储到计算机中，称为编码。反之，将存储在计算机中的二进制数按照某种规则解析显示出来，称为解码。比如说，按照A规则存储，同样按照A规则解析，那么就能显示正确的文本符号。反之，按照A规则存储，再按照B规则解析，就会导致乱码现象。

编码:字符(能看懂的)--字节(看不懂的)

解码:字节(看不懂的)-->字符(能看懂的)

字符编码Character Encoding : 就是一套自然语言的字符与二进制数之间的对应规则。

编码表:生活中文字和计算机中二进制的对应规则

字符集

字符集 Charset：也叫编码表。是一个系统支持的所有字符的集合，包括各国家文字、标点符号、图形符号、数字等。

计算机要准确的存储和识别各种字符集符号，需要进行字符编码，一套字符集必然至少有一套字符编码。常见字符集有ASCII字符集、GBK字符集、Unicode字符集等。

可见，当指定了编码，它所对应的字符集自然就指定了，所以编码才是我们最终要关心的。

ASCII字符集：

ASCII（American Standard Code for Information Interchange，美国信息交换标准代码）是基于拉丁字母的一套电脑编码系统，用于显示现代英语，主要包括控制字符（回车键、退格、换行键等）和可显示字符（英文大小写字符、阿拉伯数字和西文符号）。

基本的ASCII字符集，使用7位（bits）表示一个字符，共128字符。

ASCII的扩展字符集使用8位（bits）表示一个字符，共256字符，方便支持欧洲常用字符。

ISO-8859-1字符集：

拉丁码表，别名Latin-1，用于显示欧洲使用的语言，包括荷兰、丹麦、德语、意大利语、西班牙语等。

ISO-8859-1使用单字节编码，兼容ASCII编码。

GBxxx字符集：

GB就是国标的意思，是为了显示中文而设计的一套字符集。

GB2312：简体中文码表。一个小于127的字符的意义与原来相同。但两个大于127的字符连在一起时，就表示一个汉字，这样大约可以组合了包含7000多个简体汉字，此外数学符号、罗马希腊的字母、日文的假名们都编进去了，连在ASCII里本来就有的数字、标点、字母都统统重新编了两个字节长的编码，这就是常说的"全角"字符，而原来在127号以下的那些就叫"半角"字符了。

GBK：最常用的中文码表。是在GB2312标准基础上的扩展规范，使用了双字节编码方案，共收录了21003个汉字，完全兼容GB2312标准，同时支持繁体汉字以及日韩汉字等。

GB18030：最新的中文码表。收录汉字70244个，采用多字节编码，每个字可以由1个、2个或4个字节组成。支持中国国内少数民族的文字，同时支持繁体汉字以及日韩汉字等。

Unicode字符集：

Unicode编码系统为表达任意语言的任意字符而设计，是业界的一种标准，也称为统一码、标准万国码。

它最多使用4个字节的数字来表达每个字母、符号，或者文字。有三种编码方案，UTF-8、UTF-16和UTF-32。最为常用的UTF-8编码。

UTF-8编码，可以用来表示Unicode标准中任何字符，它是电子邮件、网页及其他存储或传送文字的应用中，优先采用的编码。互联网工程工作小组（IETF）要求所有互联网协议都必须支持UTF-8编码。所以，我们开发Web应用，也要使用UTF-8编码。它使用一至四个字节为每个字符编码，编码规则：

128个US-ASCII字符，只需一个字节编码。

拉丁文等字符，需要二个字节编码。

大部分常用字（含中文），使用三个字节编码。

其他极少使用的Unicode辅助字符，使用四字节编码。

编码引出的问题

在Eclipse中，使用FileReader 读取项目中的文本文件。由于Eclipse的设置UTF-8编码但是，当读取Windows系统中创建的文本文件时，由于Windows系统的默认是GBK编码，就会出现乱码。

public class ReaderDemo {
    public static void main(String[] args) throws IOException {
        FileReader fileReader = new FileReader("E:\\File_GBK.txt");
        int read;
        while ((read = fileReader.read()) != -1) {
            System.out.print((char)read);
        }
        fileReader.close();
    }
}
输出结果：
���

那么如何读取GBK编码的文件呢？

InputStreamReader类

转换流java.io.InputStreamReader，是Reader的子类，是从字节流到字符流的桥梁。它读取字节，并使用指定的字符集将其解码为字符。它的字符集可以由名称指定，也可以接受平台的默认字符集。

构造方法

InputStreamReader(InputStream in): 创建一个使用默认字符集的字符流。

InputStreamReader(InputStream in, String charsetName): 创建一个指定字符集的字符流。

构造举例，代码如下：

InputStreamReader isr = new InputStreamReader(new FileInputStream("in.txt"));
InputStreamReader isr2 = new InputStreamReader(new FileInputStream("in.txt") , "GBK");

指定编码读取

public class ReaderDemo2 {
    public static void main(String[] args) throws IOException {
          // 定义文件路径,文件为gbk编码
        String FileName = "E:\\file_gbk.txt";
          // 创建流对象,默认UTF8编码
        InputStreamReader isr = new InputStreamReader(new FileInputStream(FileName));
          // 创建流对象,指定GBK编码
        InputStreamReader isr2 = new InputStreamReader(new FileInputStream(FileName) , "GBK");
        // 定义变量,保存字符
        int read;
          // 使用默认编码字符流读取,乱码
        while ((read = isr.read()) != -1) {
            System.out.print((char)read); // ��Һ�
        }
        isr.close();
      
          // 使用指定编码字符流读取,正常解析
        while ((read = isr2.read()) != -1) {
            System.out.print((char)read);// 大家好
        }
        isr2.close();
    }
}

OutputStreamWriter类

转换流java.io.OutputStreamWriter ，是Writer的子类，是从字符流到字节流的桥梁。使用指定的字符集将字符编码为字节。它的字符集可以由名称指定，也可以接受平台的默认字符集。

构造方法

OutputStreamWriter(OutputStream in): 创建一个使用默认字符集的字符流。

OutputStreamWriter(OutputStream in, String charsetName): 创建一个指定字符集的字符流。

构造举例，代码如下：

OutputStreamWriter isr = new OutputStreamWriter(new FileOutputStream("out.txt"));
OutputStreamWriter isr2 = new OutputStreamWriter(new FileOutputStream("out.txt") , "GBK");

指定编码写出

public class OutputDemo {
    public static void main(String[] args) throws IOException {
          // 定义文件路径
        String FileName = "E:\\out.txt";
          // 创建流对象,默认UTF8编码
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(FileName));
        // 写出数据
          osw.write("你好"); // 保存为6个字节
        osw.close();
          
        // 定义文件路径
        String FileName2 = "E:\\out2.txt";
         // 创建流对象,指定GBK编码
        OutputStreamWriter osw2 = new OutputStreamWriter(new FileOutputStream(FileName2),"GBK");
        // 写出数据
          osw2.write("你好");// 保存为4个字节
        osw2.close();
    }
}

转换流理解图解

转换流是字节与字符间的桥梁！

转换文件编码

将GBK编码的文本文件，转换为UTF-8编码的文本文件。

案例分析

指定GBK编码的转换流，读取文本文件。

使用UTF-8编码的转换流，写出文本文件。

案例实现

public class TransDemo {
   public static void main(String[] args) {      
        // 1.定义文件路径
         String srcFile = "file_gbk.txt";
        String destFile = "file_utf8.txt";
        // 2.创建流对象
        // 2.1 转换输入流,指定GBK编码
        InputStreamReader isr = new InputStreamReader(new FileInputStream(srcFile) , "GBK");
        // 2.2 转换输出流,默认utf8编码
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(destFile));
        // 3.读写数据
        // 3.1 定义数组
        char[] cbuf = new char[1024];
        // 3.2 定义长度
        int len;
        // 3.3 循环读取
        while ((len = isr.read(cbuf))!=-1) {
            // 循环写出
              osw.write(cbuf,0,len);
        }
        // 4.释放资源
        osw.close();
        isr.close();
      }
}

数据流

前面学习的IO流，在程序代码中，要么将数据直接按照字节处理，要么按照字符处理。那么，如果要在程序中直接处理Java的基础数据类型，怎么办呢？

String name = “巫师”;
int age = 300;
char gender = ‘男’;
int energy = 5000;
double price = 75.5;
boolean relive = true;

完成这个需求，可以使用DataOutputStream进行写，随后用DataInputStream进行读取，而且顺序要一致。

示例代码

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

public class TestData {
    public void save() throws IOException{
        String name = "巫师";
        int age = 300;
        char gender = '男';
        int energy = 5000;
        double price = 75.5;
        boolean relive = true;
        
        DataOutputStream dos = new DataOutputStream(new FileOutputStream("game.dat"));
        dos.writeUTF(name);
        dos.writeInt(age);
        dos.writeChar(gender);
        dos.writeInt(energy);
        dos.writeDouble(price);
        dos.writeBoolean(relive);
        dos.close();
    }    
    public void reload()throws IOException{
        DataInputStream dis = new DataInputStream(new FileInputStream("game.dat"));
        String name = dis.readUTF();
        int age = dis.readInt();
        char gender = dis.readChar();
        int energy = dis.readInt();
        double price = dis.readDouble();
        boolean relive = dis.readBoolean();
        
        System.out.println(name+"," + age + "," + gender + "," + energy + "," + price + "," + relive);
        
        dis.close();
    }
}

重新认识PrintStream和Scanner、System.in和out

PrintStream类

平时我们在控制台打印输出，是调用print方法和println方法完成的，这两个方法都来自于java.io.PrintStream类，该类能够方便地打印各种数据类型的值，是一种便捷的输出方式。

构造方法

public PrintStream(String fileName)：使用指定的文件名创建一个新的打印流。

构造举例，代码如下：

PrintStream ps = new PrintStream("ps.txt")；

改变打印流向

System.out就是PrintStream类型的，只不过它的流向是系统规定的，打印在控制台上。不过，既然是流对象，我们就可以玩一个"小把戏"，改变它的流向

public class PrintDemo {
    public static void main(String[] args) throws IOException {
        // 调用系统的打印流,控制台直接输出97
        System.out.println(97);
      
        // 创建打印流,指定文件的名称
        PrintStream ps = new PrintStream("ps.txt");
          
          // 设置系统的打印流流向,输出到ps.txt
        System.setOut(ps);
          // 调用系统的打印流,ps.txt中输出97
        System.out.println(97);
    }
}

Scanner类

构造方法

Scanner(File source) ：构造一个新的 Scanner，它生成的值是从指定文件扫描的。

Scanner(File source, String charsetName) ：构造一个新的 Scanner，它生成的值是从指定文件扫描的。

Scanner(InputStream source) ：构造一个新的 Scanner，它生成的值是从指定的输入流扫描的。

Scanner(InputStream source, String charsetName) ：构造一个新的 Scanner，它生成的值是从指定的输入流扫描的。

常用方法：

boolean hasNextXxx()：如果通过使用nextXxx()方法，此扫描器输入信息中的下一个标记可以解释为默认基数中的一个 Xxx 值，则返回 true。

Xxx nextXxx()：将输入信息的下一个标记扫描为一个Xxx

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Scanner;

import org.junit.Test;

public class TestFile {
    @Test
    public void test1() throws IOException {
        Scanner input = new Scanner(System.in);
        ArrayList<String> list = new ArrayList<>();
        while(true){
            System.out.print("请输入一个单词：");
            String str = input.nextLine();
            if("stop".equals(str)){
                break;
            }
            list.add(str);
        }
        System.out.println(list);
        input.close();
    }
    @Test
    public void test2() throws IOException {
        Scanner input = new Scanner(new File("1.txt"));
        while(input.hasNextLine()){
            String str = input.nextLine();
            System.out.println(str);
        }
        input.close();
    }
    
    @Test
    public void test3() throws FileNotFoundException{
        System.setIn(new FileInputStream("1.txt"));
        Scanner input = new Scanner(System.in);
        while(input.hasNextLine()){
            String str = input.nextLine();
            System.out.println(str);
        }
        input.close();
    }
}

序列化

概述

Java 提供了一种对象序列化的机制。用一个字节序列可以表示一个对象，该字节序列包含该对象的类型和对象中存储的属性等信息。字节序列写出到文件之后，相当于文件中持久保存了一个对象的信息。

反之，该字节序列还可以从文件中读取回来，重构对象，对它进行反序列化。对象的数据、对象的类型和对象中存储的数据信息，都可以用来在内存中创建对象。看图理解序列化：

ObjectOutputStream类

java.io.ObjectOutputStream 类，将Java对象的原始数据类型写出到文件,实现对象的持久存储。

构造方法

public ObjectOutputStream(OutputStream out)：创建一个指定OutputStream的ObjectOutputStream。

构造举例，代码如下：

FileOutputStream fileOut = new FileOutputStream("employee.txt");
ObjectOutputStream out = new ObjectOutputStream(fileOut);

序列化操作

该类必须实现java.io.Serializable 接口，Serializable 是一个标记接口，不实现此接口的类将不会使任何状态序列化或反序列化，会抛出NotSerializableException 。

如果对象的某个属性也是引用数据类型，那么如果该属性也要序列化的话，也要实现Serializable 接口

该类的所有属性必须是可序列化的。如果有一个属性不需要可序列化的，则该属性必须注明是瞬态的，使用transient 关键字修饰。

静态变量的值不会序列化

public class Employee implements java.io.Serializable {
    public static String company = "尚硅谷";
    public String name;
    public String address;
    public transient int age; // transient瞬态修饰成员,不会被序列化
    public void addressCheck() {
      System.out.println("Address  check : " + name + " -- " + address);
    }
}

写出对象方法

public final void writeObject (Object obj) : 将指定的对象写出。

public class SerializeDemo{
       public static void main(String [] args)   {
        Employee e = new Employee();
        e.name = "zhangsan";
        e.address = "beiqinglu";
        e.age = 20; 
        try {
              // 创建序列化流对象
          ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("employee.txt"));
            // 写出对象
            out.writeObject(e);
            // 释放资源
            out.close();
            fileOut.close();
            System.out.println("Serialized data is saved"); // 姓名，地址被序列化，年龄没有被序列化。
        } catch(IOException i)   {
            i.printStackTrace();
        }
       }
}
输出结果：
Serialized data is saved

ObjectInputStream类

ObjectInputStream反序列化流，将之前使用ObjectOutputStream序列化的原始数据恢复为对象。

构造方法

public ObjectInputStream(InputStream in)：创建一个指定InputStream的ObjectInputStream。

反序列化操作1

如果能找到一个对象的class文件，我们可以进行反序列化操作，调用ObjectInputStream读取对象的方法：

public final Object readObject () : 读取一个对象。

public class DeserializeDemo {
   public static void main(String [] args)   {
        Employee e = null;
        try {        
             // 创建反序列化流
             FileInputStream fileIn = new FileInputStream("employee.txt");
             ObjectInputStream in = new ObjectInputStream(fileIn);
             // 读取一个对象
             e = (Employee) in.readObject();
             // 释放资源
             in.close();
             fileIn.close();
        }catch(IOException i) {
             // 捕获其他异常
             i.printStackTrace();
             return;
        }catch(ClassNotFoundException c)  {
            // 捕获类找不到异常
             System.out.println("Employee class not found");
             c.printStackTrace();
             return;
        }
        // 无异常,直接打印输出
        System.out.println("Name: " + e.name);    // zhangsan
        System.out.println("Address: " + e.address); // beiqinglu
        System.out.println("age: " + e.age); // 0
    }
}

对于JVM可以反序列化对象，它必须是能够找到class文件的类。如果找不到该类的class文件，则抛出一个 ClassNotFoundException 异常。

反序列化操作2

另外，当JVM反序列化对象时，能找到class文件，但是class文件在序列化对象之后发生了修改，那么反序列化操作也会失败，抛出一个InvalidClassException异常。发生这个异常的原因如下：

该类的序列版本号与从流中读取的类描述符的版本号不匹配

该类包含未知数据类型

Serializable 接口给需要序列化的类，提供了一个序列版本号。serialVersionUID 该版本号的目的在于验证序列化的对象和对应类是否版本匹配。

public class Employee implements java.io.Serializable {
     // 加入序列版本号
     private static final long serialVersionUID = 1L;
     public String name;
     public String address;
     // 添加新的属性 ,重新编译, 可以反序列化,该属性赋为默认值.
     public int eid; 

     public void addressCheck() {
         System.out.println("Address  check : " + name + " -- " + address);
     }
}

序列化集合

将存有多个自定义对象的集合序列化操作，保存到list.txt文件中。

反序列化list.txt ，并遍历集合，打印对象信息。

案例分析

把若干学生对象，保存到集合中。

把集合序列化。

反序列化读取时，只需要读取一次，转换为集合类型。

遍历集合，可以打印所有的学生信息

案例实现

public class SerTest {
    public static void main(String[] args) throws Exception {
        // 创建 学生对象
        Student student = new Student("老王", "laow");
        Student student2 = new Student("老张", "laoz");
        Student student3 = new Student("老李", "laol");

        ArrayList<Student> arrayList = new ArrayList<>();
        arrayList.add(student);
        arrayList.add(student2);
        arrayList.add(student3);
        // 序列化操作
        // serializ(arrayList);
        
        // 反序列化  
        ObjectInputStream ois  = new ObjectInputStream(new FileInputStream("list.txt"));
        // 读取对象,强转为ArrayList类型
        ArrayList<Student> list  = (ArrayList<Student>)ois.readObject();
        
          for (int i = 0; i < list.size(); i++ ){
              Student s = list.get(i);
            System.out.println(s.getName()+"--"+ s.getPwd());
          }
    }

    private static void serializ(ArrayList<Student> arrayList) throws Exception {
        // 创建 序列化流 
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("list.txt"));
        // 写出对象
        oos.writeObject(arrayList);
        // 释放资源
        oos.close();
    }
}

java.io.Externalizable接口

除了Serializable接口之外，还可以实现java.io.Externalizable接口，但是要求重写：

void readExternal(ObjectInput in) void writeExternal(ObjectOutput out)

关于哪些属性序列化和反序列化，由程序员自己定。虽然可以自己决定任意属性的输出和读取，但是还是建议不要输出静态的和transient属性。

学生类：

import java.io.Externalizable;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;

public class Student implements Externalizable{
    private static String school = "atguigu";
    private String name;
    private transient int age;
    private int score;
    public Student(String name, int age, int score) {
        super();
        this.name = name;
        this.age = age;
        this.score = score;
    }
    public Student() {
        super();
    }
    public static String getSchool() {
        return school;
    }
    public static void setSchool(String school) {
        Student.school = school;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public int getScore() {
        return score;
    }
    public void setScore(int score) {
        this.score = score;
    }
    @Override
    public String toString() {
        return "Student [name=" + name +",age =" +age + ", score=" + score +",schoool = " + school+ "]";
    }
    
    //一下两个方法不是程序员手动调用，而是在对象被序列化和反序列时，IO流自动调用
    @Override
    public void writeExternal(ObjectOutput out) throws IOException {
        //在这个方法中，程序员自己定，哪些属性需要序列化，及其顺序
        out.writeUTF(school);
        out.writeUTF(name);
        out.writeInt(score);
        out.writeInt(age);
    }
    @Override
    public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
        //读取的顺序要与写的顺序一致
        school = in.readUTF();
        name = in.readUTF();
        score = in.readInt();
        age = in.readInt();
    }
    
}

测试类

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

import org.junit.Test;

/*
 * 类通过实现 java.io.Serializable 接口以启用其序列化功能。未实现此接口的类将无法使其任何状态序列化或反序列化。
 *         序列化接口没有方法或字段，仅用于标识可序列化的语义。
 * 
 * java.io.Externalizable 实例类的唯一特性是可以被写入序列化流中，该类负责保存和恢复实例内容。 
 *         则它要实现 Externalizable 接口的 writeExternal 和 readExternal 方法。
 * 
 *  void readExternal(ObjectInput in) 
 *  void writeExternal(ObjectOutput out)  
 *  
 *  虽然可以自己决定任意属性的输出和读取，但是还是建议不要输出静态的和transient属性
 */
public class TestExternalizable {
    @Test
    public void in()throws IOException, ClassNotFoundException{
        FileInputStream fis = new FileInputStream("stu.dat");
        ObjectInputStream ois = new ObjectInputStream(fis);
        
        Object obj = ois.readObject();
        
        System.out.println(obj);
        
        ois.close();
        fis.close();
    }
    
    @Test
    public void out()throws IOException{
        Student student = new Student("张三", 23, 89);
        Student.setSchool("尚硅谷");
        
        FileOutputStream fos = new FileOutputStream("stu.dat");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        
        oos.writeObject(student);
        
        oos.close();
        fos.close();
    }
}