File类和IO流-阿里云开发者社区

File类的概述

File位于java.io包下，是对于文件和路径（文件夹）的抽象表现方式
Java把文件中的文件和文件夹，封装成了一个File类，我们可以使用File类的方法创建、获取、删除、判断、遍历文件和文件夹
File类是一个与系统无关的类，任何一个操作系统都可以使用这个类当中的方法
file文件，directory文件夹，path路径

File类当中的成员变量

File类当中共计四个File静态成员变量

static String pathSeparator 
与系统相关的路径分隔符字符，为方便起见，表示为字符串。  
static char pathSeparatorChar 
与系统相关的路径分隔符。  
static String separator 
与系统相关的默认名称 - 分隔符字符，以方便的方式表示为字符串。  
static char separatorChar 
与系统相关的默认名称分隔符。

/*
     * @Description:File文件中的四个静态成员变量
     * @Author: DaShu
     * @Date: 2021/5/31 21:31
     */
    @Test
    public void test01(){
        //文件分隔符：win是\，Linux是/
        System.out.println(File.separator);
        System.out.println(File.separatorChar);
        //路径分隔符：win是；Linux是：
        System.out.println(File.pathSeparator);
        System.out.println(File.pathSeparatorChar);
        //        \
        //        \
        //        ;
        //        ;
    }

绝对路径和相对路径

绝对路径是一个完整的路径，以盘符开始的路径，相对路径是一个简化的路径，相对指的是相对于当前项目的根目录

File类当中常用方法介绍

package com.pactera.io;
import java.io.DataOutput;
import java.io.File;
import java.io.IOException;
/**
 * @Auther: DaShu
 * @Date: 2021/6/1 16:13
 * @Description: 测试File类的常用方法
 *               获取：判断：创删
 */
public class FileMethodTest {
    public static void main(String[] args) throws Exception {
        getAbsolutPath();
        System.out.println("-----------------------getAbsolutPath();------------------------");
        getPath();
        System.out.println("-----------------------getPath();------------------------");
        getName();
        System.out.println("-----------------------getName();------------------------");
        length();
        System.out.println("-----------------------length();------------------------");
        exists();
        System.out.println("-----------------------exists();------------------------");
        isDirectory();
        System.out.println("--------------------------isDirectory();----------------------------");
        isFile();
        System.out.println("-----------------------isFile()--------------------------------------");
        createNewFile();
        System.out.println("----------------------------createNewFile();----------------------------------------");
        mkdirAndmkdirs();
        System.out.println("------------------------mkdirAndmkdirs()--------------------------------------------");
        delete();
        System.out.println("-----------------------delete()-----------------------------");
    }
    /*
     * @Target:研究File类getAbsolutePath()路径
     * @Author: DaShu
     * @Date: 2021/6/1 16:15
     * @Result:获取的是对象当中的路径，不论当时对象里封装的是相对路径还是绝对路径，返回的都是绝对路径
     */
    public static void getAbsolutPath(){
        File file1 = new File("D:\\DevelopPackage\\codeshop\\Spring5.x\\a.txt");
        File absoluteFile = file1.getAbsoluteFile();
        System.out.println("absoluteFile="+absoluteFile);
        //absoluteFile=D:\DevelopPackage\codeshop\Spring5.x\a.txt
        File file2 = new File("a.txt");
        File absoluteFile1 = file2.getAbsoluteFile();
        System.out.println("absoluteFile1="+absoluteFile1);
        //absoluteFile1=D:\DevelopPackage\codeshop\Spring5.x\a.txt,所谓的这个项目的根路径指的是项目所在的文件夹。
    }
    /*
     * @Target:研究File类getPath();
     * @Author: DaShu
     * @Date: 2021/6/1 16:23
     * @Result: 对象当中封装的是绝对的，就是绝对的，相对的就是相对的。
     *          toString()方法调用的就是getPath（）方法
     */
    public static void getPath(){
        File file1 = new File("D:\\DevelopPackage\\codeshop\\Spring5.x\\a.txt");
        String path = file1.getPath();
        System.out.println("path="+path);
        //path=D:\DevelopPackage\codeshop\Spring5.x\a.txt
        File file2 = new File("a.txt");
        String path1 = file2.getPath();
        System.out.println("path1="+path1);
        //path1=a.txt
    }
    /*
     * @Target:研究File类getName();
     * @Author: DaShu
     * @Date: 2021/6/1 16:32
     * @Result:无论是什么路径获取的都是最后一段，对象当中的路径可以是绝对的，可以是相对的。
     */
    public static void getName(){
        File file1 = new File("D:\\DevelopPackage\\codeshop\\Spring5.x\\a.txt");
        System.out.println(file1.getName());//a.txt
        File file2 = new File("D:\\DevelopPackage\\codeshop\\Spring5.x");
        System.out.println(file2.getName());//Spring5.x
    }
    /*
     * @Target:研究File类length();
     * @Author: DaShu
     * @Date: 2021/6/1 16:35
     * @Result:文件夹是没有大小的，不能获取文件夹的大小,获取的也是文件夹所有文件的大小
     *         如果路径当中给出的路径不存在，那么length方法返回的值是0；
     */
    public static void length(){
        File file1 = new File("D:\\DevelopPackage\\codeshop\\Spring5.x\\a.txt");
        long length = file1.length();
        System.out.println(file1.getAbsolutePath());
        System.out.println(file1.exists());
        System.out.println("length="+length);
        File file2 = new File("D:\\DevelopPackage\\codeshop\\Spring5.x");
        long length2 = file2.length();
        System.out.println("length2="+length2);
        System.out.println(file2.hashCode() == file1.hashCode());
    }
    /*
     * @Target:判断File类当中的exists()方法是否存在
     * @Author: DaShu
     * @Date: 2021/6/1 17:04
     * @Result: 判断路径是否存在
     */
    public static void exists(){
        File file1 = new File("D:\\DevelopPackage\\codeshop\\Spring5.x\\a.txt");
        System.out.println(file1.exists());//true
        File file2 = new File("D:\\DevelopPackage\\codeshop\\Spring5.x");
        System.out.println(file2.exists());//true
        File file3 = new File("a.txt");
        System.out.println(file3.exists());//true
        File file4 = new File("b.txt");
        System.out.println(file4.exists());//false
    }
    /*
     * @Target:判断File类当中的isDirectory()方法是否存在
     * @Author: DaShu
     * @Date: 2021/6/1 17:04
     * @Result: 判断给定路径是否以为文件夹结尾
     *     注意：电脑中的文件要么是文件，要么是文件夹，这两个文件夹的路径必须是存在的否则就是默认返回false
     *
     */
    public static void isDirectory(){
        File file1 = new File("D:\\DevelopPackage\\codeshop\\Spring5.x\\a.txt");
        System.out.println(file1.isDirectory());//false
        File file2 = new File("D:\\DevelopPackage\\codeshop\\Spring5.x");
        System.out.println(file2.isDirectory());//true
        File file3 = new File("a.txt");
        System.out.println(file3.isDirectory());//false
        File file4 = new File("b");
        System.out.println(file4.isDirectory());//false
    }
    /*
     * @Target:判断File类当中的isFile()方法是否存在
     * @Author: DaShu
     * @Date: 2021/6/1 17:04
     * @Result: 判断给定路径是否以为文件夹结尾
     *     注意：电脑中的文件要么是文件，要么是文件夹，这两个文件夹的路径必须是存在的否则就是默认返回false
     *
     */
    public static void isFile(){
        File file1 = new File("D:\\DevelopPackage\\codeshop\\Spring5.x\\a.txt");
        System.out.println(file1.isFile());//false
        File file2 = new File("D:\\DevelopPackage\\codeshop\\Spring5.x");
        System.out.println(file2.isFile());//true
        File file3 = new File("a.txt");
        System.out.println(file3.isFile());//false
        File file4 = new File("b");
        System.out.println(file4.isFile());//false
    }
    /*
     * @Target: File文件当中的createFile()方法
     * @Author: DaShu
     * @Date: 2021/6/1 17:19
     * @Result: createNewFile方法声明抛出了异常，我们调用也必须处理异常。
     */
    public static void createNewFile() throws Exception {
        File file1 = new File("D:\\DevelopPackage\\codeshop\\Spring5.x\\b.txt");
        boolean newFile = file1.createNewFile();
        System.out.println(newFile);//文件不存在的时候，才会创建文件，返回TRUE，此方法只能创建文件，不能创建文件夹，创建文件的路径必须存在，否则会抛出异常。
        //public boolean createNewFile() throws IOException {
        //    SecurityManager security = System.getSecurityManager();
        //    if (security != null) security.checkWrite(path);
        //    if (isInvalid()) {
        //        throw new IOException("Invalid file path");
        //    }
        //    return fs.createFileExclusively(path);
        //}
        File file2 = new File("c.bat");
        boolean newFile1 = file2.createNewFile();
        System.out.println(newFile1);//
        File file4 = new File("新建文件");
        boolean newFile2 = file4.createNewFile();
        System.out.println(newFile2);//没有文件后缀也能创建文件
    }
    /*
     * @Target: File文件当中的mk()方法
     * @Author: DaShu
     * @Date: 2021/6/1 17:30
     * @Result:
     */
    public static void mkdirAndmkdirs(){
        //mkdir创建单击文件夹，另一个创建单机多级都可以。
        //文件夹不存在创建文件夹，返回TRUE，存在返回false
        //构造方法中的文件路径不存在返回false
        File file = new File("com");
        boolean mkdir = file.mkdir();
        System.out.println(mkdir);
        File file01 = new File("com\\pactera\\aaa\\shit");
        boolean mkdirs = file01.mkdirs();
        System.out.println(mkdirs);
        File file02 = new File("com\\pactera\\aaa\\shit\\shit.txt");
        boolean mkdirss = file02.mkdirs();
        System.out.println(mkdirss);
    }
    /*
     * @Target: File文件当中的delete方法
     * @Author: DaShu
     * @Date: 2021/6/1 17:39
     * @Result: 删除文件和文件夹
     */
    public static void delete(){
        //删除成功返回TRUE，删除失败返回false，路径错误返回false，
        File file = new File("com");
        boolean mkdir = file.delete();
        System.out.println(mkdir);
        File file01 = new File("com\\pactera\\aaa\\shit");
        boolean mkdirs = file01.delete();
        System.out.println(mkdirs);
        File file02 = new File("com\\pactera\\aaa\\shit\\shit.txt");
        boolean mkdirss = file02.delete();
        System.out.println(mkdirss);
    }
}

File类的遍历方法和迭代

文件搜索的原理也是递归

package com.pactera.io;
import com.sun.scenario.effect.impl.sw.sse.SSEBlend_SRC_OUTPeer;
import java.io.File;
/**
 * @Auther: DaShu
 * @Date: 2021/6/2 17:31
 * @Description: 文件目录的遍历
 */
public class FileRoll {
    public static void main(String[] args) {
        list_and_listFile();
        File file = new File("D:\\DevelopPackage\\codeshop\\Spring5.x\\io");
        System.out.println("------------------------------");
        getAllFiles(file);
    }
    /*
     * @Target: list方法，listFile方法
     * @Author: DaShu
     * @Date: 2021/6/2 17:31
     * @Result:这两个方法遍历的的是File构造路径中的目录，如果路径是假的或者是文件
     *         就会抛出一个空指针异常,这个遍历的方法可以获取到隐藏的文件和文件夹，
     */
    public static void list_and_listFile(){
        File file = new File("D:\\DevelopPackage\\codeshop\\Spring5.x\\io");
        String[] list = file.list();
        for (String s : list) {
            System.out.println(s);
            //io.iml
            //pom.xml
            //src
            //target
        }
        File[] files = file.listFiles();
        for (File file1 : files) {
            System.out.println(file1.getAbsoluteFile());
            //D:\DevelopPackage\codeshop\Spring5.x\io\io.iml
            //D:\DevelopPackage\codeshop\Spring5.x\io\pom.xml
            //D:\DevelopPackage\codeshop\Spring5.x\io\src
            //D:\DevelopPackage\codeshop\Spring5.x\io\target
        }
        for (File file1 : files) {
            System.out.println(file1.getName());
            //io.iml
            //pom.xml
            //src
            //target
        }
    }
    //递归，递归的意思就是方法调用自己，
    //递归一定要有条件，要让方法能够停下来，防止栈内存溢出。
    //递归中虽然有条件限定，但是递归次数也不能太多，否则也会繁盛栈内存溢出。
    //构造方法禁止递归
    //为什么会发生栈内存溢出呢？
    public static void getAllFiles(File dir){
        File[] files = dir.listFiles();
        for (File file : files) {
            if(file.isFile()){
                System.out.println(file.getName());
            }else{
                System.out.println(file.getName());
                getAllFiles(file);
            }
            //io.iml
            //pom.xml
            //src
            //main
            //java
            //com
            //pactera
            //io
            //FileMethodTest.java
            //FileRoll.java
            //resources
            //test
            //java
            //target
            //classes
            //com
            //pactera
            //io
            //FileMethodTest.class
            //FileRoll.class
            //generated-sources
            //annotations
        }
    }
}

文件过滤器优化

文件过滤器是一个接口，刚才我们这个需求可以进行优化，我们可以使用过滤器来实现迭代文件和文件夹的接口，在File类当中由两个listFile()重载的方法，方法的参数就是过滤器，

在file类当中有两个和listFile()重载的方法，方法的参数传递的就是过滤器，是一个接口

先说listFiles(FileFilter f)这个方法，作用用于过滤文件，过滤的内容都是File对象，其中有一个抽象方法，boolean accept(File file) 测试指定抽象路径名是否应该包含在某个路径名列表中。
方法的参数是就是file对象，
另一个方法，参数也是一个接口，是一个文件名称过滤器，用于过滤文件名称，用于过滤抽象方法，叫做accept，参数有两个，File对象， String name 使用listFile方法比那里目录获取的每一个文件、文件夹的名称。
注意事项：两个过滤器接口没有实现类，需要我们自己写实现类，重写过滤方法，在方法中自己定义过滤的规则。

//只要.java结尾的文件。
    public static void getAllFiles01(File dir){
        //方法一：
        FileFilter f1 = new FIleFilterImpl();
        f1 = new FileFilter() {
            @Override
            public boolean accept(File pathname) {
                //如果pathname是一个文件夹，返回TRUE，不能遍历数组。
                return pathname.getName().toLowerCase().endsWith(".java") || pathname.isDirectory();
            }
        };
        File[] files = dir.listFiles(f1);
        //方法二：
        files = dir.listFiles(new FilenameFilter() {
            @Override
            public boolean accept(File dir, String name) {
                return new File(dir,name).isDirectory()||name.toLowerCase().endsWith(".java");
            }
        });
        //方法三：使用lambda表达式
        files = dir.listFiles((fileType,name)->new File(fileType,name).isDirectory()||name.toLowerCase().endsWith(".java"));
        for (File file : files) {
            if(file.isFile()){
                System.out.println(file.getName());
            }else{
                System.out.println(file.getName());
                getAllFiles(file);
            }
        }
    }

io概述

这个是硬盘，硬盘在不停的转，硬盘在不停转的同时与磁头进行接触读取到硬盘上不同的文件。内存当中的数据存储是临时存储，电脑已关机，数据就没了，io，就是读取和输出。流：就是数据，数据共有两种：字节流和字符流，一个字符占两个字节，也就是16个二进制的位。一个字节=8个二进制的位，

数据分为字节和字符，所以流也分为：

这四个也是io流的最顶层的四个父类。

字节流

一切皆为字节

硬盘上的视频，图片，文本，TXT文件，。。都是以字节的方式存储的，存储的任意的字节都是字节，那么作为流传输的时候也是以二进制字节的方式进行传输的，**所以，这个字节流可以读取任意的文件。**所有的流都在。java.io包下

OutputStream流

字节输出流的最顶层的父类，是一个抽象类，一般超类当中定义的都是公共的所有类都能使用的方法，

第二个是往文件当中写内容的输出流。这个流也叫：文件字节输出流，作用就是把内存中的数据写入到硬盘的文件中。

流使用的时候会占用一定的jvm内存和操作系统资源，使用完毕之后一定要关闭流，减少资源的占用，提高程序的效率。

文件存储的原理

输出多个字节

public static void write02() throws IOException {
        OutputStream fos = new FileOutputStream("io\\src\\main\\java\\com\\pactera\\io\\b.txt");
        fos.write(49);//写出去一个字节
        fos.write(48);//写出去一个字节
        fos.write(-48);//写出去一个字节
        byte[] bytes = {-65,-66,67,-68,69};
        fos.write(bytes);
        byte[] bytes1 = {65,66,67,68,69};
        fos.write(bytes1,1,2);//10锌綜糆BC
        byte[] bytes2 = "你好".getBytes();
        System.out.println(Arrays.toString(bytes2));//[-28, -67, -96, -27, -91, -67]
        fos.write(bytes2);
        fos.close();
    }

数据追加（非覆盖重写）+换行

\r\n也是个字符串。

字节输入流InputStream

这是一个抽象类。这是所有的字节输入流的超类。定义类所有的字节输入流的共性的方法。

java.io.FileInputStream extends inputStream这个流叫做文件字节输入流。

可以把硬盘文件中的数据读取到内存中使用，这是他的一个作用，

构造方法

我们用第一个和第三个，他的参数是文件的数据源，Strring文件路径，File是文件对象。

常用方法进行数据读取

读取数据的原理：

public static void main(String[] args) throws Exception {
        InputStream fis = new FileInputStream("spring5.x\\a.txt");
        //一次读一个，读取文件中的一个字节，并进行返回，读取到文件的末尾，会返回-1
        //这个函数是一个特殊的函数，读一次会把他的指针往回挪一位（流对象当中的指针），所以，每次调用read方法得到的结果都不一样。
/*        int read = fis.read();
        System.out.println(read);
        read = fis.read();
        System.out.println(read);
        read = fis.read();
        System.out.println(read);
        read = fis.read();
        System.out.println(read);
        read = fis.read();
        System.out.println(read);*/
        //97
        //98
        //99
        //-1
        //-1
        //以上读取文件是一个重复的过程，重复的过程我们可以使用循环优化，不知道文件中由多少个字节，使用while循环
        int num ;
        while( (num = fis.read()) != -1){
            System.out.println((char)num);
        }
/*        97
        98
        99*/
        fis.close();
    }

字节输入流读取文件的一个原理

结束标记是看不到的，是window系统的一个结束标记。

创建了FileInputStream之后就就创建了一这样的对象，这个对象指向的硬盘上的对应路径的那个文件，并且指向的是那个文件的第一个字节。使用read方法的时候，并不是直接read方法去读文件，而是read方法被虚拟机调用，虚拟机去找os,os去找对应的操作函数，函数去找文件，是这样的一个过程。数据回来的时候也是文件数据给函数，函数给操作系统，os给jvm，对应的指针向后移动一位，指针到了结束标记之后，就会把结束标记给操作系统，操作系统把结束标记给jvm，jvm把-1给我们。所以，Linux一样。

文件的复制

文件当中都是以字节存储的，我们使用字节流可以读取任意类型的文件，我们的目地就是将文件读进来之后在存进其他的盘当中，我们怎么进行文件的复制呀就是一读一写，读进jvm内存之后在写到磁盘上。

/**
 * @Auther: DaShu
 * @Date: 2021/6/7 19:17
 * @Description:
 */
public class Copy {
    public static void main(String[] args) throws Exception {
        File file;
        FileInputStream fis = new FileInputStream("D:\\love.shit");
        FileOutputStream fos = new FileOutputStream("d:\\lovefuct.shit");
        int len;
        while((len = fis.read()) != -1){
            System.out.println(len);
            fos.write(len);
        }
        //关闭流的话肯定是先关闭输出的，在关闭输入的，如果重复执行这个方法的话，会先把之前复制的文件给删除掉，在进行复制
        fos.close();
        fis.close();
    }
}

/**
 * @Auther: DaShu
 * @Date: 2021/6/7 19:17
 * @Description:
 */
public class Copy {
    public static void main(String[] args) throws Exception {
        long begin = System.currentTimeMillis();
        FileInputStream fis = new FileInputStream("D:\\love.shit");
        FileOutputStream fos = new FileOutputStream("d:\\mama.shit");
        int len;
        byte[] bytes = new byte[10240000];
//        while((len = fis.read(bytes)) != -1){
          System.out.println(len);
            fos.write(bytes,0,len);
        }
        len = fis.read(bytes);
        fos.write(bytes,0,len);
        int i = 0;
        FileInputStream fis1 = new FileInputStream("D:\\love.shit");
        FileOutputStream fos1 = new FileOutputStream("d:\\mama1.shit");
        while((len = fis1.read(bytes))!=-1){
            System.out.println(i);
            i++;
            fos1.write(bytes,0,len);
        }
        fos.close();
        fis.close();
        fos1.close();
        fis1.close();
        long end = System.currentTimeMillis();
        System.out.println(end - begin + "mm");
    }
}

字节流读取中文

/**
 * @Auther: DaShu
 * @Date: 2021/6/7 19:51
 * @Description: 使用字节流读取中文
 */
public class ChineseTest {
    public static void main(String[] args)throws IOException {
        FileInputStream fileInputStream = new FileInputStream("d:\\aaa.txt");
        int len = 0;
        /*
         * @Description:
         * @Author: DaShu
         * @Date: 2021/6/7 19:55
         * Gbk的中文占用两个字节，utf8的中文占用3个字节，
         */
        while((len = fileInputStream.read())!=-1){
            System.out.println((char)len);
        }
        //228       ä               
        //189       ½
        //160        
        //229       å
        //165       ¥
        //189       ½
        fileInputStream.close();
    }
}

使用字节流读取中文的时候会由于gbk和utf8的编码占用空间的不同，字节流读取的字符是一半或者三分之一，这样的话，使用字符可能出现所谓的乱码的问题，为了解决这个问题，java当中产生了字符流，使用字符流可以读取中文英文等任意类型的东西。

Reader字符输入流最顶层父类

Reader当中定义了公共的使用的方法，他是一个抽象类。

我们使用FileReader读取问价拿的字符输入流。

字符输入流的使用步骤：

/**
 * @Auther: DaShu
 * @Date: 2021/6/7 20:01
 * @Description:
 */
public class ReaderDemo {
    public static void main(String[] args) throws Exception {
        Reader reader = new FileReader("d:\\aaa.txt");
//        int len = 0;
//        while((len = reader.read()) != -1){
//            System.out.print((char)len);
//            //你好avxd##$$%%@@#
//        }
        char[] cs = new char[1024];
        int len = 0;//len记录的事读取到的有效字符的个数
        //new String(char[])
        //new String(char[],begin,lenth
        while ((len = reader.read(cs)) != -1){
            System.out.println(new String(cs,0,len));//你好avxd##$$%%@@#
        }
        reader.close();
    }
}

Writer字符输出流最顶层父类

这是一个抽象类，是字节输出流的最顶层的父类，定义了公共的方法，定义了共性的方法，这个流可以直接写一个字符，写一个数组，写数组一部分，直接写字符串，定义了共性成员方法，FileWriter继承了一个OutputStreamWriter，继承了writer,

FileWriter叫做文件字符字符流，将内存中的字符传输来写入到文件当中，

字符输出流的使用的过程，

创建Filewriter对象，构造方法中绑定要写入数据的目的地，

使用filewriter中的方法write将数据写入内存当中的缓存区，（这个是将字节转为字符的过程）

使用FIleWriter当中的方法flush将内存缓冲区的数据，刷新到文件中，

释放资源（close）会先把内存缓冲区当中的数据刷新到文件中，所以这个flush这个方法可以不用写，字符流根字节流最大的区别就在于，不是直接将数据写入到文件中而是先把数据写入到内存中。

这个FileWriter的方法并不是直接将数据写入到硬盘上，如果我们执行write方法之后，既不close，又不flush方法，内容还在缓冲区当中，是不会到磁盘上的，所以文件是空的。他这个写入到字节缓存区是在内存当中，并没有进入磁盘。

/**
 * @Auther: DaShu
 * @Date: 2021/6/7 20:28
 * @Description:
 */
public class FileWriterTest {
    public static void main(String[] args) throws IOException {
        FileWriter fw = new FileWriter("D:\\d.txt");
        //写单个字符
        fw.write(97);
        fw.flush();
        //执行close方法之前会先将缓冲区当中的流刷入磁盘当中。
        fw.close();
    }
}

close方法和flush方法的区别

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

flush：刷新缓冲区，然后通知系统释放资源，流对象不可以在使用了。

写数据的其他方法

/**
 * @Auther: DaShu
 * @Date: 2021/6/7 20:50
 * @Description:
 */
public class FileWriterTest01 {
    public static void main(String[] args) throws Exception {
        FileWriter fw = new FileWriter("d:\\e.txt");
        //写字符数组
        char[] cs = {'a','b','c','d','e'};
        fw.write(cs);
        //写字符数组的一部分
        fw.write(cs,1,3);
        //写字符串
        fw.write("传智播客");
        fw.write("黑马程序员",2,3);
        //abcdebcd传智播客程序员
        fw.close();
    }
}

字符流的续写和换行

这个和字节流一模一样。

续写和追加写，使用两个参数的构造方法就可以了。

流异常的处理

jdk1.7之前可以使用try catch finally来进行异常处理。

变量的作用于只在变量的声明的大扩招当中有效。

/**
 * @Auther: DaShu
 * @Date: 2021/6/7 21:07
 * @Description:
 */
public class FileWriteTest02 {
    public static void main(String[] args) {
        //提高fw的作用域，这的变量是一个局部变量，变量使用的时候必须有值
        //创建对象有可能失败，这样的话，fw没有值，所以需要一个初始化的值，所以编译不过去
        FileWriter fw = null;
        try {
            fw  = new FileWriter("D:\\d.txt");
            fw.write(97);
        }catch (IOException e){
            System.out.println(e);
        }finally {
            //如果fw创建失败了，fw是null。
            if(fw != null){
                try {
                    //fw.close声明抛出异常，有可能报错，所以我们处理这个对象要么try ，
                    fw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

JDK7的新特性

在jdk7以后在try后边可以增加一个()，在括号中定义流对象，这个流对象的作用于是try当中有效，try当中的代码执行完毕就会自动把对象释放，不用写finally

try(定义一个或者多个流对象){

}catch(){

}

class StreamTest {
    public static void main(String[] args) {
        try(FileInputStream fis = new FileInputStream("D:\\love.shit");
            FileOutputStream fos = new FileOutputStream("d:\\mama.shit");){
            long begin = System.currentTimeMillis();
            int len;
            byte[] bytes = new byte[10240000];
            len = fis.read(bytes);
            fos.write(bytes,0,len);
            long end = System.currentTimeMillis();
            System.out.println(end - begin + "mm");
        }catch (IOException e){
            e.printStackTrace();
        }
    }
}

jdk9的流的新特性

在jdk7的新特性上做了一点点修改。

两种方式try完成之后流已经关闭了，

属性集Properties

HashTable是最早期的一个双列集合，在jdk1.0的时候就存在了，但是因为是单线程被淘汰了，他的子类Properties依旧活跃，因为她是唯一一个和IO相结合的集合，Propertyes类表示的是一个持久的属性集，属性列表当中的键和值都是一个字符串，

java.util.Properties集合 extends hashtable implements Map

Properties是一个唯一一个和io流相结合的结合，可以使用store方法吧集合当中的临时数据写入到磁盘当中，可以使用properties集合当中的load方法把硬盘当中保存的文件（键值对），读取到集合中进行使用。这个属性列表当中的键和值都是一个字符串他是一个双列结构，并且他们的键和值都是一个字符串，所以不用使用泛型了，默认都是字符串

Properties集合当中操作字符串的方法

/**
 * @Auther: DaShu
 * @Date: 2021/6/7 21:39
 * @Description:
 */
public class PropertiesTest {
    public static void main(String[] args) {
        show();
    }
    public static void show(){
        Properties properties = new Properties();
        properties.setProperty("赵丽颖","168");
        properties.put("古力娜扎","shist");
        properties.setProperty("迪丽热巴","165");
        Set<String> strings = properties.stringPropertyNames();
        for (String string : strings) {
            String property = properties.getProperty(string);
            System.out.println(property);
            //168
            //shist
            //165
        }
    }
}

properties当中的store方法

public static void show02() throws IOException {
        Properties properties = new Properties();
        properties.setProperty("赵丽颖","168");
        properties.put("古力娜扎","shist");
        properties.setProperty("迪丽热巴","165");
        FileWriter fw = new FileWriter("d:\\prop.txt");
//        properties.store(fw,"save data");
        //匿名对象不用关，因为匿名对象使用完之后自己就关了
        //字符流可以写中文，字节流不可以写中文。
        properties.store(new FileOutputStream("d:\\prop11.txt"),"save data");
        fw.close();
        //#save data
        //#Mon Jun 07 21:57:16 CST 2021 这个时间是他自己家的。
        //赵丽颖=168
        //古力娜扎=shist
        //迪丽热巴=165
    }

load方法
这个是今天的主要的方法，load方法可以把硬盘中保存的文件读取到内存当中，

public static void show03() throws Exception {
        Properties prop = new Properties();
        prop.load(new FileReader("d:\\prop11.txt"));
        Set<String> strings = prop.stringPropertyNames();
        for (String string : strings) {
            System.out.println(string + "=" + prop.getProperty(string));
            //一般我们使用这个load方法都用字符流。
            //迪丽热巴=165
            //古力娜扎=shist
            //赵丽颖=168
        }
    }

缓冲流

缓冲流的概念

缓冲流能够高效的读写，能够转换编码，能够持久化存储对象的序列化流，这些功能强大的缓冲流都是在基本的流对象基础之上创建来的，就像穿上铠甲的勇士一样，相当于是对基本流对象的增强。

缓冲流的原理

每个文件当中都有一个结束标记，现在使用一个流读取文件，如果使用基本的字节输入流的话，FileInputStream 中的read方法进行读取。读取的过程java程序要找到jvm，jvm要找到操作系统，操作系统要找到相应的函数来进行读取。字节的读取的时候，读取一个字符到什么然后进行一级一级的返回。这样的话就非常的影响效率，二使用字节缓冲输入流的话，就会给基本的字节输入流增加一个缓冲区，也就是一个数组，提高基本的字节输入流的效率，这是字节缓冲输入流，字节缓冲输出流也是这个流程，比如说bufferedInputStream它里边需要传入一个基本的字节输入流，FileInputStream,有了这个高效的字节缓冲输入流之后，有一个缓冲区数组，通过这个数组可以一次性把所有的数组读取进来，在把这个数组整体进行返回。

注意：不管是字节的还是字符的都是增加了一个这样的数组，提高了读取的效率。

BufferedOutputStream

继承了OutputStream所以，这是个字节流。字节缓冲输出流。集成共性的父类的构造方法

构造方法

一共有两个。

/**
 * @Auther: DaShu
 * @Date: 2021/6/8 19:00
 * @Description: 研究bufferdOutputStream
 */
public class BufferdOutputStreamTest {
    public static void main(String[] args) throws IOException{
        File file = new File("d:\\bufferedOutputStream.txt");
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(file));
        bos.write("我把数据写入到内存缓冲区".getBytes());
        bos.flush();//flush方法才会把数据刷入到文件当中。
        bos.close();
    }
}

BufferedInputStream

继承了inputStream也是一个字节流，叫字节缓冲输入流，他的集成父类的成员方法。字节输入流有这三个方法。

构造方法

两个：默认缓冲区大小，指定缓冲区大小。需要一个FileInputStream对象。size是指定缓冲区大小。

class BufferedInputStreamTest{
    public static void main(String[] args) throws IOException {
        File file = new File("d:\\BufferedOutputStream.txt");
        FileInputStream fis = new FileInputStream(file);
        BufferedInputStream bis = new BufferedInputStream(fis);
//        int len;
//        while((len = bis.read()) != -1){
//            System.out.println(len);
//        }
        //这个效率最快。
        byte[] bytes = new byte[1024];
        int len = 0;
        while((len = bis.read(bytes)) != -1){
            System.out.println(new String(bytes,0,len));
        }
        bis.close();//资源释放关闭缓冲流就可以了，关闭缓冲流就可以关闭对应的普通流
    }
}

效率测试

class BufferedVSUniverse{
    public static void main(String[] args) throws IOException {
        try(BufferedInputStream bis = new BufferedInputStream(new FileInputStream(new File("d:\\test.txt")));
            BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(new File("d:\\test01.txt")));
            FileInputStream fis = new FileInputStream(new File("d:\\test.txt"));
            FileOutputStream fos = new FileOutputStream(new File("d:\\test2.txt"));
        ){
            long start01 = System.currentTimeMillis();
            byte[] bytes = new byte[204800];
            int len ;
            while((len = bis.read(bytes)) != -1){
                bos.write(bytes,0,len);
            }
            bos.flush();
            long end01 = System.currentTimeMillis();
            System.out.println("buffered流的用时为："+ (end01-start01)+"mm");
            bos.close();
            long start02 = System.currentTimeMillis();
            while((len = fis.read(bytes)) != -1){
                fos.write(bytes,0,len);
            }
            fos.flush();
            long end02 = System.currentTimeMillis();
            System.out.println("非buffered流的用时为："+ (end02-start02)+"mm");
        }catch (Exception e){
            System.out.println(e);
        }
    }
}

结论：

一个700多kb的文件，使用普通的输入输出流，单个字节读取需要6000多mm，使用数组需要10mm提升了600多倍，buffered这样的流的话进行读取，一个一个字节进行读取的话需要32mm，而使用数组的话大约需要5mm。

bufferedWriter

bufferedWriter extends writer 叫做字符缓冲输出流，集成自父类的成员方法。

println当中调用的换行符号就是newline(),他的作用就是写一个换行符号

在这里插入代码片

bufferedReader

字符缓冲输入流，extends Reader 继承了成员方法。

文本内容进行排序。

转换流

字符编码和字符流。

计算机当中只能识别10101，计算机当中存储的也是二进制数据，计算机当中的文件和视频多事二进制存储的，但是将图片记性打开的时候并不是1010，而是图或者视频，任何一个软件都有转换功能，经1010转换成字符，图片，

我们使用A编码进行编码，使用A编码进行解析就可以显示正确的文本，我们使用A规则存储使用B规则进行解析就会出现乱码的情况。

任何一个编码表都兼容了asill表，这是一个最基本的编码表。

双编码的意思就是任何一个字符都是采用两个字节进行存储，所以gbk一个字符使用两个字节

GB18030使用的是多字节编码，有可能是一个字节，有可能是两个字节，有可能是四个字节，支持的文字非常多。

万国码：Unicode，

gbk当中两个字节存储一个中文，utf-8是三个字节对应一个中文，什么叫编码表，就是生活中的文字与计算机的存储的一种对应规则。

编码引出的问题

/**
 * @Auther: DaShu
 * @Date: 2021/6/9 20:09
 * @Description:
 */
public class GbkTest {
    public static void main(String[] args) throws IOException {
        FileReader fr = new FileReader(new File("d:\\gbk编码.txt"));
        int len = 0;
        while((len = fr.read()) != -1){
            System.out.print((char)len);//����Һô�Һ�
        }
    }
}

编码和解码的方式不一样了。所以会造成乱码。

转换流

转换流的原理

FilerReader的原理是：底层使用fileInputStream这个字符流进行读取，然后fileReader查询utf8编码表进行转码把字节转换成我们能看懂的字符，

InputStreamReader是FileReader的父类，这个是字节流通向字符流的桥梁，他可以把字节流转换为字符流，他可以使用指定的字符集，

编码不一样占用的空间也不一样，字节的读写只能使用字节流，所以任何流的底层都是字节流。FileReader只能查询系统默认码表。

OutputStramWriter

以writer结尾肯定是一个字符流，extends Writer这是字符通过字节的桥梁，可以指定编码表，

class OutputStreamWriterTest{
    public static void main(String[] args) throws Exception{
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(new File("d:\\xxx.txt")),"GBK");
        osw.write("我爱你中国，亲爱的目前");
        osw.flush();
        osw.close();
        OutputStreamWriter osw1 = new OutputStreamWriter(new FileOutputStream(new File("d:\\xxxxxx.txt")));
        osw1.write("我爱你中国，亲爱的目前");
        osw1.flush();
        osw1.close();
    }
}

InputStreamReader

字节流通向字符流的桥梁，extends Reader是一个字节流，按照指定字符集进行解码。

文件转码

序列化流和反序列化流

什么叫序列化，什么叫反序列化
把对象写入到磁盘中去保存

序列化接口是一种标记性接口

反序列化

瞬态关键字 transient

静态的是不能被序列化的，

被transient修饰的成员变量也不能序列化，

被他修饰不能被序列化，就这么点东西。

每次反序列化的时候都会验证一个class文件的序列号和序列化文件的序列号是否相同。

可以通过显示生命序列号的方法进行解决。

写这个值得目的在于不论我们如何更改我们的代码，我们的这个序列号都不会改变。这样的话，不论这个类怎么改，我都用的是这个序列号。

序列化集合

文件中保存多个对象的时候，我们可以吧多个对象存到一个集合中，对集合进行序列化和反序列化。目的：一次序列化多个对象

class ObjectOutputStreamTest{
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(new File("d:\\oos.txt")));
        List<Teacher> list = new ArrayList<>();
        list.add(new Teacher("小红","河北省石家庄市正定县"));
        list.add(new Teacher("aaa","河北省石家庄市正定县"));
        list.add(new Teacher("bbb","河北省石家庄市正定县"));
        list.add(new Teacher("ccc","河北省石家庄市正定县"));
        list.add(new Teacher("ddd","河北省石家庄市正定县"));
        oos.writeObject(list);
        oos.flush();
        oos.close();
        InputStream in;
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(new File("d:\\oos.txt")));
        List<Teacher> listTeachers = (List<Teacher>)ois.readObject();
        ois.close();
        for (Teacher listTeacher : listTeachers) {
            System.out.println(listTeacher.getAddr());
            System.out.println(listTeacher.getName());
        }
        //河北省石家庄市正定县
        //小红
        //河北省石家庄市正定县
        //aaa
        //河北省石家庄市正定县
        //bbb
        //河北省石家庄市正定县
        //ccc
        //河北省石家庄市正定县
        //ddd
    }
}

打印流PrintStream

打印流我们们天都在用

System.out.println

java.in.printStream 打印流：extends

特点：只负责数据的输出，不负责读取

这个流永远不会抛出ioException;

里边有特有的方法，println,print两个方法。

构造方法是

注意事项：

如果使用继承自父类的write方法写数据，那么查看数据的时候会查询编码表 97-a，如果使用他自己的特有的print或者println方法写数据，写的数据原样输出，比方说写97打印的就是97

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

File类和IO流

File类的概述

File类当中的成员变量

绝对路径和相对路径

File类当中常用方法介绍

File类的遍历方法和迭代

文件过滤器优化

io概述

字节流

一切皆为字节

OutputStream流

文件存储的原理

输出多个字节

数据追加（非覆盖重写）+换行

字节输入流InputStream

构造方法

常用方法进行数据读取

文件的复制

字节流读取中文

Reader字符输入流最顶层父类

Writer字符输出流最顶层父类

字符输出流的使用的过程，

close方法和flush方法的区别

写数据的其他方法

字符流的续写和换行

流异常的处理

JDK7的新特性

jdk9的流的新特性

属性集Properties

缓冲流

缓冲流的概念

缓冲流的原理

BufferedOutputStream

构造方法

BufferedInputStream

构造方法

效率测试

结论：

bufferedWriter

bufferedReader

文本内容进行排序。

转换流

字符编码和字符流。

编码引出的问题

转换流

转换流的原理

OutputStramWriter

InputStreamReader

文件转码

序列化流和反序列化流

瞬态关键字 transient

序列化集合

打印流PrintStream

热门文章

最新文章

相关电子书