Java基础差缺补漏系列之I/O流系列1

冷环渊

发布于 2021-10-19 07:33:55

29300

代码可运行

文章被收录于专栏：冷环渊的全栈工程师历程冷环渊的全栈工程师历程

运行总次数：0

代码可运行

io流

每日格言：

千里之行，始于足下——老子

file类

文件，目录

文件：内存中存放的数据计算机关机后会消失，要长久的保存数据，就要使用硬盘，光盘等，为了便于数据的管理和检索，引入了文件的概念，可以有一篇文章，一段视频，一个可执行程序。

目录（文件夹）：

成千上万的文件，如果不分类的话，会很难管理，于是我们用文件夹去分类，管理。

操作系统：

如果需要查看文件/目录星系，右键属性就好了，

现在我想用java来操纵文件/目录，我该如何？

java程序最典型的特点，面向对象，java程序最擅长的就是操纵对象，盘符上的文件目录，将它们的各种信息封装，封装成一个对象，

java最擅长就是操作对象，这个对象属于—》file类

盘符上的文件—》封装为对象—？对象属于file类的对象–》有了这个对象，我们的程序就可以直接操作这个对象，通过获取文件的各种信息，还可以对文件进行操作，创建或者删除等等等.

对文件的操作：

   public static void main(String[] args) throws IOException {
        File f = new File("D:\\java工程师\\javaSE代码\\javaSE源码\\javaSE\\src\\test.txt");
        File f1 = new File("D:\\java工程师\\javaSE代码\\javaSE源码\\javaSE\\src\\test.txt");//跨平台建议使用这种
//   常用方法
        System.out.println("文件是否可读 : "+f.canRead());
        System.out.println("文件是否可写 : "+f.canWrite());
        System.out.println("文件的名字 :　"+f.getName());
        System.out.println("文件的上级目录　："+f.getParent());
        System.out.println("是否是一个目录　："+f.isDirectory());
        System.out.println("是否是一个文件　："+f.isFile());
        System.out.println("是否隐藏　："+f.isHidden());
        System.out.println("文件大小　：　"+f.length());
//        if (f.exists()){ 如果有那就删除，没有就创建
//                f.delete();
//        }else {
//            f.createNewFile();
//        }
        System.out.println(f==f1);
        System.out.println(f.equals(f1));
        //和路径相关的
        System.out.println("绝对路径 ："+f.getAbsolutePath());
        System.out.println("相对路径 ："+f.getPath());
        System.out.println("toString ："+f.toString());
        File file = new File("demo.txt");
        if (!file.exists()){
            file.createNewFile();//创建到了项目根目录里
        }
//        绝对路径指一个精确，完成的路径
        System.out.println("绝对路径 ："+file.getAbsolutePath());
//        相对路径有一个参会造物，相对这个·参照物的路径
//        相对这个位置，main方法的相对位置为项目根路径
        System.out.println("相对路径 ："+file.getPath());
//        toString的效果永远是相对路径
        System.out.println("toString ："+file.toString());


    }

对目录的操作

    public static void main(String[] args) {
        File f = new File("D:\\java工程师\\javaSE代码\\javaSE源码\\javaSE\\src");
        File f1 = new File("D:\\java工程师\\javaSE代码\\javaSE源码\\javaSE\\src");//跨平台建议使用这种
//   常用方法
        System.out.println("文件是否可读 : "+f.canRead());
        System.out.println("文件是否可写 : "+f.canWrite());
        System.out.println("文件的名字 :　"+f.getName());
        System.out.println("文件的上级目录　："+f.getParent());
        System.out.println("是否是一个目录　："+f.isDirectory());
        System.out.println("是否是一个文件　："+f.isFile());
        System.out.println("是否隐藏　："+f.isHidden());
        System.out.println("文件大小　：　"+f.length());

        File f2 = new File("D:\\java工程师\\javaSE代码\\javaSE源码\\javaSE\\src\\a\\b\\c");
//        f2.mkdir();创建单层目录
//        f2.mkdirs();创建多层目录
//        f2.delete();删除，只删除一层，如果是删除目录的话只删除没有内容的，如果有内容就不会删除
        String[] list = f.list();//遍历目录下的对应的名字
        for (String s : list) {
            System.out.println(s);
        }
        System.out.println("============");
        File[] files = f.listFiles();
        for (File file : files) {//作用相对上面发那个发，多了file对象，作用更加广泛
            System.out.println(file.getName());
        }
        }

file:封装文件/目录各种信息，对文件和目录进行操作，但是我们不可以获取到文件和目录的内容，

于是乎！io！！！流！！！

字符流

IO流体系结构：

I/O：input/output的缩写，用于处理设备之间的数据的传输

形象理解：

案例：通过java程序完成文件的复制

功能分解：使用到第一个流 file reader

功能分解1：初体验io流的文件内容读取

public static void main(String[] args) throws IOException {
//        文件--》程序
//        1.有一个文件---》创建file类对象
        File file = new File("D:\\java工程师\\javaSE代码\\javaSE源码\\javaSE\\demo.txt");
//        2.利用filereader这个流将流连接到源文件--》file流对象
        FileReader fr = new FileReader(file);
//        3.进行操作 --》读取操作
//        下面的代码我们验证了，如果到了文件的结尾，那么读取的内容为-1
/*
        int i = fr.read();
        int i2 = fr.read();
        int i3 = fr.read();
        int i4 = fr.read();
        int i5 = fr.read();
        System.out.println(i);
        System.out.println(i2);
        System.out.println(i3);
        System.out.println(i4);
        System.out.println(i5);
        */
//方法一
//        int i = fr.read();
//        while (i!=-1){
//            System.out.println(i);
//            i = fr.read();
//        }
//        方法二
        int i =0;
        while ((i = fr.read())!=-1){
            System.out.print((char) i);
        }
//        4.关闭流--》关闭
//        流，数据库，网络资源，考jvm无法帮助我们关闭，必须程序元手动关闭
        fr.close();
    }

新需求，我每次读取5个，不够我在继续读，读到没有为止。

 public static void main(String[] args) throws IOException {
        //        1.有一个文件---》创建file类对象
        File file = new File("D:\\java工程师\\javaSE代码\\javaSE源码\\javaSE\\demo.txt");
//        2.利用filereader这个流将流连接到源文件--》file流对象
        FileReader fr = new FileReader(file);
//        3.进行操作 --》读取操作
        char [] ch = new char[5];
        int len = fr.read(ch);//一次读取五个，返回值是数组中的有效长度
        while (len!=-1){
/*            方法1
        for (int i = 0; i < len; i++) {
                System.out.println(ch[i]);
            }
            System.out.println("!");
            len = fr.read(ch);*/

            String str  = new String(ch,0,len);
            System.out.println(str);
            len = fr.read(ch);
        }
//        4.关闭操作
        fr.close();
    }

利用缓冲数组，做一个操作

功能分解2：程序输出文件，filewriter

一个一个向外输出，

 public static void main(String[] args) throws IOException {
//目标文件
       File file = new File("D:\\java工程师\\javaSE代码\\javaSE源码\\javaSE\\demo01.txt");
//      fw连接到文件
        FileWriter fw = new FileWriter(file);
//开始操作
        String str = "你好，小朋友";
        for (int i = 0; i < str.length(); i++) {
            fw.write(str.charAt(i));
        }
//        关闭流
        fw.close();
    }

发现：如果目标文件不存在，会自动创建文件写入，如果存在，

new FileWriter(file);，相当于对源文件覆盖，而并不是追加

new FileWriter(file，true);为true的时候才会有追加操作

new FileWriter(file，false);为false的时候会是覆盖操作，默认也是覆盖

批量，使用缓冲数组向外输出，

package TestIO.com.hyc.IO01;

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

public class Test03 {
    public static void main(String[] args) throws IOException {
//目标文件
       File file = new File("D:\\java工程师\\javaSE代码\\javaSE源码\\javaSE\\demo01.txt");
//      fw连接到文件
        FileWriter fw = new FileWriter(file,true);//追加

//开始操作
        String str = "老子开心";
        char[] ch =str.toCharArray();
        fw.write(ch);

//        关闭流
        fw.close();
    }
}

接下来是合并操作！

使用reader和writer完成文件复制

package TestIO.com.hyc.IO01;


import java.io.*;

public class Test04 {
    public static void main(String[] args) throws IOException {
//        创建file类
//        一个复制本体，一个是接受复制
        File file = new File("D:\\java工程师\\javaSE代码\\javaSE源码\\javaSE\\demo01.txt");
        File file2 = new File("D:\\java工程师\\javaSE代码\\javaSE源码\\javaSE\\demo02.txt");
//        创建输出流
        FileReader reader = new FileReader(file);
//        FileReader reader1 = new FileReader(file2);
        FileWriter writer = new FileWriter(file2,true);//用追加的形式不用覆盖的形式

        //region 1.一个一个字符的形式
        int n = reader.read();
        while (n!=-1){
                writer.write(n);
                n = reader.read();
        }
        //endregion
        //region 2.缓冲数组的形式
        char[] ch = new char[5];
        int len = reader.read(ch);
        while (len!=-1){
            writer.write(ch,0,len);//输出缓冲数组有效的长度
            len = reader.read(ch);
        }

        //region 3.缓冲数组转成字符串的形式
        char[] ch1 = new char[5];
        int len1 = reader.read(ch1);
        while (len1!=-1){
            String s =new String(ch1,0,len1);
            writer.write(s);//输出缓冲数组有效的长度
            len1 = reader.read(ch1);
            System.out.println(len1);
        }
        //endregion
//关闭流，后用先关
        writer.close();
        reader.close();

    }
}