Java-I/O流

最新推荐文章于 2024-10-08 21:30:52 发布
最新推荐文章于 2024-10-08 21:30:52 发布
阅读量103 收藏
点赞数
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/pmc0_0/article/details/114292474
版权

在这里插入图片描述

IO流的分类方式：

一种方式是按照流的方向进行分类:

  • 往内存中去,叫做输入(Input)，或者叫做读(Read)
  • 从内存中出来，叫做输出(Output)，或者叫做写(Write)

另一种方式是按照读取数据方式不同进行分类:

  • 有的流是按照字节的方式读取教据，一次读取1个字节byte，等同于一次读取8个二进制位，这种流是方能的，什么类型的文件都可以读取。包括:文本文件（xxx.txt），图片，声音文件，视频。
  • 有的流是按照字符的方式读取数据的，一次读取一个字符，这种流是为了方便读取普通文本文件而存在的，这种流不能读取:图片、声音、视频等文件。只能读取纯文本文件（xxx.txt），连word文件都无法读取。

字符流和字节流的不同：

“a我”（在windows操作系统里面一个汉字占两个字节，a字母占一个字节，在Java中’a’字符（也就是char类型是两个字节的）占两个字节）
采用字符流：第一次读’a’字符，第二次读’我’字符
采用字节流：第一次读第一个字节（也就是’a’字符，这个文件不关Java的事，文件在操作系统中，就只是占用一个字节）,第二次读第二个字节（我字符的一半）,第三次读第三个字节（我字符的另一半）

Java I/O流有四大顶级抽象类

  • java.io.Inputstream (字节输入流)

  • java.io.outputstream (字节输出流)

  • java.io.Reader (字符输入流)

  • java.io.Writer (字符输出流)

注意:在Java中只要"类名"以stream结尾的都是字节流。以"Reader/Writer"结尾的都是字符流（看结尾）。
所有的流都实现了java.io.Closeable接口，都是可关闭的，都有close()方法。用完流一定要关闭。
所有的输出流都实现了java.io.Flushable接口，都是可刷新的，都有flush()方法。输出流在最终输出之后，一定要记得flush()刷新一下。这个刷新表示将流通道当中剩余未输出的数据强行输出完，刷新的作用就是清空管道。

我们要掌握的流有16个

文件流:

  • java.io.FileInputStream
  • java.io.FileOutputStream
  • java.io.FileReader
  • java.io.FileWriter

转换流:(将字节流转换成字符流)

  • java.io.InputStreamReader
  • java.io.OutputStreamWriter

缓冲流:

  • java.io.BufferedReader
  • java.io.BufferedWriter
  • java.io.BufferedInputStream
  • java.io.BufferedOutputStream

数据流:

  • java.io.DataInputStream
  • java.io.DataOutputStream

标准输出流:

  • java.io.PrintWriter
  • java.io.PrintStream

对象流:

  • java.io.ObjectInputStream
  • java.io.ObjectOutputStream

FileInputStream

package IO;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

// 文件字节输入流
public class FileInputStreamTest {
    public static void main(String[] args) {
        FileInputStream fileInputStream = null; // 提升fileInputStream变量作用域方便后面finally语句的文件流关闭
        try {
            /*
            第一个 \ 是转义符，文件路径表示不能单独出现，会被识别成转义符而不是路径符号
            单独用的话可以用 /
            */
            fileInputStream = new FileInputStream("D:/springboot-study/Demo01/src/IO/pang.txt");
            while (true){
                // read()：从这个输入流读取一个字节的数据。如果没有数据读取就返回-1
                int readData = fileInputStream.read();
                if(readData == -1){
                    break;
                }
                System.out.println(readData);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(fileInputStream != null) {
                try {
                    /*防止空指针异常，关闭流的前提是:流不是空，流是null的时候没必要关闭。因为流没有被初始化，
                    也就是fileInputStream = new FileInputStream("D:/springboot-study/Demo01/src/IO/pang.txt")异常的情况下不用关闭，
                    不然会报空指针异常
                    */
                    fileInputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

package IO;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

/**
* int read( byte[] b)
*一次最多读取b.Length个字节。
*减少硬盘和内存的交互，提高程序的执行效率，往byte[]数组当中读。
*/
public class FileInputStreamTest01 {
    public static void main(String[] args) {
        FileInputStream fileInputStream = null;
        try {
            fileInputStream = new FileInputStream("\\pang");

            byte[] bytes = new byte[9];
            int readCount = 0;
            // read（byte[] b ）往数组里面传字符串，返回值是读到的字符个数
            while ((readCount = fileInputStream.read(bytes)) != -1){
                // 将byte数组转化为字符串，读到多少个转化多少个
                System.out.println(new String(bytes, 0, readCount));
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(fileInputStream != null){
                try {
                    fileInputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

FileInputStream常用方法：

package IO;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class FileInputStreamTest01 {
    public static void main(String[] args) {
        FileInputStream fileInputStream = null;
        try {
            fileInputStream = new FileInputStream("src\\IO\\pang.txt");

            byte[] bytes = new byte[fileInputStream.available()];// available()返回未读的字节数,不适用于大文件，初始化后第一次就是计算总字节数
                fileInputStream.read(bytes);// 读一次就能读完
                System.out.println(new String(bytes));
                
			/*// skip(3) 跳过三个字节不读
            fileInputStream.skip(3);
            System.out.println(fileInputStream.read());*/

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(fileInputStream != null){
                try {
                    fileInputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

FileOutputStream

package IO;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileOutputStreamTest {
    public static void main(String[] args) {
        FileOutputStream fileOutputStream = null;
        try {
            // append参数置true，写操作不会清空文件从头写，而是在文件末尾以追加等的方式进行写
            fileOutputStream = new FileOutputStream("src/IO/lol.txt",true);
            byte[] bytes = {33,11,99};
            
            // off:起始位置，写的长度
            fileOutputStream.write(bytes,0,3);

            // 写完后要刷新
            fileOutputStream.flush();

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if(fileOutputStream != null){
                try {
                    fileOutputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

万能的文件复制代码

package IO;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
/*
* 把pang.txt内容复制到lol.txt中
* */
public class CopyTest {
    public static void main(String[] args) {
        FileInputStream fileInputStream = null;
        FileOutputStream fileOutputStream = null;


        try {
            fileOutputStream = new FileOutputStream("src/IO/lol.txt");
            fileInputStream = new FileInputStream("src/IO/pang.txt");

            byte[] bytes = new byte[1024 * 1024]; // 1MB
            int readCount = 0;
            while ((readCount = fileInputStream.read(bytes)) != -1){
                fileOutputStream.write(bytes,0,readCount);
            }
            fileOutputStream.flush();
            System.out.println("复制成功");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 要分开处理，一起try因为第一次异常，代码终止，第二个就不会执行关闭操作
            if(fileInputStream != null){
                try {
                    fileInputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            if(fileOutputStream != null){
                try {
                    fileOutputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

转换流

package IO;

import java.io.*;

/*
* 转换流的用法
* */
public class InputStreamReaderTest {
    public static void main(String[] args) {
        try {
            // 看源码发现BufferedReader（）的构造方法需要一个Reader类对象，这时候要转化流把InputStream转化为Reader
            BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("src/IO/lol.txt")));
            String s = null;
            while ((s = br.readLine()) != null){
                System.out.println(s);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

对象流

序列化 : （Serialize）java对象存储到文件中。将java对象的状态保存下来的过程。
反序列化: （DeSerialize）将硬盘上的数据重新恢复到内存当中，恢复成java对象。

package IO;

import java.io.Serializable;
// java虚拟机先通过类名判别，类名一样就通过序列号判别是不是同一个类
// 要实现Serializable接口才能参加序列化
public class People implements Serializable {

    /*
    过了很久,People这个类源代码改动了。
    源代码改动之后，需要重新编译，编译之后生成了全新的字节码文件。
    并且class文件再次运行的时候，java虚拟机生成的序列化版本号也会发生相应的改变。反序列化就会失败
    Java虚拟机看到erializable接口之后，会自动生成一个序列化版本号。
    这里没有手动写出来，java虚拟机会默认提供这个序列化版本号。
    建议将序列化版本号手动的写出来。不建议自动生成
    */

    private static final long serialVersionUID = 21654135L;


    private transient String name; // transient 游离的，这个属性不参加序列化，反序列化的时候得到的name为null
    private String id;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }


    @Override
    public String toString() {
        return "People{" +
                "name='" + name + '\'' +
                ", id='" + id + '\'' +
                '}';
    }

    public People(String name, String id) {
        this.name = name;
        this.id = id;
    }
}

package IO;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;

public class ObjectOutputStreamTest {
    public static void main(String[] args) throws IOException {
        People people = new People();
        //序列化
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("src/IO/jian.txt"));
        //序列化对象
        oos.writeObject(people);

        // 刷新
        oos.flush();
        // 关闭
        oos.close();

    }
}

package IO;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;

public class ObjectInputStreamTest {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //反序列化
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("src/IO/jian.txt"));
        Object object = ois.readObject();
        System.out.println(object.toString());
        ois.close();
    }
}
pmc0_0
关注
专栏目录
Java使用I/O流读取文件内容的方法详解
08-25
Java使用I/O流读取文件内容的方法详解 Java使用I/O流读取文件内容的方法是Java编程中常用的文件读取方式。该方法可以将文件内容读取到程序中，并对其进行处理和分析。在Java中，I/O流是指数据流向某个对象的数据...
Java中I/O流对文件进行复制粘贴及可能会出现的问题
12-20
需求：将E:\电脑桌面壁纸... //创建字节输入流对象,关联数据源文件路径 FileInputStream fis = new FileInputStream("E:\\电脑桌面壁纸\\MisakaMikoto.jpg"); //创建字节输出流对象,关联目的地文件路径 FileOutputSt
JAVA I/O流(超详细)
wu_ry的博客
03-08 1641
File类能够实现对文件和目录的创建、删除等基础性操作，但是无法实现对文件内容的操作，也就是无法实现对文件的读写。而java中的I/O流能够方便地实现数据的输入和输出，是实现文件读写的基础。流，是指一连串流动的字符，是以先进先出的方式发送和接收数据的通道。既然是流，必然有源端和目的的端，它们可以是计算机内存的某些区域，也可以是磁盘、文件等，甚至可以是Internet上的某个统一资源定位符。所谓I/O流就是实现数据输入和输出的流，在I/O流的基础上，可以实现对文件的读写操作。那么文件的读写指什么？
Java I/O流详解
qq_28791753的博客
03-21 2390
JAVA I/O流详解，字节流，字符流
Java之I/O流（最详细的I/O流总结）
熊凯瑞的博客
05-15 8115
I/O流I/O流1、定义2、分类2.1 字节流和字符流2.2 输入流和输出流2.3 节点流和处理流3、结构4、字节流4.1 定义4.2 说明4.3 字节流概述4.4 InputStream的常用方法4.5 OutputStream的常用方法5、字节流读写文件5.1 说明5.2 注意5.3 字节输入流——相关代码5.4 字节输出流——相关代码6、文件的拷贝6.1 需求6.2 分析6.3 注意6.4 快捷键6.5 相关代码7、字节流的缓冲区7. 相关代码8、字节缓冲流8.1 说明8.2 特点8.3 相关代码8.
[JDK1.8] Java-I/O流使用概述
vivisoul的专栏
06-14 2255
@@@
Java核心技术【二十一】Java的I/O流处理：文件的读写操作
技术管理修行
07-09 1103
Java的I/O流是一组用于读写数据的类，它们位于java.io包中。根据处理数据类型的不同，Java的I/O流分为字节流和字符流。字节流：以字节为单位处理数据，主要用于处理二进制文件，如图片、音频、视频等。字节流的抽象基类为和。字符流：以字符为单位处理数据，主要用于处理文本文件。字符流的抽象基类为Reader和Writer。
Java——I/O流（一）：字节流（概念理解+应用举例）
热门推荐
★★光亭★★
07-19 1万+
Java——I/O流（一）：字节流（概念理解+应用举例）
Java——5个关于Java中I/O流的面试题
★★光亭★★
06-02 7200
Java——5个关于Java中I/O流的面试题
Java-Java I/O流解读之基于字节的I / O和字节流
小工匠
09-06 6202
概述 File and Directory Class javaioFile Pre-JDK 7 Verifying Properties of a FileDirectory List Directory List Directory with Filter Class javaniofilePath JDK 7 Stream IO in Standard IO javaio Package 标准
java I/O流部分习题及答案解析
weixin_52796601的博客
12-17 7919
1、 下列选项中，哪一个不是InputStream的直接子类（ ） A、ByteArrayInputStream B、FileInputStream C、BufferedInputStream D、PipedInputStream 1、 下列选项中，哪个类是用来读取文本的字符流？（ ） A、FileReader B、FileWriter C、FileInputStream D、FileOutputStream 2、 当文件不存在或不可读时，使用FileInputStream读取文件会报下列哪一种错误（
Java I/O (Input/Output)——文件字节流
窗外风景随心变幻
08-06 3907
Java I/O（输入/输出）是 Java 程序中用于处理数据输入和输出的重要部分。输入流（Input Streams）：用于从数据源读取数据。常见的输入流包括（从文件读取）、（提高读取效率）等。输出流（Output Streams）：用于将数据写入到目的地。例如（向文件写入）、（提高写入效率）。字符流（Reader 和 Writer）：处理字符数据，更适合处理文本。如FileReader和FileWriter。缓冲流（Buffered Streams）：通过缓冲区来减少实际的 I/O 操作次数，提高性能。
Java I/O 流代码实例大全（01~09）
07-27
Java I/O 流代码实例大全（01~09） File、FileInputStream、FileOutputStream、FileReader、FileWriter、BufferedInputStream、BufferedOutputStream、BufferedReader、BufferedWriter
java基础之I/O流
10-12
Java中的I/O流是程序与外部数据交互的重要机制，它允许数据在程序、文件、网络等之间流动。I/O流分为两大类：字符流（Character Stream）和字节流（Byte Stream），每类又分为输入流（Input Stream）和输出流...
JDK1.0主要特性
FoolRabbit的专栏
10-06 737
JDK1.0主要特性。
2024Java最新面试题总结（针对于一些小厂、中厂）
weixin_62375676的博客
10-07 1515
2024最新Java面试题，针对一些小厂，中厂
已解决-Sentinel控制台明明正常启动，扫描不到客户端应用
最新发布
qq_46248151的博客
10-08 673
经排查才发现，我在启动了Sentinel控制台之后，对SpringBoot应用做了配置的更新，于是重启了SpringBoot服务，这时SpringBoot是没有任何访问的。今天启动Sentinel控制台的时候，明明启动成功，无报错，浏览器能正常访问，但就是无论如何都刷新不出来应用。
Spring Boot新闻推荐系统设计与实现
2402_85758936的博客
10-04 1654
目前，界面设计已经成为对软件质量进行评价的一条关键指标，一个好的用户界面可以使用户使用系统的信心和兴趣增加，从而使工作效率提高，JSP技术是将JAVA语言作为脚本语言的，JSP网页给整个服务器端的JAVA库单元提供了一个接口用来服务HTTP的应用程序。一旦输入系统的数据不正确，那么处理后的输出就会扩大这些错误，因此输入的数据的准确性对整个系统的性能起着决定性意义。输出是由电脑对输入的基本信息进行解决，生成高质量的有效信息，并使之具有一定的格式，提供给管理者使用，这是输出设计的主要责任和目标。
Java JDK I/O流详解：文件输入/输出
Java I/O流体系构建了一个层次结构，允许以过滤器流的形式添加额外的功能。比如，可以使用`BufferedInputStream`或`BufferedReader`来提高读写效率，使用`DataInputStream`和`DataOutputStream`进行基本类型的数据...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值