Java IO流基础

已于 2022-09-02 19:47:00 修改
阅读量146 收藏
点赞数
分类专栏： java 文章标签： java 开发语言
于 2022-09-02 19:45:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41183751/article/details/126669444
版权

流的概念

内存与存储设备之间传输数据的通道。（数据借助流传出）

流的分类

按方向划分：

  • 输入流：将<存储设备>中的内容读入到<内存>中。
  • 输出流：将<内存>中的内容写入到<存储设备>中。

按单位划分：

  • 字节流：以字节为单位，可以读写所有数据。
  • 字符流：以字符为单位，只能读写文本数据。

按功能划分：

  • 节点流：具有实际传输数据的读写功能。
  • 过滤流：在节点流的基础之上增强功能。

字节流

字节流的父类（抽象类）:

  • InputStream：字节输入流
  • OutputStream：字节输出流

文件字节流

  • FileInputStream：

    • public int read(byte[] b) //从流中读取多个字节，将读到内容存入b数组，返回实际读到的字节数；如果达到文件的尾部，则返回-1。

    • FileInputStream的使用：

      /**
 * 演示FileInputStream的使用
 * 文件字节输入流
 */
public class FileInputStreamDemo {
    public static void main(String[] args) throws Exception{
        //1.创建FileInputStream,并指定文件路径
        FileInputStream fis = new FileInputStream("d:\\aaa.txt");
        //2.读取文件
        //fis.read();
        //2.1 单个字节读取
//        int data = 0;
//        while ((data = fis.read())!=-1){
//            System.out.println((char) data);
//        }
        //2.2 一次读取多个字节
        byte[] buf = new byte[3];
        int count = 0;
        while ((count=fis.read(buf))!=-1){
            System.out.println(new String(buf,0,count));
        }
        //3.关闭
        fis.close();
        System.out.println("closed!!");
    }
}

  • FileOutputStream：

    • public void write(byte[] b) //一次写多个字节，将b数组中的所有字节，写入输出流。

    • FileOutputStream的使用：

      /**
 * FileOutputStream的使用
 * 文件字节输出流
 */
public class FileOutputStreamDemo {
    public static void main(String[] args) throws Exception {
        //1.创建文件字节输出流对象
        FileOutputStream fos = new FileOutputStream("d:\\bbb.txt",true);
        //2.写入文件
//        fos.write(97);
//        fos.write('b');
//        fos.write('c');
        String s = "hello!";
        fos.write(s.getBytes());
        //3.关闭
        fos.close();
        System.out.println("closed!!");
    }
}

  • 文件字节流实例（实现文件复制）：

/**
 * 使用文件字节流实现文件复制
 */
public class CopyDemo {
    public static void main(String[] args) throws IOException {
        //1.创建流
        //1.1 文件字节输入流
        FileInputStream fis = new FileInputStream("d:\\aaa.txt");
        //1.2 文件字节输出流
        FileOutputStream fos = new FileOutputStream("d:\\aaa2.txt",true);
        //2. 一边读，一边写
        byte[] buf = new byte[1024];
        int count = 0;
        while ((count= fis.read(buf))!=-1){
            fos.write(buf,0,count);
        }
        fis.close();
        fos.close();
        System.out.println("copy closed!");
    }

字节缓冲流

  • 缓冲流：BufferedInputStream/BufferedOutputStream

    • 提高IO效率，减少访问磁盘的次数；
    • 数据存储在缓冲区中，flush是将缓存区的内容写入文件中，也可以直接close。

  • BufferedInputStream

    /**
 * BufferedInputStream使用
 * 使用字节缓冲流读取
 */
public class BufferedInputStreamDemo {
    public static void main(String[] args) throws Exception{
        //1. 创建BufferedInputStream
        FileInputStream fis = new FileInputStream("d:\\aaa.txt");
        BufferedInputStream bis = new BufferedInputStream(fis);
        //2. 读取
//        int data=0;
//        while ((data=bis.read())!=-1){
//            System.out.print((char) data);
//        }
        byte[] buf= new byte[1024];
        int count=0;
        while ((count= bis.read(buf))!=-1){
            System.out.println(new String(buf,0,count));
        }
        // 3. 关闭
        bis.close();
    }
}

  • BufferedOutputStream

    /**
 * 使用字节缓冲流写入文件
 * BufferedOutputStream
 */
public class BufferedOutputStreamDemo {
    public static void main(String[] args) throws Exception{
        //1.创建字节输出缓冲流
        FileOutputStream fos = new FileOutputStream("d:\\buffer.txt");
        BufferedOutputStream bos = new BufferedOutputStream(fos);
        //2.写入文件
        for (int i = 0; i < 10; i++) {
            bos.write("Hello!\r\n".getBytes()); //写入8K缓冲区
            bos.flush(); //刷新到硬盘
        }
        //3.关闭（内部会调用flush方法）
        bos.close();
    }
}

对象流

  • 对象流：ObjectOutputStream/ObjectInputStream

    • 增强了缓冲区功能
    • 增强了读写8种基本数据类型和字符串功能
    • 增强了读写对象的功能：
      • readObject() 从流中读取一个对象
      • writeObject(Object obj) 向流中写入一个对象
    • 使用流传输对象的过程称为序列化、反序列化。（将对象写入至文件中的过程称为序列化、从文件中读取出来的过程称为反序 列化）

  • 序列化实例：

    /**
 * 使用ObjectOUtputStream实现对象的序列化
 * 注意事项:
 * （1）序列化的类必须要实现Serializable接口
 * （2）序列化类中的对象属性要求实现Serializable接口
 * （3）序列化版本号ID，保证序列化的类和反序列化的类是同一个类
 * （4）使用transient（临时的）修饰属性，这个属性不能序列化
 * （5）静态属性不能被序列化
 * （6）序列化多个对象，可以借助集合实现
 */
public class ObjectOutputStreamDemo {
    public static void main(String[] args) throws  Exception{
        //1.创建对象流
        FileOutputStream fos = new FileOutputStream("d:\\stu.");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        //2.序列化（写入操作）
        Student s1 = new Student("zhangsan", 18);
        oos.writeObject(s1);
        //3.关闭
        oos.close();
        System.out.println("closed!!");
    }
}

  • 反序列化实例：

    /**
 * ObjectInputStream实现反序列化（读取重构成对象）
 */
public class ObjectInputStreamDemo {
    public static void main(String[] args) throws  Exception{
        //1.创建对象流
        FileInputStream fis = new FileInputStream("d:\\stu");
        ObjectInputStream ois = new ObjectInputStream(fis);
        //2.读取文件（反序列化）
        Student s = (Student) ois.readObject();
        //3.关闭
        ois.close();
        System.out.println(s.toString());
    }
}

字符流

  • 字符编码

    • ISO-8859-1 收录除ASCII外，还包括西欧、希腊语、泰语、阿拉伯语、希伯来语对应的文字符号。
    • UTF-8 针对Unicode码表的可变长度字符编
    • GB2312 简体中文
    • GBK 简体中文、扩充
    • BIG5 台湾，繁体中文

  • 字符流的父类（抽象类）：

    • Reader：字符输入流

    • Write：字符输出流

文件字符流

  • FileReader：

  • public int read(char[] c) //从流中读取多个字符，将读到内容存入c数组，返回实际读到的字符数；如果达到文件的尾部，则返回-1。

  • FileWriter：

  • public void write(String str) //一次写多个字符，将b数组种所有字符，写入输出流。

  • FileReader的使用：

    /**
 * 使用FileReader读取文件
 */
public class FileReaderDemo {
    public static void main(String[] args) throws Exception{
        //1.创建FileReader文件字符输入流
        FileReader fr = new FileReader("d:\\bbb.txt");
        //2.读取
        //2.1单个字符读取
//        int data=0;
//        while ((data=fr.read())!=-1){ //读取一个字符
//            System.out.print((char) data);
//        }
        //2.2多个字符读取
        char[] buf = new char[2];
        int count = 0;
        while ((count=fr.read(buf))!=-1){
            System.out.println(new String(buf,0,count));
        }
        //3.关闭
        fr.close();
    }
}

  • FileWriter的使用：

    /**
 * 使用FileWriter写入文件
 */
public class FileWriterDemo {
    public static void main(String[] args) throws Exception{
        //1.创建FileWriter对象
        FileWriter fw = new FileWriter("d:\\writer.txt");
        //2.写入
        for (int i = 0; i < 10; i++) {
            fw.write("HI~~~\r\n");
            fw.flush();
        }
        //3.关闭
        fw.close();
    }
}

  • 实现文件复制：

    /**
 * 使用FileReader和FileWriter实现文本复制，不能复制图片或者二进制文件
 * 使用字节流可以复制任意文件。
 */
public class CopyDemo02 {
    public static void main(String[] args) throws Exception{
        //1.创建FileReader和FileWriter
        FileReader fr = new FileReader("d:\\writer.txt");
        FileWriter fw = new FileWriter("d:\\writer2.txt");
        //2.读写
        int data=0;
        while ((data= fr.read())!=-1){
            fw.write(data);
            fw.flush();
        }
        //3.关闭
        fr.close();
        fw.close();
    }
}

字符缓冲流

  • 缓冲流：BufferedReader/BufferedWriter

    • 高效读写
    • 支持输入换行符
    • 可一次写一行、读一行

  • BufferedReader的使用：

    /**
 * 使用字符缓冲流读取文件
 * BufferedReader
 */
public class BufferedReaderDemo {
    public static void main(String[] args) throws Exception{
        //1.创建一个缓冲流
        FileReader fr = new FileReader("d:\\writer.txt");
        BufferedReader br = new BufferedReader(fr);
        //2.读取
        //2.1第一种方式（一次读取多个字符）
//        char[] buf = new char[1024];
//        int count = 0;
//        while ((count= br.read(buf))!=-1){
//            System.out.println(new String(buf,0,count));
//        }
        //2.2第二种方式（一次读取一行）
        String line = null;
        while ((line= br.readLine())!=null){
            System.out.println(line);
        }
        //3 关闭
        br.close();
    }
}

  • BufferedWriter的使用：

    /**
 * BufferedWriter的使用
 */
public class BufferedWriterDemo {
    public static void main(String[] args) throws Exception{
        //1.创建BufferedWriter对象
        FileWriter fw = new FileWriter("d:\\buffer.txt");
        BufferedWriter bw = new BufferedWriter(fw);
        //2.写入
        for (int i = 0; i < 10; i++) {
            bw.write("好好学习！\r\n"); //windows：\r\n 换行  linux：\n
            bw.newLine(); //写入一个换行符
            bw.flush();
        }
        //3.关闭
        bw.close();
    }
}

打印流

  • PrintWriter：

    • 封装了print() / println() 方法，支持写入后换行。
    • 支持数据原样打印。

  • PrintWriter的使用：

/**
 * PrintWriter的使用
 */
public class PrintWriterDemo {
    public static void main(String[] args) throws Exception{
        //1.创建打印流
        PrintWriter pw = new PrintWriter("d:\\print.txt");
        //2.打印
        pw.println(97);
        pw.println(31.4);
        pw.println(true);
        pw.println('a');
        //3.关闭
        pw.close();
    }
}

转换流

  • 桥转换流：InputStreamReader / OutputStreamWriter

    • 可将字节流转换为字符流。
    • 可设置字符的编码方式。

  • InputStreamReader读取文件：

    /**
 * 使用InputStreamReader读取文件，指定使用的编码
 */
public class InputStreamReaderDemo {
    public static void main(String[] args) throws Exception{
        //1.创建InputStreamReader对象
        FileInputStream fis = new FileInputStream("e:\\writer.txt");
        InputStreamReader isr = new InputStreamReader(fis,"utf-8"); //格式需与文件编码格式相同，否则会乱码
        //2.读取文件
        int data = 0;
        while ((data= isr.read())!=-1){
            System.out.println((char) data);
        }
        //3.关闭
        isr.close();
    }
}

  • OutputStreamWriter写入文件：

    /**
 * 使用OutputStreamWriter写入文件，使用指定的编码
 */
public class OutputStreamWriterDemo {
    public static void main(String[] args) throws Exception{
        //1.创建OutputStreamWriter对象
        FileOutputStream fos = new FileOutputStream("e:\\info.txt");
        OutputStreamWriter osw = new OutputStreamWriter(fos, "gbk");
        //2.写入
        for (int i = 0; i < 10; i++) {
            osw.write("桥转换流：InputStreamReader / OutputStreamWriter\n" +
                    "\n" +
                    "* 可将字节流转换为字符流。\n" +
                    "* 可设置字符的编码方式");
            osw.flush();
        }
        //3.关闭
        osw.close();
    }
}

File类

File概念

代表物理盘符中的一个文件或者文件夹。

方法：

/**
 * File类的使用
 * （1）分隔符
 * （2）文件操作
 * （3）文件夹操作
 */
public class FileDemo {
    public static void main(String[] args) throws Exception{
//        separator();
//        fileOpe();
        directoryOpe();
    }
    //(1)分隔符
    public static void separator(){
        System.out.println("路径分隔符" + File.pathSeparator);
        System.out.println("名称分隔符"+File.separator);
    }
    //(2)文件操作
    public static void fileOpe() throws Exception{
        //1. 创建文件
        File file = new File("e:\\file.txt");
        System.out.println(file.toString());
        boolean b = file.createNewFile();
        System.out.println("创建结果"+b);
        //2.删除文件
        //2.1直接删除
//        System.out.println("删除结果" + file.delete());
        //2.2使用jvm退出时删除
//        file.deleteOnExit();
//        Thread.sleep(5000);
        //3.获取文件信息
        System.out.println("获取文件的绝对路径" + file.getAbsolutePath());
        System.out.println("获取路径" + file.getPath());
        System.out.println("获取文件名称" + file.getName());
        System.out.println("获取父目录" + file.getParent());
        System.out.println("获取文件长度" + file.length());
        System.out.println("文件的创建时间" + new Date(file.lastModified()).toLocaleString());
        //4.判断
        System.out.println("是否可写" + file.canWrite());
        System.out.println("是否是文件" + file.isFile());
        System.out.println("是否隐藏"+file.isHidden());
    }
    //(3)文件夹操作
    public static void directoryOpe() throws Exception {
        //1.创建文件夹
        File dir = new File("e:\\aa\\bb\\cc");
        System.out.println(dir.toString());
        if (!dir.exists()){
//            System.out.println(dir.mkdir()); //只能创建单级目录
            System.out.println(dir.mkdirs()); //能创建多级目录
        }
        //2.删除文件夹
        //2.1直接删除（只能删除空目录）
//        System.out.println(dir.delete());
        //2.2使用jvm删除
//        dir.deleteOnExit();
//        Thread.sleep(5000);
        //3.获取文件夹信息
        System.out.println("获取绝对路径" + dir.getAbsolutePath());
        System.out.println("获取路径" + dir.getPath());
        System.out.println("获取名称" + dir.getName());
        System.out.println("获取父目录" + dir.getParent());
        System.out.println("获取创建时间" + new Date(dir.lastModified()).toLocaleString());
        //4.判断
        System.out.println("是否是文件夹"+dir.isDirectory());
        System.out.println("是否是隐藏"+dir.isHidden());
        //5.遍历
        File dir2 = new File("e:\\壁纸");
        String[] file = dir2.list();
        for (String s : file) {
            System.out.println(s);
        }
    }
}

FileFilter接口（文件过滤器）

  • public interface FileFilter

  • boolean accept(File pathname)

  • 当调用File类中的listFiles()方法时，支持传入 FileFilter接口实现类，对获取文件进行过滤，只有满足条件的文件才可出现在listFiles()方法的返回值中。

  • FileFilter的使用：

    //--------FileFilter接口的使用-----------
File[] file1 = dir2.listFiles(new FileFilter() {
    @Override
    public boolean accept(File pathname) {
        if (pathname.getName().endsWith(".png")){
            return true;
        }
            return false;
    }
});
for (File file2 : file1) {
    System.out.println(file2.getName());
}

  • 实例：递归遍历/删除文件夹

    /**
 * 案例（1）递归遍历文件夹
 * 案例（2）递归删除文件夹
 */
public class ListDemo {
    public static void main(String[] args) {
//        listDir(new File("e:\\javaCode"));
        deleDir(new File("e:\\javaCode"));
    }
    //（1）递归遍历文件夹
    public static void listDir(File f){
        File[] files = f.listFiles();
        System.out.println(f.getAbsoluteFile());
        if (files!=null&&files.length>0){
            for (File file : files) {
                if (file.isDirectory()){
                    listDir(file); //递归
                }else
                    System.out.println(file.getAbsoluteFile());
            }
        }
    }
    //（2）递归删除文件夹
    public static void deleDir(File dir){
        File[] files = dir.listFiles();
        if (files!=null&&files.length>0){
            for (File file : files) {
                if (file.isDirectory()){
                    deleDir(file);
                }
                System.out.println(file.getAbsoluteFile()+"删除"+file.delete());
            }
        }
        System.out.println(dir.getAbsoluteFile()+"删除"+dir.delete());
    }
}

总结

  • 流的概念：

    • 内存与存储设备之间传输数据的通道

  • 流的分类：

    • 输入流、输出流；字节流、字符流；节点流、过滤流；

  • 序列化、反序列化：

    • 将对象通过流写入到文件，或将对象通过流读取到内存，必须实现Serializable接口。

  • File对象：

    • 代表物理盘符中的一个文件或者文件夹。
绝不认输的程序媛
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Java-Class-FC：java.nio.charset.StandardCharsets
weixin_30897079的博客
06-27 1310
ylbtech-Java-Class-FC：java.nio.charset.StandardCharsets 1.返回顶部 2.返回顶部 1.1、import java.nio.charset.StandardCharsets; 1.2、 restTemplate.getMessageConvert...
Java IO流基础知识详解
NiShoushun的博客
03-18 514
Java IO流 前话- 自己在学习Java IO时网上查了很多资料，感觉写的都并不完善，所以特地整理了一晚上，希望整理后的资料能帮到有需要的人 文章目录Java IO流1. javaIO流概述1.1 IO流介绍1.1.1 什么是IO流？1.1.2 java中的IO流列表1.2 IO流分类1.2.1 按方向分类1.2.2 按传输单位分类1.2.3 按功能分类2.常用 java IO流使用2.1 ...
Java-字符编码-StandardCharsets类
深度安全实验室
06-21 1509
Java-字符编码-StandardCharsets类
Java-初识IO流 【理论】
AOOOOO李
12-14 364
什么是流 概念：内存与存储设备之间传输数据的通道： 流的分类 按方向【重点】： 输入流：将<存储设备>中的内容读入到<内存>中。 输出流：将<内存>中的内容写入到<存储设备>中。 按单位： 字节流：以字节为单位，可以读写所有数据。 字符流：以字符为单位，只能读写文本数据。 按功能： 节点流：具有实际传输数据的读写功能。 过滤流：在节点流的基础之上增强功能。 字节流 字节流的父类(抽象类） InputStream： 字节输入流 P
深入理解Java I/O流之BufferedInputStream类详解
最新发布
喵手的博客
05-05 1539
在 Java 开发中，IO 操作是十分常见且重要的一个内容。在 IO 操作中，类是一个十分重要的类，它可以提供缓冲和流的级联两个功能，使得读取操作变得更加高效，提供了一定的性能优化。本文将对类进行详细介绍。本文将从类的定义入手，介绍其主要的功能、使用场景和优缺点，然后从源代码解析、应用场景案例和类代码方法介绍等方面深入探讨类的内部机制和使用方法，并提供测试用例对类进行实际测试。最后对全文内容进行总结，帮助读者更好地理解类。类继承自。
java.nio.charset.StandardCharsets导入失败的问题
胖达哒的博客
01-18 542
记录一下这个离谱的问题的解决过程
StandardCharsets类在工作中的使用
虚心学习，和气编码
04-06 2647
StandardCharsets类在工作中的使用 在工作中，我们需要使用字符集的时候都会使用UTF-8。 一般时候我们会直接使用字符串。 new String(result, "UTF-8") 但是使用后发现公司的代码质量不过关，会出现警告。 StandardCharsets类就帮助我们优雅的进行字符集转换，这个类中为我们提供了很多我们需要使用的字符集的常量值，例如： /** * Constant definitions for the standard {@link Charset Charsets}
Java IO流（一）基础知识
Xinghf
04-17 1580
<!-- @font-face {font-family:宋体} @font-face {font-family:宋体} @font-face {font-family:Calibri} @font-face {font-family:"\@宋体"} p.MsoNormal, li.MsoNormal, div.MsoNormal {margin:0cm; mar
Java IO流 文件传输基础
09-02
文件传输基础是Java IO流应用的一个核心场景，通过IO流可以实现对文件的读写操作，包括创建、打开、修改和删除文件。在本文中，我们将深入探讨Java IO流在文件传输中的基础知识，特别是涉及文件编码的概念。 文件的...
java基础之IO流
06-18
java基础之IO流，基础简介知识，帮助你了解java的io技术
java基础 IO流
09-05
此文档属于本人当初学习java基础之IO流，所整理的文档。里面有字节流与字符流的比较，也有总结使用不同方式读取文档的demo。希望对你的学习有帮助，谢谢！
javaIO流基础.zip_IO流 上传 下载文件_io流 上传_io流下载_下载
09-20
在这个“javaIO流基础.zip”压缩包中，我们能看到一系列与文件上传和下载相关的Java代码示例，涵盖了多种IO流类型及其用法。 首先，`TestFileOutputStream.java`和`TestFileInputStream.java`涉及到的是文件输入流...
Java IO流和文件操作实现过程解析
08-25
Java IO流和文件操作实现过程解析是Java语言中的一种基本操作，IO流是Java中处理输入输出的基础。Java中的IO流主要包括两种类型：字节流和字符流。字节流用于处理二进制数据，而字符流用于处理文本数据。 Java中的...
JAVA学习-NIO.字符集和Charset
weixin_69763181的博客
03-21 699
在Java NIO中，字符集（Character Set）用于将字符与字节之间进行编码和解码。Java NIO提供了Charset类来表示字符集，并且支持多种常用的字符集。
Java基础之Java NIO
weixin_42414567的博客
01-12 1030
NIO Server package com.nio.server; import java.io.IOException; import java.net.InetSocketAddress; import java.nio.ByteBuffer; import java.nio.channels.*; import java.nio.charset.StandardCharsets; import java.util.Iterator; public class NIOServer {
field requires API 19(current min is 18) java.nio.charset.standardcharsets#UTF_8
u011149565的博客
04-23 4509
开发Android APP时遇到对服务器HTTP 请求所返回的 json字符串进行UTF-8转码时，出现了以上标题所示错误提示。原方法： new String(responseBody, StandardCharsets.UTF_8) 由于 StandardCharsets.UTF_8引用的  java.nio.charset.StandardCharsets 包不支持 19 以下的API
JAVA开发常用API及封装
今天又是充满希望的一天
03-25 3987
JAVA开发常用API及封装
Java IO流详解：从基础到实践
Java的IO流技术是Java编程中至关重要的部分，它涉及数据的输入/输出操作，以"流"的形式进行管理和传输。Java 2 SDK提供了丰富的流类，主要集中在java.io包中，这些类和接口构成了Java IO体系的基础。 首先，我们...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值