Java中的File类与IO流（File类的基本使用、字节流、字符流、转换流、java文件拷贝）

最新推荐文章于 2024-04-20 19:33:09 发布
最新推荐文章于 2024-04-20 19:33:09 发布
阅读量3.5k 收藏 21
点赞数 9
分类专栏： Java Java学习 文章标签： File类的基本使用 字节流 字符流 转换流 java文件拷贝
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhao_miao/article/details/88368210
版权

文章目录

1. File类的基本使用

File类即可描述真实文件，也可描述文件夹（目录）
File类是java.io包中唯一一个与文件本身操作（创建、删除、取得信息）有关，与文件内容无关的程序类
File类的常用构造方法:

 public File(String pathname); //pathname:文件的绝对路径
 public File(String parent,String child);//parent:文件的父路径 child：文件的子路径

1.1 文件操作

1.1.1 创建新文件

public boolean createNewFile() throws IOException 

import java.io.File;
import java.io.IOException;
public class Test {
    public static void main(String[] args) {
        //取得File对象,此处的路径为绝对路径
        File file = new File("C:\\Users\\79024\\Desktop\\java.txt");
        try {
            file.createNewFile();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

在这里插入图片描述

1.1.2 删除文件

public boolean delete();

import java.io.File;
import java.io.IOException;
public class Test {
    public static void main(String[] args) {
        //取得File对象
        File file = new File("C:\\Users\\79024\\Desktop\\java.txt");
        //判断文件是否存在 此方法也可判断文件夹是否存在
        if(file.exists())
        {
            file.delete();
        }else{
            try {
                file.createNewFile();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

1.1.3 路径分隔符

路径分隔符:File.separator用于替换路径中的\

import java.io.File;
import java.io.IOException;
public class Test {
    public static void main(String[] args) {
        //取得File对象
        File file = new File("C:"+File.separator+"Users"+
                File.separator+"79024"+File.separator+
                "Desktop"+ File.separator+"java.txt");
        try {
            file.createNewFile();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

1.2 目录操作

1.2.1 取得父路径与父File对象

public String getParent();
public File getParentFile();

1.2.2 创建目录

无论有多少级父目录都会一次性创建public boolean mkdirs()；

import java.io.File;
import java.io.IOException;

public class Test {
    public static void main(String[] args) {
        //取得File对象
        File file = new File("C:"+File.separator+"Users"+
                File.separator+"79024"+File.separator+
                "Desktop"+ File.separator+
                "www"+File.separator+"java"+File.separator+"java.txt");
        //取得父路径对象
        File parentFile = file.getParentFile();
        //如果父路经不存在 -- 创建父路径
        //父文件即C：\Users\79024\Desktop\www\java
        if(!parentFile.exists()){
        //无论有多少级父目录都一次性创建
            parentFile.mkdirs();
        }
        //如果文件存在 删除
        if(file.exists()){
            file.delete();
        }else{
            try {
                file.createNewFile();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

1.3 取得文件或者目录的信息（大小、最后修改日期）

public boolean isFile(); //判断路径是否是文件
public long length();//取得文件大小
public long lastModified();//取得最后修改日期

import java.io.File;
import java.util.Date;
public class Test {
    public static void main(String[] args) {
        //取得File对象
        File file = new File("C:" + File.separator + "Users" +
                File.separator + "79024" + File.separator +
                "Desktop" + File.separator  + "happy.png");
        //如果路径存在 且 路径是一个文件
        //输出文件的大小（字节）以及最后的修改时间（1970年开始的时间戳）
        if(file.exists()&&file.isFile()){
            System.out.println(file.length());
            System.out.println(file.lastModified());
            //最后的修改时间以能看懂的形式显示
            System.out.println(new Date(file.lastModified()));
        }
    }
}

对目录的操作:

public boolean isDirectory();//判断路径是否是目录
public File[] listFile();//列举一个目录的全部组成

import java.io.File;
public class Test {
    public static void main(String[] args) {
        //取得File对象
        File file = new File("C:" + File.separator + "Users" +
                File.separator + "79024" + File.separator +
                "Desktop");
        //如果路径存在且路径是一个目录
        //列举该目录下的文件和目录
        if(file.exists()&&file.isDirectory()){
        	//只展开一层
            File[] files = file.listFiles();
            for(File file1:files){
                System.out.println(file1);
            }
        }

    }
}

如果目录的全部组成下还有目录递归展示：

import java.io.File;
public class Test {
    public static void main(String[] args) {
        //取得File对象
        File file = new File("C:" + File.separator + "Users" +
                File.separator + "79024" + File.separator +
                "Desktop");
        listAllFiles(file);
    }
    public static void listAllFiles(File file){
        /**
         * 如果路径存在且路径是一个文件直接输出
         */
        if(file.exists()&&file.isFile()){
            System.out.println(file);
        }else{
            //此时file对象为目录
            File[] files = file.listFiles();
            for(File file1:files){
                listAllFiles(file1);
            }
        }
    }
}

IO相关处理属于阻塞式耗时操作。一般放在子线程中进行

import java.io.File;
public class Test {
    public static void main(String[] args) {
        System.out.println("主线程开始");
        new Thread(()->{
            //取得File对象
            File file = new File("C:" + File.separator + "Users" +
                    File.separator + "79024" + File.separator +
                    "Desktop");
            System.out.println("遍历文件开始...");
            long start = System.currentTimeMillis();
            listAllFiles(file);
            long end = System.currentTimeMillis();
            System.out.println("遍历文件结束，共耗时"+(end-start));
        }).start();
        System.out.println("主线程结束");
    }
    public static void listAllFiles(File file){
        /**
         * 如果路径存在且路径是一个文件直接输出
         */
        if(file.exists()&&file.isFile()){
            System.out.println(file);
        }else{
            //此时file对象为目录
            File[] files = file.listFiles();
            for(File file1:files){
                listAllFiles(file1);
            }
        }
    }
}

2. IO流

流的分类：

  1. 字节流（byte）：InputStream、OutputStream
  2. 字符流（char）:Reader、Write
    字节流与字符流的区别:
    字节流是原生操作，字符流是处理后的操作
    一般使用字节流（无论是网络传输还是磁盘的数据保存都是字节流），只有处理中文的文本时才会用到字符流

2.1 流的操作过程

无论是字节流还是字符流，操作流程几乎一样，以文件操作为例：
1.取得File对象
2.取得File对象的输入、输出流
3.进行数据的读取或写入
4.关闭流（close）
IO操作属于资源处理，所有资源处理（IO、数据库、网络）使用后都必须关闭

2.2 字节流

2.2.1 字节的输出流OutputStream

//抽象类
public abstract class OutputStream implements Closeable, Flushable
Closeable：public void close() throws IOException;
Flushable:void flush() throws IOException;
2.2.1.1 输出方法
public void write(byte[] b)throws IOException; //将指定的字节数组全部输出
public void write(byte[] b,int offset,int len)throws IOException;//将部分字节数组输出
public abstract void write(int b)throws IOException;//输出单个字节

要进行文件内容的输出：使用FileOutputStream子类

public FileOutputStream(File file) throws FileNotFoundException              //文件内容的覆盖
public FileOutputStream(File file, boolean append)throws FileNotFoundException //文件内容的追加

当使用FileOutoutStream进行文件内容输出时，只要文件的父路径存在，FileOutputStream会自动创建文件

import java.io.*;
public class Test {
    public static void main(String[] args) throws IOException {
        //1.取得File对象
        File file = new File("C:"+File.separator+"Users"+File.separator+
                "79024"+File.separator+"Desktop"+File.separator+"java.txt");
        //---------------------------------------------------------- 以下内容可写可不写
        //如果文件不存在 则创建
        if(!file.exists()){
            try {
                file.createNewFile();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        //--------------------------------------------------------------
        //2.取得File的输出 文件内容的追加
        OutputStream out = new FileOutputStream(file,true);
        //3.进行数据的输出
        String msg ="好好学习\n";
        out.write(msg.getBytes());
        //4.关闭流
        out.close();
    }
}

2.2.2 字节的输入流InputStream

public abstract class InputStream implements Closeable 
Closeable：public void close() throws IOException;
2.2.2.1 输入方法
public int read(byte b[]) throws IOException;  //读取数据到字节数组b中
    1.返回b的长度：当被读取的数据大小>字节数组大小 返回字节数组大小
    2.返回一个大于0的数但是小于b长度： 被读取的数据大小<字节数组大小 返回真正读取的个数
    3.返回-1： 数据读取完毕
    可以将被读取的数据看作稀饭,将字节数组的大小看作勺子
public abstract int read() throws IOException;//读取单个字节    

import java.io.*;
public class Test {
    public static void main(String[] args) throws IOException {
        //1.取得File对象
        File file = new File("C:"+File.separator+"Users"+File.separator+
                "79024"+File.separator+"Desktop"+File.separator+"java.txt");
        //2.取得输入流
        InputStream in  = new FileInputStream(file);
        //3.进行数据的写入 将数据写入data数组中
        byte[] data = new byte[1024];
        int result = in.read(data);
        System.out.println(result);
        //将字节数组转为字符串
        System.out.println(new String(data,0,result));
        //4.关闭流
        in.close();
    }
}

2.3 字符流

2.3.1 字符输出流Writer

无论是字节输出流还是字符输出流都是write方法，但是字符输出流多了一个传入String对象的方法public void write(String str) throws IOException

import java.io.*;
public class Test {
    public static void main(String[] args) throws IOException {
        //1.取得File对象
        File file = new File("C:" + File.separator + "Users" + File.separator +
                "79024" + File.separator + "Desktop" + File.separator + "java.txt");
        //2.取得输出流
        Writer writer = new FileWriter(file,true);
        //3.写入数据
        String str = "好好学习";
        writer.write(str);
        //4.关闭流
        writer.close();
    }
}

2.3.2 字符输入流Reader

Reader类中没有方法可以直接读取字符串，只能通过字符数组来读取public int read(char b[]) throws IOException; //读取数据到字符数组b中

import java.io.*;
public class Test {
    public static void main(String[] args) throws IOException {
        //1.取得File对象
        File file = new File("C:" + File.separator + "Users" + File.separator +
                "79024" + File.separator + "Desktop" + File.separator + "java.txt");
        //2.取得输出流
        Reader reader = new FileReader(file);
        //3.数据写入
        char[] data = new char[1024];
        int result = reader.read(data);
        System.out.println(result);
        System.out.println(new String(data,0,result));
        //4.关闭流
        reader.close();
    }
}

2.3 字节流与字符流

从实际开发来讲，字节流优先考虑，只有处理中文时才会考虑字符流
所有字符流操作，无论是写入还是输出，数据都先保存在缓存中，如果不关闭流，则数据不会写入或者读出

2.3 转换流

字节流–>字符流
转换流用于将底层的字节流转为字符流供子类w使用

OutputStreamWriter:字节输出流--->字符输出流
InputStreamReader：字节输入流--->字节输出流

import java.io.*;
public class Test{
    public static void main(String[] args) throws IOException {
        //1.取得文件对象
        File file = new File("C:"+File.separator+"Users"+File.separator+
        "79024"+File.separator+"Desktop"+File.separator+"java.txt");
       //2.取得文件的输出流
        OutputStream outputStream = new FileOutputStream(file);
        //字节流--->字符流
        OutputStreamWriter outputStreamWriter = new OutputStreamWriter(outputStream);
        //3.进行数据的输出
        outputStreamWriter.write("好好学习");
        //4.关闭流
        outputStreamWriter.close();
    }
}

2.4 文件拷贝

import java.io.*;
public class Test{
     public static void main(String[] args) throws IOException {
         String sourceFilePath = "C:\\Users\\79024\\Desktop\\哈.png";
         String destFilePath="C:\\Users\\79024\\Desktop\\嘿.png";
         System.out.println( copyFile(sourceFilePath,destFilePath));
     }

     /**
      * 文件拷贝
      * @param sourceFilePath
      * @param destFilePath
      * @return
      */
     public static boolean copyFile(String sourceFilePath,String destFilePath) throws IOException {
         //1.取得File对象
         File sourceFile = new File(sourceFilePath);
         File destFile = new File(destFilePath);
         //2.取得输入输出流
         /**
          * 由于是将源文件拷贝到目标文件中
          * 即需要先将源文件中的数据输入到缓冲区中 ，然后将数据输出到目标文件
          * 所以源文件对应字节输入流
          * 目标文件对应字节输出流
          */
         InputStream in = new FileInputStream(sourceFile);
         OutputStream out = new FileOutputStream(destFile);
         //3.数据的输入、输出
         long start = System.currentTimeMillis();
         int len = 0;
         /**
          * in.read() 读取单个字节  该方法有返回值
          * 返回值==-1即数据读取完毕
          * write(len)输出单个字节
          */
         while ((len = in.read()) != -1) {
             out.write(len);
         }
         long end = System.currentTimeMillis();
         System.out.println("文件拷贝耗时：" + (end - start) + "毫秒");
         in.close();
         out.close();
         return true;
     }
 }

由于一个字节一个字节的读取太过于耗时，所以修改输入方式，即增加缓冲区：

import java.io.*;
public class Test{
     public static void main(String[] args) throws IOException {
         String sourceFilePath = "C:\\Users\\79024\\Desktop\\哈.png";
         String destFilePath="C:\\Users\\79024\\Desktop\\嘿.png";
         System.out.println( copyFile(sourceFilePath,destFilePath));
     }

     /**
      * 文件拷贝
      * @param sourceFilePath
      * @param destFilePath
      * @return
      */
     public static boolean copyFile(String sourceFilePath,String destFilePath) throws IOException {
         //1.取得File对象
         File sourceFile = new File(sourceFilePath);
         File destFile = new File(destFilePath);
         //2.取得输入输出流
         /**
          * 由于是将源文件拷贝到目标文件中
          * 即需要先将源文件中的数据输入到缓冲区中 ，然后将数据输出到目标文件
          * 所以源文件对应字节输入流
          * 目标文件对应字节输出流
          */
         InputStream in = new FileInputStream(sourceFile);
         OutputStream out = new FileOutputStream(destFile);
         //3.数据的输入、输出
         long start = System.currentTimeMillis();
         int len = 0;
         /**
          * in.read() 读取单个字节  该方法有返回值
          * 返回值==-1即数据读取完毕
          * write(len)输出单个字节
          */
         byte[] data = new byte[1024];
         while ((len = in.read(data)) != -1) {
             out.write(data,0,len);
         }
         long end = System.currentTimeMillis();
         System.out.println("文件拷贝耗时：" + (end - start) + "毫秒");
         in.close();
        out.close();
         return true;
     }
 }
zhao_miao
关注
  • 9
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
java file转输入流_Java转换流
weixin_42113380的博客
02-28 8481
前面提到IO流可分为字节流和字符流，有时字节流和字符流之间也需要进行转换。在JDK中提供了两个类可以将字节流转换为字符流，它们分别是InputStreamReader和OutputStreamWriter。转换流也是一种包装流，其中OutputStreamWriter是Writer的子类，它可以将一个字节输出流包装成字符输出流，方便直接写入字符，而InputStreamReader是Reader的...
java流式文件读写_Java 流(Stream)、文件(File)和IO
weixin_28699741的博客
02-28 2206
参考于：https://blog.csdn.net/qq_22063697/article/details/52137369版权声明：本文为博主原创文章，转载请附上博文链接！一. 什么是 IOJava中 I/O 操作主要是指使用 Java 进行输入，输出操作。 Java所有的I/O机制都是基于数据流进行输入输出，这些数据流表示了字符或者字节数据的流动序列。Java 的 I/O 流提供了读写数据的...
IO流的学习与使用（一）File类
m0_56174436的博客
07-05 166
java.io.File类是文件和目录路径名的抽象表示形式，主要用于文件和目录的创建，查找和删除。注意：路径是唯一的，同一计算机不可能出现两个不同的文件但路径相同绝对路径和相对路径 常用方法：...
java中File类和输入输出流的用法
最新发布
m0_73629312的博客
04-20 829
如创建文件，删除文件，创建目录，重命名文件等。，如读文件，写文件等。针对文件系统进行操作我们可以使用对文件系统进行操作。java标准库提供了File类（出自java.io包里，和输入输出相关的内容就在这个包里）表示一个文件，进一步的通过File提供的方法，就可以进行文件系统操作了。File中提供了很多文件操作的方法：注：当我们在java中运行程序的时候，基准目录是什么呢？此时。
java----IO流：File操作
z2021_000000的博客
06-29 610
File File类创建功能 File删除功能 File类判断和获取功能
Java实现流和文件的转换 将InoutStream转为File输出到磁盘
WindNolose的博客
05-07 1万+
业务描述 项目开发中，把较小的文本文件直接用BLOB数据类型存到了MySQL中 获取时得到的是流对象，需要转换为对应的.txt文件输出到磁盘中 实现 流对象说白了就是一堆进制码，并不支持和文件的直接转换，因为流本身并不知道文件的类型 实现思路： 先使用File创建出一个对应的文件，指定好类型，把流对象输入文件中，判断为-1则表示输入完成 @Test public void test01() throws Exception{ InputStream Input = //获取
IO流‘‘
weixin_49405762的博客
08-09 134
1.所有需要网络传输的对象都需要实现序列化接口2.对象的类名，实例变量都会被序列化；方法，类变量不会被序列化3.如果想让某个变量不变序列化，可以用transient修饰4.序列化对象的引用类型成员变量5.反序列化时必须由序列化对象的class文件6.如果同一个对象被序列化多次，只有一次序列化为二进制流，以后都只是保存序列化的版本号天涯海角悲凉地记得当年全盛时。...
java---file流基础笔记
？？？
11-07 42
File类概述和构造方法【应用】 File类介绍 它是文件和目录路径名的抽象表示 文件和目录是可以通过File封装成对象 对于File而言,其封装的并不是一个真正存在的文件,仅仅是一个路径名而已.它可以是存在的,也可以是不存在的.将来是要通过具体的操作把这个路径的内容转换为具体存在的 File类的构造方法： 方法名 说明 File(String pat...
Java IO流之File类和字节流
weixin_45676761的博客
11-12 495
Java IO流是Java比较重要的一个知识点，它使Java应用程序具备了对系统文件及文件内容的增删改查操作的功能，从而使Java应用程序数据可以实现持久化存储。本篇博客将介绍Java IO流体系中的File类和字节流。
IO各种操作文件，字符流、字节流等
05-22
在Java IO中，主要有两种流的概念：字符流（Character Stream）和字节流（Byte Stream）。它们是处理数据的基本方式，适用于不同场景。 字符流主要处理基于字符的数据，如文本文件，它包括Reader和Writer两个抽象...
java 使用IO流实现文件的复制
06-13
除了使用基本的字节流，Java还提供了更高级的`java.nio`包，它提供了一种更高效、更灵活的文件操作方式——NIO（New Input/Output）。NIO引入了通道（Channel）和缓冲区（Buffer）的概念，可以实现多线程间的零拷贝...
Java二进制IO类与文件复制操作实例
06-06
在Java编程语言中，二进制输入/输出（IO）类是处理非文本数据的关键工具。这些类允许程序员高效地读取和...通过理解这些类的工作原理以及如何在实际操作中使用它们，如文件复制，可以有效地提升Java程序的处理能力。
JavaIO的常用方法.docx
12-02
使用字节流可以方便地实现文件的拷贝。以下是一个使用 `FileInputStream` 和 `FileOutputStream` 实现文件拷贝的示例： ```java import java.io.*; public class CopyUtils { public static void copyFile...
Java IO commons-io-2.5.jar
04-02
Java IO 包含了许多类，如InputStream、OutputStream、Reader、Writer等，它们分别用于处理字节流和字符流。字节流适用于二进制数据，而字符流适用于文本数据。Java IO 还包括Filter流，可以用来装饰其他流，添加...
File类的操作
ShiZaolin的博客
01-31 371
File类的概述和操作 1.File的构造方法 File(String pathname) 根据一个路径得到File对象 File(String parent,String child)根据一个目录和一个子文件/目录得到File对象 File(File parent,String child) 根据一个父File对象和一个子文件/目录得到File对象 2.File的创建功能 public bool...
JAVA流-File文件
Lyajpunov的博客
01-26 935
在 Java 中，File 类是 java.io 包中唯一代表磁盘文件本身的对象。File 类定义了一些与平台无关的方法来操作文件，File类主要用来获取或处理与磁盘文件相关的信息，像文件名、 文件路径、访问权限和修改日期等，还可以浏览子目录层次结构。File 类表示处理文件和文件系统的相关信息。也就是说，File 类不具有从文件读取信息和向文件写入信息的功能，它仅描述文件本身的属性。 一、构造方法 构造器 描述 File(String pathname) 通过将给定路径名字符串来创建一个新
在java中将inputStream对象转换为File对象（不生成本地文件）
热门推荐
爱学习的大雄的博客
07-08 1万+
在后端中通过POI生成Excel文件流，将输出流（outputStream）转为输入流（inputStream）后又需要将输入流（inputStream）转为File对象。问题：如果需要将输入流（inputStream）转为File对象，则必须要根据本地路径去生成一个File对象才行，也就是说不管怎样本地都必须要生成出来一个文件。看到这里你可能会好奇，这不是也在本地生成了个文件吗？在经过一系列的资料查询后，发现如下方式可以大致满足需求。即为我们需要的File对象。
File文件转成流的形式输出给前端
qq_42281649的博客
10-09 4317
file文件转成流的形式输出给前端
前端：文件转换成文件流？(element-u)
qq_37958178的博客
04-27 1736
文件转换成文件流
java中io流基本操作流程
09-22
### 回答1： Java中的IO流操作基本流程如下： 1. 创建流对象：通过File类或其他相关类创建输入流或输出流对象。 2. 打开流：使用输入流或输出流对象的open()方法打开流，这样就可以读取或写入数据。 3. 读取或写入数据：使用输入流或输出流对象的read()或write()方法读取或写入数据。 4. 关闭流：使用输入流或输出流对象的close()方法关闭流，释放资源。 需要注意的是，在使用IO流操作时，要遵循“先打开、后关闭”的原则，以确保数据的完整性和流的正确性。同时，在操作过程中也需要进行异常处理，以避免出现不必要的错误。 ### 回答2： Java中的IO流基本操作流程如下： 1. 打开文件或者建立网络连接：使用File类或者URL类打开文件或者建立网络连接。 2. 创建流对象：根据需要选择输入流（读取数据）或输出流（写入数据），并创建相应的流对象。常见的输入流有FileInputStream、BufferedReader等，常见的输出流有FileOutputStream、BufferedWriter等。 3. 读取或写入数据：使用流对象读取或写入数据。对于输入流，可以通过调用相关方法（如read()、readline()等）逐个字符或逐行读取数据；对于输出流，可以通过调用相应方法（如write()、print()等）逐个字符或逐行写入数据。 4. 关闭流：读取或写入完成后，需要关闭文件或网络连接，以释放资源。可以调用流对象的close()方法来关闭流。 需要注意的是，在处理IO流时，应该始终使用try-catch-finally块，以确保在发生异常时能够正确关闭流。可以把IO操作放在try块中，catch块用于捕获异常，并在finally块中关闭流。 另外，为了提高IO效率，可以考虑使用缓冲流来进行读写操作。缓冲流(BufferedInputStream、BufferedOutputStream、BufferedReader、BufferedWriter)可以通过缓冲区将数据从源读入到缓冲区中，再从缓冲区写入到目标中，提高读写的速度。 以上就是Java中IO流基本操作的流程。根据实际需要选择合适的流对象，并遵循打开、读取/写入、关闭的流程，可以实现灵活、高效的IO操作。 ### 回答3： 在Java中，IO流是用于处理输入输出操作的工具。下面是Java中IO流的基本操作流程： 1. 创建流对象：通过使用Java中的InputStream和OutputStream类来创建流对象。InputStream类用于读取输入流，而OutputStream类用于写入输出流。 2. 打开流：通过使用流对象对应的构造函数和方法来打开输入和输出流。根据具体情况，可以选择文件流、网络流或内存流来打开流。 3. 读取/写入数据：使用流对象提供的读取和写入方法来读取和写入数据。例如，使用InputStream的`int read()`方法来读取一个字节的数据，使用OutputStream的`void write(int b)`方法来写入一个字节的数据。 4. 关闭流：在读取或写入结束后，必须关闭流以释放相关资源。通过调用流对象的`close()`方法来关闭流。 需要注意的是，在处理异常的时候，我们需要对可能出现的`IOException`进行处理。可以使用try-catch语句块来捕获和处理异常。 流程示例： ```java import java.io.*; public class IOExample { public static void main(String[] args) { try { // 1. 创建流对象 FileInputStream fis = new FileInputStream("input.txt"); FileOutputStream fos = new FileOutputStream("output.txt"); // 2. 打开流 // 3. 读取/写入数据 int data; while ((data = fis.read()) != -1) { fos.write(data); } // 4. 关闭流 fis.close(); fos.close(); } catch(IOException e) { e.printStackTrace(); } } } ``` 上述示例中，我们创建了一个用于将一个文件中的内容拷贝到另一个文件中的程序。首先，我们创建了一个FileInputStream对象来读取输入文件的内容，然后创建了一个FileOutputStream对象来写入输出文件。接下来，我们通过循环从输入流中读取一个字节的数据，并将其写入到输出流中，直到读取完所有的数据。最后，我们关闭了流对象来释放资源。 这就是Java中IO流的基本操作流程。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值