Java IO常见用法

最新推荐文章于 2022-08-11 17:02:21 发布
最新推荐文章于 2022-08-11 17:02:21 发布
阅读量198 收藏 3
点赞数 2
分类专栏： JAVA
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40553042/article/details/109137890
版权

初始IO流

I/O流(Input/Output)流，通常用于处理设备间的数据传输，如读写文件，网路通讯等，如下图演示文件读写:
在这里插入图片描述
简单来说就是Java程序将磁盘上的文件通过流读到内存层面称为Input流(输入流)；Java程序将内存层面的数据通过流持久化到磁盘文件称为Output流(输出流)

流的分类

按操作数据单位:字节流、字符流
按数据的流向:输入流、输出流
按流的角色:节点流、处理流

流的体系结构

在这里插入图片描述
节点流以及处理流都继承抽象基类，只需实例化节点流或处理流即可对文件进行操作，除开抽象基类，节点流和处理流使用步骤基本一致。而节点流也是最基础的流处理类，处理流则是包裹在节点流外层，提升读写的效率。所以在开发中，多使用缓冲流(处理流)

文件操作

  • 文件读入
    /**
     * 文件读入
     * @throws Exception
     */
    @Test
    public void  myTest()  throws  Exception {

        File file=new File("test.txt");
        //字符读入流
        FileReader reader=new FileReader(file);

        char[]data=new char[5];
        //返回每次读到char[]中的字符个数，如果读到文件末尾，则返回-1
        int len ;
        while ((len=reader.read(data))!=-1){
            String str=new String(data,0,len);//这里的len是指读到char[]中的字符个数，而不是char[]的长度
            System.out.println(str);
        }
    }
  • 文件写出
/**
     * 文件写出
     * @throws IOException
     */
    @Test
    public void testWriter()throws  IOException{

        //如果文件不存在，在流写入时会自动创建
        File file=new File("my.txt");

        //写出流:append:默认为false，对原有文件进行覆盖;若为true，对原有文件进行追加
        FileWriter writer=new FileWriter(file,false);

        writer.write("helloworld\n");
        writer.write("helloxf");

        writer.close();
    }
  • 文件数据读写
/**
     * 文件数据读写
     */
    @Test
    public  void  testWriteAndRead(){

        File  srcFile=new File("test.txt");
        File  destFile=new File("my.txt");
        FileReader reader=null;
        FileWriter writer=null;
        try {
            //读入流
             reader=new FileReader(srcFile);
            //写出流
            writer=new FileWriter(destFile,true);

            //数据的读入和输出
            char[]data=new char[5]; //记录每次读入到数组的字符个数
            int len;
            while ((len=reader.read(data))!=-1){

                writer.write(data,0,len);  //输出len个数据
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (writer!=null)
                writer.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (reader!=null)
                reader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
  • 图片复制
 @Test
    public void  transferImg(){
        File  srcImg =new File("xf.png");
        File  destImg =new File("xf2.png");
        FileInputStream inputStream=null;
        FileOutputStream outputStream=null;
        try {
            inputStream=new FileInputStream(srcImg);

             outputStream=new FileOutputStream(destImg);

            byte[]data=new byte[100];
            int len;
            while ((len=inputStream.read(data))!=-1){

                outputStream.write(data,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (inputStream!=null){
                try {
                    inputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (outputStream!=null){
                try {
                    outputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

对于文本文件(.txt,.c++,.js)，用字符流处理(FileReader/FileWriter)；对于非文本文件(.jpg,.jar)，用字节流处理(FileInputStream/FileOutputStream)

缓冲流的使用

/**
 * 缓冲流的使用:提升读写的效率
 * BufferInputStream
 */
public class BufferTest {

    /**
     * 缓冲流处理
     * @param file1
     * @param file2
     */
    public void copyBufferedStream(String file1,String file2){
        FileInputStream inputStream=null;
        FileOutputStream outputStream=null;

        BufferedInputStream bufferedInputStream=null;

        BufferedOutputStream bufferedOutputStream=null;
        try {
            File srcFile=new File(file1);
            File destFile=new File(file2);
            inputStream=new FileInputStream(srcFile);
            outputStream=new FileOutputStream(destFile);

            //包装缓冲流
            bufferedInputStream=new BufferedInputStream(inputStream);
            bufferedOutputStream=new BufferedOutputStream(outputStream);
            byte[]data=new byte[1024];
            int len;
            while ((len=bufferedInputStream.read(data))!=-1){
                bufferedOutputStream.write(data,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (bufferedInputStream!=null){
                try {
                    bufferedInputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (bufferedOutputStream!=null){
                try {
                    bufferedOutputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }


    }
    /**
     * 字节流处理
     * @param file1
     * @param file2
     */
    public void copyStream(String file1,String file2){

        FileInputStream inputStream=null;
        FileOutputStream outputStream=null;

        try {
            File srcFile=new File(file1);
            File destFile=new File(file2);
            inputStream=new FileInputStream(srcFile);
            outputStream=new FileOutputStream(destFile);


            byte[]data=new byte[1024];
            int len;
            while ((len=inputStream.read(data))!=-1){
                outputStream.write(data,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //字节流测试
            if (inputStream!=null){
                try {
                    inputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (outputStream!=null){
                try {
                    outputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    @Test
    public void  testStream(){

        long startTime=System.currentTimeMillis();
        String str1="E:\\xf\\resQuality.jar";
        String str2="E:\\xf\\resQuality1.jar";
        copyBufferedStream(str1,str2);
	    //copyStream(str1,str2);
        long endTime=System.currentTimeMillis();

        System.out.println("复制文件花费:"+(endTime-startTime)+"ms");
    }

}

经过测试发现，加上缓冲流文件操作的效率提升近3倍，所以在开发中，一般多选择缓冲流(处理流的一种)居多

处理流

前面提到缓冲流，也是处理流的一种，除此之外，处理流也还有其他

  • 转换流
    属于字符流，提供字符与字节的转换
    InputStreamReader:将一个字节的输入流转为字符的输入流
    OutputStreamWriter:将一个字符的输出路转为字节的输出流
    接着我们尝试实现用转换流实现文件的读写
    在这里插入图片描述
@Test
    public void  convertFileContent()throws  IOException{
        //1.造流，造文件
        File srcFile=new File("utf-8.txt");
        File destFile=new File("gbk.txt");

        FileInputStream inputStream=new FileInputStream(srcFile);

        FileOutputStream outputStream=new FileOutputStream(destFile);

        InputStreamReader inputStreamReader=new InputStreamReader(inputStream,"utf-8");

        OutputStreamWriter outputStreamWriter=new OutputStreamWriter(outputStream,"gbk");

        //2.数据读写
        char[]data=new char[20];

        int len;
        while ((len=inputStreamReader.read(data))!=-1){
            outputStreamWriter.write(data,0,len);
        }

        //3.资源关闭
        inputStreamReader.close();
        outputStreamWriter.close(); 
    }

实现将utf-8文件转为gbk格式文件后，我们用IDEA打开，会出现乱码，这就实现了上述需求
在这里插入图片描述

对象流

ObjectInputStream和ObjectOutputStream；用于存储和读取基本数据类型或对象的处理流，并且实现对象序列化和反序列化的过程。
序列化:将Java对象转化为与平台无关的二进制流保存到磁盘或通过网络进行传输，使用ObjectOutputStream实现
反序列化:通过读取文件或网络获取对象二进制流并还原为Java对象的过程；使用ObjectInputStrea实现
注:要能实现对象序列化和反序列化的前提就是该对象支持序列化机制，具体做法就是使该Java对象实现Serializable接口，并提供一个全局序列化版本号，类的各个属性也支持序列化机制(默认情况下，基本数据类型支持序列化机制)。例如下面的Java对象:

/**
 * User类支持序列化机制
 */
public class User implements Serializable {

    public  static final long serialVersionUID = 21321312312L; //序列版本号
    private  int id;
    private  String username;
    private  String password;

    public User() {
    }

    public User(int id, String username, String password) {
        this.id = id;
        this.username = username;
        this.password = password;
    }

    public int getId() {
        return id;
    }

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

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

第三方Jar包支持文件操作

上面我们都是自己通过流来对文件进行操作，步骤都代替都基本一致:获取文件->创建流->数据的读写->关闭资源。但实际开发中，我们可以直接借用第三方提供的Jar包实现对文件的操作，底层封装了文件的操作的以上步骤，我们只需调用相应的方法即可。

  • 导入依赖
  <dependency>
      <groupId>commons-io</groupId>
      <artifactId>commons-io</artifactId>
      <version>2.4</version>
    </dependency>
  • 文件复制
 /**
     * FileUtils操作文件
     * @param args
     */
    public static void main(String[] args) {
        //通过工具类获取File对象
        File file1 = FileUtils.getFile("my.txt");

        File file2 = FileUtils.getFile("my2.txt");

        //文件复制

        try {
            FileUtils.copyFile(file1,file2);
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
  • copyFile源码
private static void doCopyFile(File srcFile, File destFile, boolean preserveFileDate) throws IOException {
        if (destFile.exists() && destFile.isDirectory()) {
            throw new IOException("Destination '" + destFile + "' exists but is a directory");
        } else {
            FileInputStream fis = null;
            FileOutputStream fos = null;
            FileChannel input = null;
            FileChannel output = null;

            try {
                fis = new FileInputStream(srcFile);
                fos = new FileOutputStream(destFile);
                input = fis.getChannel();
                output = fos.getChannel();
                long size = input.size();
                long pos = 0L;

                for(long count = 0L; pos < size; pos += output.transferFrom(input, pos, count)) {
                    count = size - pos > 31457280L ? 31457280L : size - pos;
                }
            } finally {
                IOUtils.closeQuietly(output);
                IOUtils.closeQuietly(fos);
                IOUtils.closeQuietly(input);
                IOUtils.closeQuietly(fis);
            }

            if (srcFile.length() != destFile.length()) {
                throw new IOException("Failed to copy full contents from '" + srcFile + "' to '" + destFile + "'");
            } else {
                if (preserveFileDate) {
                    destFile.setLastModified(srcFile.lastModified());
                }

            }
        }
    }

通过源码我们看到，底层封装了前面的文件操作的步骤，并在该基础上，提供了更多新的特性，封装许多方法，第三方提供的API更强大，推荐在项目中使用。
在这里插入图片描述

总结

了解流的概念，熟练使用jdk提供的API来操作文件的读写。熟悉流的分类，并通过导入第三方工具包，实现对文件的操作

我的鱼要死了
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Java IO
weixin_34124939的博客
09-10 942
一、java io 概述 1.1 相关概念 Java IO Java IO即Java 输入输出系统。不管我们编写何种应用，都难免和各种输入输出相关的媒介打交道，其实和媒介进行IO的过程是十分复杂的，这要考虑的因素特别多，比如我们要考虑和哪种媒介进行IO（文件、控制台、网络），我们还要考虑具体和它们的通信方式（顺序、随机、二...
JavaIO流基础使用
qq_57404736的博客
10-10 629
JavaIO流基础使用
Java之IO流使用
y516369的博客
07-27 291
Java之IO流的使用
Java io流的使用操作
H3542561135的博客
08-11 298
字节流有利于非中文文档的读写 例如图文文档 图片。Io流是操作文件内容的 File是操作文件结构的。了解io流 什么是io流 io流即输入输出流。
Java I/O各种流使用方法及编程举例
妖精小狗的博客
08-05 1315
字节流： 输入流：FileInputStream 输出流：FileOutputStream 编程举例： import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; public c...
JAVA_IO详解_包括讲解IO中各种流及其用法.pdf
06-18
java IO流总结文档。总要总结了 java IO 流的主要基本操作和使用到的类及方法。对于入门比较有用，如果对 IO 流比较了解，就没必要看了。
java面试题库2021.pdf
05-22
④JSTL、 DisplayTag 等常见标签库的用法 3、 Web 编程原理 ① HTTP 协议 ②请求/相应架构原理 ③web 容器 四、 JDBC 编程 1、 SQL 基础 2、 JDBC 基础 ①数据库 ②数据库连接池 ③事物管理， 批处理 3、 JDBC 进阶 ...
Java基础语法面试题.docx
最新发布
08-06
集合框架：涵盖Java中的List、Set、Map等集合类型，以及它们的特性和用法。 线程和并发：涵盖多线程编程、线程同步、线程安全等相关概念。 IO操作：解释如何进行文件读写、输入输出流、序列化等操作。 Java虚拟机...
JAVA基础课程讲义
08-30
JAVA.IO包相关流对象用法总结(尚学堂1002班王鑫) 165 IO中其他常用类 165 File类 165 RandomAccessFile 166 思考作业 166 上机作业 166 提高课外作业 166 第九章 多线程技术 167 基本概念 167 程序 167 进程 167 ...
java技术储备，如何提升自己
02-25
4. Java虚拟机参数配置：熟悉常见的 JVM 输入参数，了解如何配置 JVM parameters 来优化 Java 应用程序的性能。 5. GC 停顿：了解 GC 停顿的原因和解决方案，包括 Full GC、Minor GC、Mixed GC 等。 设计模式 1. ...
Java IO的常用方法
chenyl
02-13 207
文件复制 1 使用IO复制 public static void ioCopy(String pathIn,String pathOut) throws IOException { BufferedInputStream inputStream = new BufferedInputStream(new FileInputStream(pathIn)); BufferedOutpu...
Java：一个线程安全io流输出到txt文件的简单实现
提笔忘字的帝国
03-25 609
一个线程安全io流输出到txt文件的简单实现
Java中的IO流总结
乔治在哪里
10-29 257
javaIO中的类使用方法
u011521890的专栏
10-11 575
/** ObjectInputStream、 ObjectOutputStream 通过在流中使用文件可以实现对象的持久存储。 */ import java.io.*; public class ObjectStreamDemo{ public static void main(String args[])throws Exception{ //WriteObj(); ReadObj()
java输入、输出流的简单入门
qq_36923376的博客
03-30 1万+
程序在运行期间可能需要从外部的存储媒介或其他程序中读取所需要的数据，这就需要使用输入流，输入流的指向称为它的源；另一方面，程序在处理数据后，可能需要将处理的结果写入到永久的存储媒介中或传送给其他的应用程序，这就需要使用输出流。 通俗的解释就是，以我当前程序为主，我要和其他的事物进行交流，所以我必须要搭一个通道（这个通道就是流），让我和它可以交流，我获取该事物的数据就叫输...
Java的io类的使用场景
热门推荐
heihei
11-12 1万+
先附上io图： InputStream类 ByteArrayInputStream – 把内存中的一个缓冲区作为 InputStream 使用，CPU从缓存区读取数据比从存储介质的速率快10倍以上。 StringBufferInputStream – 把一个 String 对象作为。InputStream。不建议使用，在转换字符的问题上有缺陷。 FileInputStream – 把一个文件作为
IO流输出----从项目中写入数据到指定为文件中
yuzheh521的博客
03-20 318
输出说明: 输出对应的File 可以不存在, File如果不存在,在输出的过程中会自动创建此文件 File对应的磁盘文件如果存在 如果流使用的构造器是: FileWriter(file)|FileWriter(file,false);会对原有的文件覆盖 如果流使用的构造器是: FileWriter(file,true);则不会对原有文件进行覆盖,会在原有文件上追加内容 @...
IO流之读取文件(输入流)
临窗，听雨声
08-11 5955
写入文件过程 1，建立联系 2，选择流 3，操作 4，释放资源 一起来看看代码吧！ /** * 操作文件过程 * 1，建立联系 * 2，选择流 * 3，操作，读写 * 4，释放资源 * @author snow * */ public class IODemo { public static void main(String[] args) { // 1，建...
IO流(输入流和输出流)
lyn789的博客
08-03 7375
1. 输入流和输出流的联系和区别，字符流和字节流的联系和区别 输入流是得到数据，输出流是输出数据。 字符流和字节流是流的一种划分，按处理照流的数据单位进行的划分。 两类都分为输入和输出操作。 在字节流中输出数据主要是使用OutputStream完成，输入使InputStream 在字符流中输出主要是使用Writer类完成，输入流主要使用Reader类完成 2. 节点流和处理流的联系
java io流面试题
07-29
当谈到Java IO流时，以下是一些常见的面试题： 1. 什么是Java IO流？它们是如何工作的？...这些问题涵盖了Java IO流的基本概念和常见用法。准备这些问题的答案将帮助你在面试中展示你对Java IO流的理解和经验。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值