Java IO详解

最新推荐文章于 2024-09-12 22:46:32 发布
最新推荐文章于 2024-09-12 22:46:32 发布
阅读量1k 收藏 4
点赞数
分类专栏： Java程序语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhliro/article/details/45201081
版权

一、流的概念

流(stream)的概念源于UNIX中管道(pipe)的概念。在UNIX中，管道是一条不间断的字节流，用来实现程序或进程间的通信，或读写外围设备、外部文件等。

流是一组有顺序的，有起点和终点的字节集合，是对数据传输的总称或抽象。 一个流，必有源端和目的端。

流机制是Java及C++中的一个重要机制，通过流我们可以自由地控制文件、内存、IO(Input输入/Output输出)设备等数据的流向。而IO流就是用于处理设备上的数据，如：硬盘、内存、键盘录入等。

一个形象的比喻是——水流，文件===程序，文件和程序之间连接一个管道，水流就在管道中形成了,自然也就出现了方向：可以流进，也可以流出

二、流的分类

  • 根据处理数据的单位不同可分为字节流和字符流
  • 根据流向的不同可分为输入流和输出流
  • 根据流的功能可以分为节点流（低级流）和处理流（高级流，也叫过滤流）

IO流

字节流：以字节为单位操作流

  • InputStream
  • OutputStream

字符流：以字符为单位操作流

  • Reader
  • Writer

输入流：从程序角度来看，输入到程序中的流

  • InputStream
  • Reader

输出流：从程序角度来看，从程序中输出的流

  • OutputStream
  • Writer

节点流：直接与数据源相连，操作流

处理流：直接使用节点流，读写不方便，为了更快的读写文件，有了处理流。处理流不直接连接数据源，而是连接在已存在的流（节点流或处理流）上，通过对数据的处理为程序提供更强大的处理能力

三、文件类

java.io包中的File类提供了管理文件与目录的功能，是文件和目录路径名的抽象表示形式。该类也是我们在使用IO流的时候经常会用到的一个类。下面列举类中常用到的方法：

|方法 |说明 ||:--------------|:----------------------------------------------------------||delete() |删除文件或目录，如果此路径名表示一个目录，则该目录必须为空才能删除 ||exists() |判断文件或目录是否存在 ||isFile() |判断是否为文件 ||isDirectory() |判断是否为目录 ||lastModified() |获取最后一次修改时间 ||length() |获得文件的长度 ||list() |返回一个字符串数组，这些字符串指定目录中的文件和子目录 ||listFiles() |返回一个抽象路径名数组，这些路径名表示此目录中的File对象 ||mkdir() |创建此抽象路径名指定的目录 ||mkdirs() |创建此抽象路径名指定的目录，包括所有必需但不存在的父目录 |

更多方法的详细信息，请参考JDK API文档查看

四、如何使用

1. 文件类
import java.io.File;
import java.io.IOException;
import java.util.Date;

/**
 * File类测试
 * @author 小明
 *
 */
public class FileTest {

    public static void main(String[] args) {
        // 创建File对象
        File file = new File("E:\\jg\\exercise_bak.txt");

        // 能否读
        System.out.println("能否读：" + file.canRead());

        // 删除
        System.out.println("删除成功：" + file.delete());

        // 重新创建文件对象
        file = new File("E:\\jg\\exercise_bak.txt");

        // 判断文件是否存在
        System.out.println("是否存在：" + file.exists());

        // 目录或文件名称
        System.out.println("名称：" + file.getName());

        // 是否目录、文件
        System.out.println("是否目录：" + file.isDirectory());
        System.out.println("是否文件：" + file.isFile());

        // 最后一次修改时间
        System.out.println("最后一次修改时间：" + new Date(file.lastModified()));

        // 文件大小
        System.out.println("文件大小：" + file.length());

        // 重新创建File对象
        file = new File("E:\\jg");

        System.out.println("文件目录列表：");
        // 返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中的文件和目录
        String[] list = file.list();
        for (String string : list) {
            System.out.println(string);
        }
        System.out.println("*******************************");

        // 返回一个抽象路径名数组，这些路径名表示此抽象路径名表示的目录中的文件对象
        File[] files = file.listFiles();
        for (File item : files) {
            if (item.isDirectory()) { // 当前File对象为目录，则遍历该目录下所有子目录与文件
                System.out.println(item.getName() + " 目录下子目录与文件：");
                String[] it = item.list();
                for (String i : it) {
                    System.out.println(i);
                }
                System.out.println("*******************************");
                continue;
            }

            System.out.println(item.getName() + "  文件");
        }

        // 重新创建File对象
        file = new File("E:\\jg\\test\\demo\\test.txt");
        if (!file.exists()) { // 文件不存在
            // 获取文件路径
            File dir = file.getParentFile();
            if (!dir.exists()) { // 目录不存在，则创建路径中所有不存在的目录
                dir.mkdirs();
            }

            try {
                // 创建空文件
                System.out.println("文件是否创建成功：" + file.createNewFile());
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}
2. 字节流
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

/**
 * 字节输入输出流测试
 * 
 * @author 小明
 *
 */
public class IOTest {

    public static void main(String[] args) {
        StringBuffer buffer = new StringBuffer(); // 字符串缓冲

        /* 输入流 */
        InputStream in = null;

        try {
            // 1. 打开输入流
            in = new FileInputStream("E:\\jg\\exercise.txt");
            // 2. 读取
            byte[] b = new byte[1024 * 4];
            int len = in.read(b); // 返回读取到的字节数，返回-1表示读取到流结尾
            while(len != -1){
                buffer.append(new String(b, 0, len)); // 将读取到的字节解析为String追加到缓冲
                len = in.read(b);
            }
            System.out.println(buffer.toString());
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 3. 释放资源，关闭输入流
            if (in != null){
                try {
                    in.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

        /* 输出流 */
        OutputStream out = null;

        try {
            File file = new File("D:\\test\\demo\\test.txt");
            if (!file.getParentFile().exists()){ // 文件路径不存在，则创建路径中所有不存在的目录
                file.getParentFile().mkdirs();
            }
            // 1. 打开输出流
            out = new FileOutputStream(file);
            // 2. 写
            out.write(buffer.toString().getBytes());
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 3. 释放输出流资源
            if (out != null){
                try {
                    out.flush();
                    out.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
3. 字符流
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer;

/**
 * 字符输入输出流测试
 * 
 * @author 小明
 *
 */
public class IOTest2 {

    public static void main(String[] args) {
        StringBuffer buffer = new StringBuffer();

        /* 输入流 */
        Reader reader = null;

        try {
            // 1. 打开流
            reader = new FileReader("E:\\jg\\exercise.txt");
            // 2. 读取
            char[] ch = new char[128]; // 缓冲区
            int len;
            do {
                len = reader.read(ch);
                if (len == -1)
                    break;
                buffer.append(new String(ch, 0, len));
            } while (len != -1);
            System.out.println(buffer.toString());
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 3. 释放资源
            if (reader != null) {
                try {
                    reader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

        /* 输出流 */

        Writer writer = null;

        try {
            // 1. 打开流
            writer = new FileWriter("d:\\test.txt");
            // 2. 写入
            writer.write(buffer.toString());
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 3. 释放资源
            if (writer != null) {
                try {
                    writer.flush();
                    writer.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

归纳总结

  • 流的使用步骤：

    1. 打开一个输入/输出流对象
    2. 读取或写入数据
    3. 释放资源，关闭输入/输出流对象

  • InputStream和OutputStream主要用来处理可以被直接读作byte的数字

  • Reader和Writer主要用来处理文本
江湖人称小明
关注
专栏目录
【JAVA基础】Java IO详解
qq_27198345的博客
09-01 1117
Java IO
32.9、java io详解1
08-08
Java IO 之字节流和字符流的区别 Java 中的 IO 操作是指对文件、网络或其他输入/输出设备的读写操作。Java 中的 IO 操作可以分为两大类：字节流和字符流。字节流和字符流是 Java 中的两种基本的 IO 操作方式，它们...
java中的io详解.
06-26
java io 输入输出详细介绍. 从菜鸟化身为高手
Java IO
weixin_34124939的博客
09-10 998
一、java io 概述 1.1 相关概念 Java IO Java IO即Java 输入输出系统。不管我们编写何种应用，都难免和各种输入输出相关的媒介打交道，其实和媒介进行IO的过程是十分复杂的，这要考虑的因素特别多，比如我们要考虑和哪种媒介进行IO（文件、控制台、网络），我们还要考虑具体和它们的通信方式（顺序、随机、二...
【网络】高级IO——五种IO模式
最新发布
2301_80224556的博客
09-12 1767
我们在本专栏前面的文章中大概学习了TCP/IP四层模型，因为我们不学网络，所以那些知识也是够用的。我们接下来要回归到我们的应用层的学习——也就是写代码。接下来，我们在接下来的学习中将学习以下内容理解五种IO模型的基本概念,重点是IO多路转接掌握select编程模型,能够实现select版本的TCP服务器掌握poll编程模型,能够实现poll版本的TCP服务器掌握epoll编程模型,能够实现epoll版本的TCP服务器理解epoll的LT模式和ET模式,
Java 基础之详解 Java IO
qq_37955980的博客
05-08 348
Java IO 基本概念 Java IO：即 Java 输入 / 输出系统。 区分 Java 的输入和输出：把自己当成程序， 当你从外边读数据到自己这里就用输入（InputStream/Reader）， 向外边写数据就用输出（OutputStream/Writer）。 Stream：Java 中将数据的输入输出抽象为流，流是一组有顺序的，单向的，有起点和终点的数据集合，就像水流。按照流中的最...
java中的io详解_java io详解
weixin_34561373的博客
02-12 197
(5)FilterReader允许过滤字符流protectedfilterReader(Readerr);(6)BufferReader接受Reader对象作为参数，并对其添加字符缓冲器，使用readline()方法可以读取一行。PublicBufferReader(Readerr);Writer类体系结构(1)FileWrite将字符类型数据写入文件，使用缺省字符编码和缓冲器大小。...
Java教程之javaIO详解
09-12
Java IO 详解 Java IO（Input/Output）是 Java 语言中用于处理输入输出操作的类库，提供了大量的类和方法来实现文件、网络、字节流等方面的输入输出操作。下面对 Java IO 中的重要知识点进行详细说明。 一、File ...
javaio详解【2】.pdf
10-03
Java IO 是Java平台中用于处理输入输出操作的重要部分，它提供了丰富的类库，使得开发者能够高效地读写数据。在Java中，IO是以流为基础进行的，数据被串行化写入输出流或从输入流读取。Java的IO体系分为字节流和字符...
JAVA IO详解
WHS-_-2022的博客
12-09 908
JAVA IO
JavaIO详解
isbn0123的博客
07-29 2666
IO/NIO/BIO 简介 无论是Socket的读写还是文件的读写，在Java层面的应用开发或者是linux系统底层开发，都属于输入input和输出output的处理，简称为IO读写。在原理上和处理流程上，都是一致的。区别在于参数的不同。 用户程序进行IO的读写，基本上会用到read&write两大系统调用。可能不同操作系统，名称不完全一样，但是功能是一样的。 先强调一个基础知识：read系统调用，并不是把数据直接从物理设备，读数据到内存。write系统调用，也不是直接把数据，写入到物理设备。 re
Java-IO详解
weixin_30827565的博客
11-21 62
IO详解 参考自： https://www.cnblogs.com/laughingQing/p/4885142.html https://www.cnblogs.com/dreamyu/p/6551137.html 一、概览 　　“流”（stream）有方向：流进（input stream）和流出（output stream）。 　　“流”有流动的最小单位：①有基于一个字节（sing...
java io详解_Java IO详解
weixin_26899879的博客
02-19 1296
IO 是什么？其实就是Java中的一种输入和输出功能，也可以理解为对文件的写入和读出的操作，只不过Java中对这种操作叫做对流的操作。而流不只是对文件进行读写，还可以对内存，网络，程度操作。一、字节与字符在Java中有输入、输出两种IO流，每种输入、输出流又分为字节流和字符流两大类。关于字节，每个字节(byte)有8bit组成。关于字符，我们可能知道代表一个汉字或者英文字母。字节与字符之间的关系J...
java IO操作知识点
qq_56350439的博客
05-02 3360
IO流的概念： IO流，将不同的输入输出，以相同的方式操作read(),write();创建不同类型的流，有不同的实现方式，不同类型的流，又有各自特有的操作方式。 无论内部如何工作，所有IO流呈现的都是相同的，简单的模式，程序中流入或流出的一系列数据。 Inputstream、Outputstream: 输入流，输出流的操作超类，支持子类以基本字节的方式操作二进制数据 java.io.InputStream抽象类：基本子类，ByteArrayInputStream,FileInputStre
【JAVA IO 详细介绍】
weixin_44273248的博客
12-20 3382
Java IO流
Java IO详解：字节流与字符流
"JAVA IO总结" Java的IO系统是Java编程中不可或缺的一部分，它提供了一种在程序和外部数据源之间传输数据的方式。本篇总结将深入探讨Java IO中的stream概念，以及字节流和字符流的基本类型。 1. Stream概念 在Java...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值