I/O 流总结

简介: I/O 流总结

第一章:I/O 文件对象

1.创建文件对象

使用绝对路径或者相对路径创建File对象

public static void main(String[] args) {
            // 绝对路径
            File f1 = new File("E:\\桌面\\测试");
            System.out.println("f1的绝对路径:" + f1.getAbsolutePath());
            // 相对路径,相对于工作目录,如果在eclipse中,就是项目目录
            File f2 = new File("yanwc.exe");
            System.out.println("f2的绝对路径:" + f2.getAbsolutePath());
            // 把f1作为父目录创建文件对象(并未真实创建)
            File f3 = new File(f1, "yanwc.txt");
            System.out.println("f3的绝对路径:" + f3.getAbsolutePath());
        }

运行结果:

f1的绝对路径:E:\桌面\测试
f2的绝对路径:F:\IDEA_gulimall\csdn_DDD_lotter\springboot-daily-crud-record\yanwc.exe
f3的绝对路径:E:\桌面\测试\yanwc.txt

2.文件常用方法

public static void main(String[] args) {
            File f = new File("E:\\桌面\\测试\\abc.txt");
            System.out.println("当前文件是:" +f);
            //文件是否存在
            System.out.println("判断是否存在:"+f.exists());
            //是否是文件夹
            System.out.println("判断是否是文件夹:"+f.isDirectory());
            //是否是文件(非文件夹)
            System.out.println("判断是否是文件:"+f.isFile());
            //文件长度
            System.out.println("获取文件的长度:"+f.length());
            //文件最后修改时间
            long time = f.lastModified();
            Date d = new Date(time);
            System.out.println("获取文件的最后修改时间:"+d);
            //设置文件修改时间为1970.1.1 08:00:00
            f.setLastModified(0);
            //文件重命名
            File f2 =new File("E:\\桌面\\测试\\abcef.txt");
            f.renameTo(f2);
            System.out.println("把abc.txt改名成了abcef.txt");
            System.out.println("注意: 需要本地有文件才可以看到对应的文件长度、修改时间等信息");
        }

运行结果:

当前文件是:E:\桌面\测试\abc.txt
判断是否存在:true
判断是否是文件夹:false
判断是否是文件:true
获取文件的长度:0
获取文件的最后修改时间:Tue Mar 07 15:23:51 CST 2023
把abc.txt改名成了abcef.txt
注意: 需要本地有文件才可以看到对应的文件长度、修改时间等信息

public static void main(String[] args) throws IOException {
            File f = new File("E:\\桌面\\测试\\abc.txt");
            // 以字符串数组的形式,返回当前文件夹下的所有文件(不包含子文件及子文件夹)
            f.list();
            // 以文件数组的形式,返回当前文件夹下的所有文件(不包含子文件及子文件夹)
            File[]fs= f.listFiles();
            // 以字符串形式返回获取所在文件夹
            f.getParent();
            // 以文件形式返回获取所在文件夹
            f.getParentFile();
            // 创建文件夹,如果父文件夹skin不存在,创建就无效
            f.mkdir();
            // 创建文件夹,如果父文件夹skin不存在,就会创建父文件夹
            f.mkdirs();
            // 创建一个空文件,如果父文件夹skin不存在,就会抛出异常
            f.createNewFile();
            // 所以创建一个空文件之前,通常都会创建父目录
            f.getParentFile().mkdirs();
            // 列出所有的盘符c: d: e: 等等
            f.listRoots();
            // 刪除文件
            f.delete();
            // JVM结束的时候,刪除文件,常用于临时文件的删除
            f.deleteOnExit();
        }

DEMO1

/**
     * 一般说来操作系统都会安装在C盘,所以会有一个 C:\WINDOWS目录。
     * 遍历这个目录下所有的文件(不用遍历子目录
     * 找出这些文件里,最大的和最小(非0)的那个文件,打印出他们的文件名
     * <p>
     * 注: 最小的文件不能是0长度
     *
     * @param args
     */
    public static void main(String[] args) {
        File file = new File("C:\\WINDOWS");
        File[] fs = file.listFiles();
       //创建最大最小用于存放文件及其文件大小
        long maxSize = 0;
        long minSize = Integer.MAX_VALUE;
        System.out.println("minSize的值" + minSize);
        File maxFile = null;
        File minFile = null;
           //循环
        for (File f : fs) {
            //f 判断 是否是文件夹
            if (f.isDirectory())
                continue;
            if (f.length() > maxSize) {
                maxSize = f.length();
                maxFile = f;
            }
            if (f.length() != 0 && f.length() < minSize) {
                minSize = f.length();
                minFile = f;
            }
        }
        System.out.println("获取到最大的文件是" + maxFile.getAbsolutePath() + "文件大小为" + maxSize+"=="+maxFile.length());
        System.out.println("获取到最小的文件是" + minFile.getAbsolutePath() + "文件大小为" + minSize);
    }
}

DEMO2

/**
     * 一般说来操作系统都会安装在C盘,所以会有一个 C:\WINDOWS目录。
     * 要求遍历子文件夹
     * 找出这些文件里,最大的和最小(非0)的那个文件,打印出他们的文件名
     * <p>
     * 注: 最小的文件不能是0长度
     *
     * @param args
     */
    static long maxSize = 0;
    static long minSize = Integer.MAX_VALUE;
    static File minFile = null;
    static File maxFile = null;
    public static void listFiles(File file) {
            //是否是文件  是则进入
            if (file.isFile()) {
                //获取最大的文件及其值
                if (file.length() > maxSize) {
                    maxSize = file.length();
                    maxFile = file;
                }
                if (file.length()!=0 &&file.length() < minSize) {
                    minFile = file;
                    minSize = file.length();
                }
                return;
            }
        //是不是文件夹 是则进入
        if (file.isDirectory()) {
//以文件数组的形式,返回当前文件夹下的所有文件(不包含子文件及子文件夹)
            File[] fs = file.listFiles();
            if (null!=fs)
                for (File f : fs) {
                    //此处可以理解为 是文件的 循环到文件 把文件放入 遍历中进行遍历
                    listFiles(f);
                }
        }
    }
    public static void main(String[] args) {
        File file = new File("C:\\桌面图标");
        listFiles(file);
        System.out.println("执行结束");
        System.out.printf("最大的文件是%s,其大小是%,d字节%n", maxFile.getAbsoluteFile(), maxFile.length());
        System.out.printf("最小的文件是%s,其大小是%,d字节%n", minFile.getAbsoluteFile(), minFile.length());
    }

第二章:I/O 什么是流

1 : 什么是流

当不同的介质之间有数据交互的时候,JAVA就使用流来实现。

数据源可以是文件,还可以是数据库,网络甚至是其他的程序

比如读取文件的数据到程序中,站在程序的角度来看,就叫做输入流

输入流: InputStream
输出流:OutputStream

2 : 文件输入流输出流

如下代码,就建立了一个文件输入流,这个流可以用来把数据从硬盘的文件,读取到JVM(内存);

创建基于文件的输入流
    FileInputStream fis = new FileInputStream(file);
       创建基于文件的输出流
     FileOutputStream fis = new FileOutputStream(file);
public static void main(String[] args) {
            try {
                File file = new File("E:\\桌面\\闫文超.txt");
                // 创建基于文件的输入流
                FileInputStream fis = new FileInputStream(file);
                // 通过这个输入流,就可以把数据从硬盘,读取到Java的虚拟机中来,也就是读取到内存中
                System.out.println("输入流"+fis);
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            try {
                File file = new File("E:\\桌面\\闫文超.txt");
                FileOutputStream fis = new FileOutputStream(file);
                // 通过这个输出流,就可以把数据从硬盘,读取到Java的虚拟机中来,也就是读取到内存中
                System.out.println("输出流"+fis);
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

第三章:I/O 字节流

ASCII码 概念点击概念即可跳转;

InputStream是字节输入流,同时也是抽象类,只提供方法声明,不提供方法的具体实现。

FileInputStream 是InputStream子类,以FileInputStream 为例进行文件读取

1. 以字节流的形式读取文件内容

public static void main(String[] args) {
            try {
                File file = new File("E:\\桌面\\闫文超.txt");
                // 创建基于文件的输入流
                FileInputStream fis = new FileInputStream(file);
                // 通过这个输入流,就可以把数据从硬盘,读取到Java的虚拟机中来,也就是读取到内存中
                byte[]  bytes=new byte[(int) file.length()];
               fis.read(bytes);
                for (byte b : bytes) {
                    System.out.println("输出位"+b);
                }
               fis.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

2.写入数据导文件夹

/**
     * 以字节流的形式向文件写入数据 中的例子,当lol2.txt不存在的时候,是会自动创建lol2.txt文件的。
     * 但是,如果是写入数据到d:/xyz/lol2.txt,而目录xyz又不存在的话,就会抛出异常。
     * 那么怎么自动创建xyz目录?
     * 如果是多层目录 d:/xyz/abc/def/lol2.txt 呢?
     *
     * @param args
     */
    public static void main(String[] args) {
        try {
            File f = new File("d:/xyz/abc/def/lol2.txt");
           File filepath=f.getParentFile();//获取文件所在目录
            //判断是否存在 不存在则进入
             if (!filepath.exists()){
                 filepath.mkdir(); //使用mkdir会抛出异常,因为该目录的父目录也不存在
                 filepath.mkdirs(); //使用mkdirs则会把不存在的目录都创建好
             }
                //创建文件夹,如果父文件夹skin不存在,创建就无效 创建有效则进入
                byte data[] = {88, 89};
                FileOutputStream fis = new FileOutputStream(f);
                fis.write(data);
                fis.close();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

第四章:I/O 关闭流的方式

第五章:I/O 字符流

第六章:I/O 中文问题

第七章:I/O 缓冲流

第八章:I/O 数据流流

第九章:I/O 对象流

第十章:I/O System.in

第十一章:I/O 联系DEMO

第十二章:I/O 字节流

第十三章:I/O 字节流

文章主要来源how2j ;主要目的加深学习的印象;


相关文章
|
6月前
|
存储 Java API
Stream流
Stream流
63 1
|
5月前
|
API
Stream流知识
Stream流知识
30 0
|
5月前
|
存储 Java API
Java——Stream流(1/2):Stream流入门、Stream流的创建(认识Stream、体验Stream流、Stream流的使用步骤、获取Stream流的方法)
Java——Stream流(1/2):Stream流入门、Stream流的创建(认识Stream、体验Stream流、Stream流的使用步骤、获取Stream流的方法)
79 0
|
6月前
|
存储 C++ iOS开发
C++ 文件和流
C++ 文件和流
42 0
java流是指在Java中用来读写数据的一组有序的数据序列,它可以将数据从一个地方带到另一个地方。java流分为输入流和输出流,输入流是从源读取数据的流,而输出流是将数据写入到目的地的流。Java流又可以分为字节流和字符流,字节流读取的最小单位是一个字节(1byte=8bit),而字符流一次可以读取一个字符(1char = 2byte = 16bit)。Java流还可以分为节点流和处理流,节点流是直接从一个源读写数据的流(这个流没有经过包装和修饰),处理流是在对节点流封装的基础上的一种流。
123 0
|
安全 Java
字节数组流和数据流
字节数组流和数据流
74 0
|
6月前
|
程序员 C++ iOS开发
c++文件和流
c++文件和流
37 0
|
SQL JavaScript 前端开发
开始使用流
Java 8 中的 Stream 俗称为流,它与 java.io 包里的 InputStream 和 OutputStream 是完全不同的概念 Stream 用于对集合对象进行各种非常便利、高效的聚合操作,或者大批量数据操作 Stream API 借助于 Lambda 表达式,极大的提高编程效率和程序可读性 同时它提供串行和并行两种模式进行汇聚操作,并发模式能够充分利用多核处理器的优势 通过下面的例子我们可以初步体会到使用 Stream 处理集合的便利性
52 1
I/O流
IO流:I的全称是Input,O的全称是Output。表示读取,流可以看做是程序传输数据的通道。 作用:解决程序请求资源,输出资源的问题。
55 0