文件流

底层数据流转示意图：

 文件流：

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

public class DemoClass4IO2 {
    public static void main(String[] args) throws IOException {
        //TODO Java IO - 文件流

        /*
        * 1. File 文件类（指：文件 或者 文件夹），属于java.io.File
        * */
        //String filePath = "D:\\1_code\\myjava\\mystudy\\JavaCodeProject\\data\\io.txt";
        String filePath = "D:\\1_code\\myjava\\mystudy\\JavaCodeProject\\data";
        File file = new File(filePath);
        System.out.println(file); //D:\1_code\myjava\mystudy\JavaCodeProject\data\io.txt

        //1.1 文件对象的操作
        //TODO 判断是否是文件,因为File语法：有文件 还有文件夹的意思
        System.out.println(file.isFile()); //true

        //TODO 判断是否是文件夹
        System.out.println(file.isDirectory()); //false

        //TODO 判断文件是否存在关联
        System.out.println(file.exists()); //true

        //TODO 创建文件目录
        //file.mkdir();

        //TODO 创建文件
        //file.createNewFile();

        if(file.exists()) {
            if(file.isFile()){
                //TODO 存在文件关联
                System.out.println("文件存在，存在关联关系");
                System.out.println("文件名："+file.getName()); //文件名：io.txt
                System.out.println("文件长度："+file.length()); //文件长度：11
                System.out.println("文件最后修改时间："+file.lastModified()); //文件最后修改时间：1761026131762
                System.out.println("文件绝对路径："+file.getAbsolutePath()); //文件绝对路径：D:\1_code\myjava\mystudy\JavaCodeProject\data\io.txt

            }else if(file.isDirectory()){
                //TODO 存在文件夹关联
                System.out.println("文件夹存在，存在关联关系");
                System.out.println("文件名："+file.getName()); //文件名：data
                System.out.println("文件最后修改时间："+file.lastModified()); //文件最后修改时间：1761027185973
                System.out.println("文件绝对路径："+file.getAbsolutePath()); //文件绝对路径：D:\1_code\myjava\mystudy\JavaCodeProject\data

                //文件夹中的文件，返回文件名称集合
                String[] list = file.list();
                for (String s : list) {
                    System.out.println("遍历得到的文件名称集合："+s);
                }
                /*
                * 输出结果：
                    遍历得到的文件名称集合：io.txt
                    遍历得到的文件名称集合：newdata
                * */

                //获取文件对象（也就是问文件绝对路径）集合
                System.out.println("------------");
                File[] files = file.listFiles();
                for (File file1 : files) {
                    System.out.println("遍历得到的文件集合："+file1);
                }
                /*
                * 输出结果：
                    遍历得到的文件集合：D:\1_code\myjava\mystudy\JavaCodeProject\data\io.txt
                    遍历得到的文件集合：D:\1_code\myjava\mystudy\JavaCodeProject\data\newdata
                * */
            }
        }else{
            System.out.println("文件不存在，不存在关联关系");
            //TODO 创建文件目录
            //file.mkdir(); //data目录下多出一个newdata文件夹

            //TODO 创建文件
            //file.createNewFile(); //kfc 文件
        }
    }
}

 

字节流：

文件复制：（打开一次阀门，流转一个数据，效率低）

import java.io.*;

public class DemoClass4IO3 {
    public static void main(String[] args) {
        //TODO Java IO - 文件复制
        File srcFile = new File("D:\\1_code\\myjava\\mystudy\\JavaCodeProject\\data\\io.txt");
        File destFile = new File("D:\\1_code\\myjava\\mystudy\\JavaCodeProject\\data\\io2.txt");

        //TODO 文件输入流（管道对象）
        FileInputStream in = null;
        //TODO 文件输出流（管道对象）
        FileOutputStream out = null;

        try {
            in = new FileInputStream(srcFile);
            out = new FileOutputStream(destFile);

            //TODO 打开输入阀门，流转数据
            //int data = in.read();
            //TODO 打开输出阀门，流转数据
            //out.write(data);  //io2.txt 确实有了，但是里面内容为：h  少于：io.txt 里hello china 的内容

            //TODO 打开输入阀门，流转数据
            //int data2 = in.read();
            //TODO 打开输出阀门，流转数据
            //out.write(data2);  //io2.txt 确实有了，但是里面内容为：he  少于：io.txt 里hello china 的内容

            /*
            * 总结：
            * 问题1；代码重复性比较强
            * 问题2：多读数据的时候，会返回data=-1，在write，会乱码，产生错误数据
            *
            * 针对上面，可以使用循环遍历打开输入、输出阀门
            * */
            int data = -1;
            while((data = in.read()) != -1){
                out.write(data);
            }
            //输出结果：io2.txt里面是：hello

        }catch (IOException e){
            throw new RuntimeException(e);
        }finally {
            if(in != null){
                try{
                    in.close();
                }catch (IOException e2){
                    throw new RuntimeException(e2);
                }
            }
            if(out != null){
                try{
                    out.close();
                }catch (IOException e2){
                    throw new RuntimeException(e2);
                }
            }
        }

    }
}

 

 字节流：

缓冲流：Buffered（阀门打开2次即可）

import java.io.*;

public class DemoClass4IO4 {
    public static void main(String[] args) {
        //TODO Java IO - 文件复制-缓冲区 Buffered
        File srcFile = new File("D:\\1_code\\myjava\\mystudy\\JavaCodeProject\\data\\io.txt");
        File destFile = new File("D:\\1_code\\myjava\\mystudy\\JavaCodeProject\\data\\io3.txt");

        //TODO 文件输入流（管道对象）
        FileInputStream in = null;
        //TODO 文件输出流（管道对象）
        FileOutputStream out = null;

        //TODO 缓冲输入流（管道对象）
        BufferedInputStream buffin = null;
        //TODO 缓冲输出流（管道对象）
        BufferedOutputStream buffout = null;

        //TODO 缓冲区(水桶)
        byte[] bucket = new byte[1024];

        try {
            in = new FileInputStream(srcFile);
            out = new FileOutputStream(destFile);

            buffin = new BufferedInputStream(in);
            buffout = new BufferedOutputStream(out);

            int data = -1;
            while((data = buffin.read(bucket)) != -1){
                buffout.write(bucket, 0, data); // 0 data 参数决定：有多少数据，读取多少数据
            }

        }catch (IOException e){
            throw new RuntimeException(e);
        }finally {
            if(buffin != null){
                try{
                    buffin.close();
                }catch (IOException e2){
                    throw new RuntimeException(e2);
                }
            }
            if(buffout != null){
                try{
                    buffout.close();
                }catch (IOException e2){
                    throw new RuntimeException(e2);
                }
            }
        }
    }
}

 

字符流：

1. 说明为什么要字符流

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

public class DemoClass4IO5 {
    public static void main(String[] args) {
        //TODO Java IO - 字符流
        File srcFile = new File("D:\\1_code\\myjava\\mystudy\\JavaCodeProject\\data\\io.txt");
        File destFile = new File("D:\\1_code\\myjava\\mystudy\\JavaCodeProject\\data\\io4.txt");

        //TODO 文件输入流（管道对象）
        FileInputStream in = null;
        //TODO 文件输出流（管道对象）
        FileOutputStream out = null;

        try {
            in = new FileInputStream(srcFile);
            out = new FileOutputStream(destFile);

            int data = -1;
            /*
            while((data = in.read()) != -1){
                //out.write(data);
                System.out.println(data);
                *//*
                * 打印结果：hello 打印出来：ascII
                * byte -> -128~127
                * ascII -> 0~127
                *
                *
                104
                101
                108
                108
                111
                * 中国 打印出来：Unicode
                * 用三个字节标识除了ascII以外的字符
                * 所以一个汉字三个字节，并且都是大于127的
                *
                228
                184
                173
                229
                155
                189
                * *//*

                // 结论：遍历的data就是一个一个字节了，，这样就可以针对字节来操作，实现修改数据
                //但是这样不现实，太麻烦了，所以直接操作字符是最快捷的
            }*/

            //字符流的写法，实现修改内容（一般都是新增内容）
            StringBuilder sb = new StringBuilder();
            while((data = in.read()) != -1){
                sb.append((char)data);
            }
            sb.append(" china");
            System.out.println(sb.toString());//hello china

            //可以将字符串转为字节数组，再讲数组中的每一个字节写入文件中
            //常用的是字符操作，而不是字节,且看下面文章：

        }catch (IOException e){
            throw new RuntimeException(e);
        }finally {
            if(in != null){
                try{
                    in.close();
                }catch (IOException e2){
                    throw new RuntimeException(e2);
                }
            }
            if(out != null){
                try{
                    out.close();
                }catch (IOException e2){
                    throw new RuntimeException(e2);
                }
            }
        }

    }
}

 2.字符流的使用

 

import java.io.*;

public class DemoClass4IO5 {
    public static void main(String[] args) {
        //TODO Java IO - 字符流  把多个字节转为字符，来流转，提高效率
        File srcFile = new File("D:\\1_code\\myjava\\mystudy\\JavaCodeProject\\data\\io.txt");
        File destFile = new File("D:\\1_code\\myjava\\mystudy\\JavaCodeProject\\data\\io5.txt");

        //TODO 字符输入流（管道对象）
        BufferedReader reader = null;
        //TODO 字符输出流（管道对象）
        PrintWriter writer = null;

        try {
            reader = new BufferedReader(new FileReader(srcFile));
            writer = new PrintWriter(destFile);

            //读取文件中一行的数据（字符串）
            String line = null;
            while((line = reader.readLine()) != null){
                System.out.println("读取的是字符串："+line);
                writer.println(line);
            }
            //刷写数据
            writer.flush();  //类似：0 参数的作用； buffout.write(bucket, 0, data); // 0 data 参数决定：有多少数据，读取多少数据

        }catch (IOException e){
            throw new RuntimeException(e);
        }finally {
            if(reader != null){
                try{
                    reader.close();
                }catch (IOException e2){
                    throw new RuntimeException(e2);
                }
            }
            if(writer != null){
                writer.close();
            }
        }
    }
}