Java中的IO流

最新推荐文章于 2024-08-23 15:44:17 发布
最新推荐文章于 2024-08-23 15:44:17 发布
阅读量664 收藏
点赞数 5
分类专栏： javaSE 文章标签： java io流
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gfd54gd5f46/article/details/54936972
版权

Java中的IO流


      Java的核心库java.io提供了全面的IO接口。包括：文件读写、标准设备输出等。Java中IO是以流为基础进行输入输出的，所有数据被串行化写入输出流，或者从输入流读入。


百度百科：

http://baike.baidu.com/link?url=r9vOfxsGkUHzoGw3rxvw0YQJiFHsmS3P2cQGV4prjdT14RCCXNxCvd3KNuHgxF56Upj86uJ2EAkK1_vjSiHIYK


在线API：

http://www.apihome.cn/api/java/java.io_1


Java IO流的分类

  • 1) 字节流：数据流中的最小的数据单元是字节，一次读入读出8位二进制；

  • 2) 字符流：数据流中的最小的数据单元是字符，一次读入读出16位二进制，java中的字符是Unicode编码，一个字符占用两个字节。

字节流

输入字节流：InputStream类
  • InputStream类是个抽象类是所有字节输入流的超类。

1

读取文件：FileInputStream
  • 在src目录下创建一个a.txt文件

2


  • 创建一个FileInputStream类的对象用来读取a.txt文件
package com.lingdu.file;

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

public class FileInputStreamDemo {

    /**
     * 使用InputStream抽象类的子类FileInputStream类
     * 从一个文件中读取流数据
     */
    public static void test1() {
        try {
            //读取src下的a.txt文件
            FileInputStream myStream = new FileInputStream("src/a.txt");
            int a = 0;
            //如果没读到文件尾，则继续执行
            while((a = myStream.read()) != -1){
                System.out.print((char)a);
            }
            //关闭流（使用完之后都要关闭）
            myStream.close();
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }


    public static void main(String[] args) {
        test1();
    }
}

3

  • 使用多态的特性使用子类FileInputStream
    /**
     * 使用多态的特性使用子类FileInputStream
     */
    public static void test2() {
        try {

            InputStream is = new FileInputStream("src/a.txt");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }
输出字节流OutputStream类

4

写到文件：FileOutputStream


写入一个字符到文件中

/**
 * 写入一个字符到文件中
 * @author Administrator
 *
 */
public class FileOutputStreamDemo {


    public static void  test1() {
        try {
            OutputStream os = new FileOutputStream("src/a.txt");
            os.write(97);
            os.flush();
            os.close();
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

5


写入一个数组到文件

/**
     * 写入一个数组到文件
     */
    public static void test2() {
//方法比较笨拙不推荐使用，这里只是作为演示
        byte myArray[] = new byte[5];
        myArray[0] = 97;
        myArray[1] = 98;
        myArray[2] = 99;
        myArray[3] = 100;
        myArray[4] = 101;
        try {
            OutputStream os = new FileOutputStream("src/b.txt");
            os.write(myArray);
            os.flush();
            os.close();
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

6


写入一个字符串到文件

/**
* 写入一个字符串到文件
*/
public static void test3() {
        String myContent = "I am a good man!";
        try {
            OutputStream os = new FileOutputStream("src/c.txt");
            os.write(myContent.getBytes());
            os.flush();
            os.close();
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

7


FileInputStream 和 FileOutputStream 类

通过FileInputStream 和 FileOutputStream 类拷贝文件


步骤：

  • 1、 使用FileInputStream类读取到文件

  • 2、 使用FileOutputStream类写入到新文件


这里我在src目录下创建一个a.txt文件作为测试

8


拷贝方法：

    /**
     * 读取文本文件，读取图片，读取视频
     */
    public static void copyFile(String sourceName,String dest){
        System.out.println("源文件：" + sourceName + ",目标文件：" + dest);
        //1:先读取一个文件
        //2:写入一个文件
        try {
            FileInputStream fis = new FileInputStream(sourceName);
            FileOutputStream fos = new FileOutputStream(dest);
            int a = 0;
            //当还未到达文件尾时，循环读取
            while((a = fis.read()) != -1){
                //每读取一个字节过来，我们就写入到另一个文件里去
                fos.write(a);//这里只会正常写入数据，不会把-1写进去
            }
            fos.flush();//把缓冲区里的数据强制写入到文件中
            fos.close();//关闭输出流
            fis.close();//关闭输入流
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }       
    }


这是如果读取一个视频的话，速度就会变的很慢。


我用一个22mb的视频和1G的视频作为测试

9


Main函数

public static void main(String[] args) {

        //程序运行开始时间
        long begin = System.currentTimeMillis();

        HomeWork.copyFile("src/a.txt", "src/b.txt");

        //程序运行时间=结束时间-开始时间  ，得到的是毫秒值。
        long end = System.currentTimeMillis() - begin;
        System.out.println("\n用时：" + end/1000f + "s");
    }

10

复制22mb的视频都那么吃力，可想而知用1G的视频将会等待更久


所以我们要改进一下我们的程序



使用byte数组的方式进行复制

  • 为了测试，我在src目录下创建了一个a.txt的文件用于测试，并且在txt文本中保存一些数据

11

    /**
     * 由于读取速度太慢，所以要学习新的方法，让我们更快一点
     */
    public static void test2(){
        //设置每次写入3个字节
        byte[] myArray = new byte[3];
        try {
            InputStream is = new FileInputStream("src/a.txt");
            //如果到达文件尾，无法满足while的条件，不会执行while语句的内容
            while(is.read(myArray) != -1){
                for (int i = 0; i < myArray.length; i++) {

                    //打印一下每个字符
                    System.out.print((char)myArray[i]);
                }
            }
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }

12

结果是可以复制的


问题：

  • 我当前a.txt文件下保存的数据是lingdu,但是如果我在加一些内容会怎样呢？

13

保存运行一下得到的不是我想要的数据 多出了du 两个字符

14


原因就是：

  • 因为数组定义的长度是3

  • 第一次读取到lin 输出

  • 第二次读取到gdu 输出

  • 第三次读取到a 因为读取时是覆盖操作 所以a覆盖了g之后，后面的全部输出 adu

  • 所以最后的结果是 lingduadu


知道原因之后我们就要改进一下这个方法了

/**
* 问题：
* 当使用数组的时候，如果文件里的字符的长度不是数组的倍数的时候，拿到的数据会重复
*/
    public static void test3(){
        //这里的数组长度是指 每次读取3个字节
        byte[] myArray = new byte[3];
        //定义一个变量用来保存数组的长度
        int len;
        try {
            InputStream is = new FileInputStream("src/a.txt");
            //如果到达文件尾，无法满足while的条件，不会执行while语句的内容
            while((len = is.read(myArray)) != -1){
                //这样就解决了数据重复的问题
                for (int i = 0; i < len; i++) {

                    System.out.print((char)myArray[i]);
                }
            }
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }

15

解决了这个重复的问题之后我们就可以继续进行复制了。

现在我们使用数组的方式对1G视频进行复制

    /**
     * 优化
     * 使用数组进行读取
     */
    public static void test4(){
        //这里的数组长度是指 每次读取1024个字节
        byte[] myArray = new byte[1024];
        //定义一个变量用来保存数组的长度
        int len;
        try {

            InputStream is = new FileInputStream("src/1.wmv");
            OutputStream os = new FileOutputStream("src/test.wmv");
            //如果到达文件尾，无法满足while的条件，不会执行while语句的内容
            while((len = is.read(myArray)) != -1){

                //定义过新的数组，这个数组要防止有多余的数据
                byte descArray[] = new byte[len]; 

                //这样就解决了数据重复的问题
                for (int i = 0; i < len; i++) {

                    //System.out.print((char)myArray[i]);


                    descArray[i] = myArray[i];
                }

                os.write(descArray);                    

            }
            os.flush();
            os.close();
            is.close();
            System.out.println("写入成功！");
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }


使用数组的方式写入一个1G的视频才用了1.7秒左右，比刚刚使用1个字节写入快了几百倍

16

BufferedInputStream和BufferedOutputStream 类


性能优化

使用封装好的write(byte[] b, int off, int len)方法，简易代码。
    /**
     * 性能优化
     * 1：使用封装好的方法直接使用write(myArray, 0, len);
     */
    public static void test5(){
        //这里的数组长度是指 每次读取1024个字节
        byte[] myArray = new byte[1024];
        //定义一个变量用来保存数组的长度
        int len;
        try {

            InputStream is = new FileInputStream("src/1.wmv");
            OutputStream os = new FileOutputStream("src/test.wmv");


            //如果到达文件尾，无法满足while的条件，不会执行while语句的内容
            while((len = is.read(myArray)) != -1){
                //最后一次读取数据的时候，只把数组的第0个长度开始到数组的指定len（我们从流里最好一次实际读出的数据）
                os.write(myArray, 0, len);
            }
            os.flush();
            os.close();
            is.close();
            System.out.println("写入成功！");
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }


使用封装好的方法要比自己定义数组数值快很多，而已省去了很多的代码，提高了开发效率

17

使用缓冲区 BufferedInputStream和BufferedOutputStream
    /**
     * 进一步性能优化
     * 2：使用缓冲区 BufferedInputStream跟BufferedOutputStream 
     */
    public static void test6(){
        //这里的数组长度是指 每次读取3个字节
        byte[] myArray = new byte[1024];
        //定义一个变量用来保存数组的长度
        int len;
        try {
            //把原来的流装进一个类里
            BufferedInputStream bis = new BufferedInputStream(new FileInputStream("src/1g.wmv"));   
            BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("src/test.wmv"));

            //如果到达文件尾，无法满足while的条件，不会执行while语句的内容
            while((len = bis.read(myArray)) != -1){
                //最后一次读取数据的时候，只把数组的第0个长度开始到数组的指定len（我们从流里最好一次实际读出的数据）
                bos.write(myArray, 0, len);
            }
            bos.flush();
            bos.close();
            bis.close();
            System.out.println("写入成功！");
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }


使用缓冲区写入数据的时候，速度快了1倍

18


ByteArrayInputStream 类
  • 当我们没有文件的时候，如何使用流？


这时我们就要用到ByteArrayInputStream 类

    /**
     * 当我们没有文件的时候，如何使用流
     * 
     */
    public static void test8(){
        String content = "lingdu";
        ByteArrayInputStream is = new ByteArrayInputStream(content.getBytes());
        int i = 0;
        while((i = is.read()) != -1){
            System.out.print((char)i);
        }
    }

19


当文件里有中文的时候，会出现乱码

    /**
     * 新的问题：当文件里有中文的时候，可能会乱码
     * 
     */
    public static void test9(){
        String content = "魑魅魍魉";
        byte myArray[] = content.getBytes();
        ByteArrayInputStream is = new ByteArrayInputStream(content.getBytes());

        for (int i = 0; i < myArray.length; i++) {
            System.out.print((char)myArray[i]);
        }
        System.out.println();

        byte a = 0;
        while((a = (byte)is.read()) != -1){
            System.out.print((char)a);
        }
    }

20


如何解决乱码问题呢？

    /**
     * 解决乱码问题
     * 
     */
    public static void test10(){
        String content = "魑魅魍魉";
        byte myArray[] = content.getBytes();
        ByteArrayInputStream is = new ByteArrayInputStream(content.getBytes());
        int len = 0;
        try {
            while((len = is.read(myArray)) != -1){
                System.out.println(new String(myArray));
            }
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

21

  • 如果我要读取一个文本文件里面的中文呢？

我在src下创建一个a.txt,并写入数据

22

    /**
     * 读取文件
     * 解决乱码问题
     * 
     */
    public static void test11(){
        InputStream is;
        try {
            is = new FileInputStream("a.txt");
            byte myArray[] = new byte[6];
            ByteArrayInputStream bais = new ByteArrayInputStream(myArray);
            int len = 0;
            while((len = is.read(myArray)) != -1){
                System.out.println(new String(myArray));
            }
        } catch (FileNotFoundException e1) {
            e1.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }


运行结果并不会出现乱码

23

字符流


Reader类


优点：

  • 对InputStream进行包装

  • 比较擅长读取文本文件


还是拿刚刚的文件进行测试，为了解决中文问题，引用字符流

/**
     * 引用字符流，来解决中文问题
     * Reader抽象类，InputStreamReader实现类
     */
    public static void test12() {
        try {
            //InputStreamReader(InputStream in, String charsetName)   可以设置文件的编码
            Reader reader = new InputStreamReader(new FileInputStream("src/a.txt"), "UTF-8");
            int a;
            while((a = reader.read())!= -1){
                System.out.print((char)a);
            }
            reader.close();
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

24


使用数组进行读取

    /**
     * 字符流其实就是对字节流进行了包装
     * 字符流读数组
     */
    public static void test13() {
        try {
            Reader reader = new InputStreamReader(new FileInputStream("src/a.txt"), "UTF-8");

            //字符长度越大，越不会出错
            char myArray[] = new char[12];
            int a;
            while((a = reader.read(myArray))!= -1){
                System.out.print(new String(myArray));
            }
            reader.close();
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

25

BufferedReader类


性能优化：

  • 使用BufferedReader 进行包装
    /**
     * 字符流
     * BufferedReader
     * 提高读取效率
     */
    public static void test15() {
        try {
            BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream("src/a.txt"), "UTF-8"));
            //准备读取
            while (reader.ready()) {
                //打印一行数据
                System.out.println(reader.readLine());
            }
            reader.close();
        } catch (UnsupportedEncodingException | FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

26

Writer类


所谓有读取就有写入，所以引用字符输出流Writer，对OutputStream进行包装

  • 写入数据到文件
    /**
     * 字符流
     * Writer抽象类，OutputStreamWriter实现类
     * 写入数据到文件
     */
    public static void test14() {
        try {
            //true表示在尾部继续添加数据
            Writer writer = new OutputStreamWriter(new FileOutputStream("c.txt",true));
            //BufferedWriter bw = new BufferedWriter(writer);
            writer.write("零度");
            writer.flush();
            writer.close();



        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

数据已经写入到c.txt文件下了

27

BufferedWriter类


性能优化：

  • 当然我们也可以让程序写快一些，就是使用BufferedWriter
/**
     * 字符流
     * BufferedWriter
     * 提高写入字符流效率
     */
    public static void test16() {
        try {
            BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("a.txt")));
            bw.write("hello 零度!");
            bw.write("pro");
            bw.flush();
            bw.close();
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

28

Scanner 类


Scanner 类使读取文件更为简单

/**
 *读取文件的时候要更方便
 */
public static void test18() {
    try {
        Scanner sc = new Scanner(new FileInputStream("a.txt"));
        while(sc.hasNextLine()){
            System.out.println(sc.nextLine());
        }
        System.out.println("读取完成！");
    } catch (FileNotFoundException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }


}

29

printWriter类


对输出流进行包装，输出操作更简单了

    /**
     *为了能够输出数据的时候更方便，我们要引入printWriter
     */
    public static void test17() {
        try {
            PrintWriter pw = new PrintWriter("a.txt");
            pw.print("I am 零度! 我");
            pw.print(18);
            pw.print("岁");
            pw.flush();
            pw.close();
            System.out.println("写入完成！");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }

    }

30

31

Lingdu丶
关注
专栏目录
java_io详解
01-15
关于java io技术的详解：IO（Input/Output）是计算机输出/输出的接口。Java的核心库java.io提供了全面的IO接口，包括：文件读写，标准设备输出等等。Java中IO是以流为基础进行输入输出的，所有数据被串行化写入输出流，或者从输入流读入。此外，Java也对块传输提供支持，在核心库java.nio中采用的便是块IO。关于NIO我们在后面还有专门的讨论。 　　流IO的好处是简单易用，缺点是效率较低。块IO效率很高，但编程比较复杂。
Java中io流解析及代码实例
08-28
Java中IO流解析及代码实例 Java中IO流是一种基本的输入/输出机制，用于读取和写入数据。IO流可以分为两种：字节流和字符流。字节流按照字节来读取和写入数据，而字符流按照字符来存取数据。 字节流 字节流是Java...
Java IO _字节流与字符流
韩世雷 程序员专栏
08-23 1348
1.掌握流的概念 2.掌握字节流与字符流的作用 3.掌握文件的标准操作步骤 4.掌握字节与字符操作的区别 1、流的概念 程序中的输入输出都是以流的形式保存的，流中保存的实际上全都是字节文件。 2、字节流与字符流 内容操作就四个类：OutputStream、InputStream、writer、Rader 使用 File 类操作的时候一定要有路
Java中的IO流-最全最基础的IO流概述和简介
最新发布
是程序喵呀
08-23 2570
Java中的IO流是用于处理数据输入和输出的核心机制。通过应用IO流可以使Java程序能够与外部世界（如磁盘文件、网络、硬件设备等）进行数据交互。IO流的全称为输入/输出流（Input/Output Stream），它是Java编程语言中用于数据传输的一种抽象模型。流可以被想象为数据的连续流动，就像水通过管道一样，数据通过流从一个地方流向另一个地方。文件流是用来连接我们的程序与文件之间的"管道",用来读写文件中的数据。
java io流
weixin_41729259的博客
03-30 144
参考1 参考2 JAVA基础知识之IO——Java IO体系及常用类 Java IO体系 个人觉得可以用“字节流操作类和字符流操作类组成了Java IO体系”来高度概括Java IO体系。 借用几张网络图片来说明(图片来自 http://blog.csdn.net/zhangerqing/article/details/8466532 ) 基于字节的IO操作 基于字符的IO操作 从上图...
java io流
Noreaday的博客
03-13 198
如：生活中图片、影视等都是以字节存在的。字节流可以读取任何类文件（可以读取字符流可以读取的任何文件，反之不行）java  io流类有很多，类以inputstream或outputstream结尾的是字节流；以reader、writer结尾的是字符流。...
[Java]Day9:IO流 字节流 字符流 Properties集合
DhzWorld的博客
09-03 176
File类 File类 文件和目录路径名的抽象表示 文件和目录是可以通过File封装成对象的 对于File而言,其封装的并不是一个真正存在的文件,仅仅是一个路径名而已,它可以是存在的,也可以是不存在的,将来是要通过具体的操作把这个路径的内容转换为具体存在的 File类构造方法 方法名 说明 File(String pathname) 通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例 File(String parent, String child) 从父
Java 中IO流字符流详解及实例
08-30
* OutputStreamWriter 是字符流通向字节流的桥梁：可使用指定的 charset 将要写入流中的字符编码成字节。 3. 文件读写流 文件读写流是文件读写操作的基本实现。FileReader 和 FileWriter 是读取字符文件和写入字符...
Java中IO流 RandomAccessFile类实例详解
08-30
Java中IO流 RandomAccessFile类实例详解 Java中的IO流 RandomAccessFile类实例详解是Java中IO流的重要组成部分。RandomAccessFile类提供了对文件内容的访问，既可以读文件，也可以写文件。同时，RandomAccessFile类...
Java中IO流详解
08-30
Java中IO流详解 Java中IO流详解是指Java语言中负责输入输出操作的类库，主要包括字节流和字符流两大类。下面将详细介绍Java中IO流的知识点。 一、IO解决的问题 IO流解决了设备之间的数据传输问题，例如硬盘和...
Java 中IO流分为哪几种？ BIO、NIO、AIO有什么区别？
01-07
Java中的流分为两种，一种是字节流，另一种是字符流，分别由四个抽象类来表示（每种流包括输入和输出两种所以一共四个）:InputStream，OutputStream，Reader，Writer。Java中其他多种多样变化的流均是由它们派生出来...
java IO流
weixin_41765786的博客
07-15 511
在java程序中，对于数组的输入/输出操作以“流（stream）”的方式进行；Java提供了各种各样的“流”类，用以获取不同种类的数据；程序中通过标准的方法输入或输出数据。java的流类型一般位于java.io包中。数据源datasource,提供原始数据的原始媒介。常见的数据库、文件、其他程序、内存、网络连接、IO设备。流是一个抽象、动态的概念，是一连串连续动态的数据集合。数据源就像水箱，流就像水管中流着的水流，程序就是我们最终的用户。流是一个抽象动态的概念，是一连串连续动态的数据集合。...
JAVA IO流
weixin_55076626的博客
02-03 673
1、节点流可以从一个特定的数据源读写数据，如FileReader、FileWriter。2、处理流（也叫包装流）是”连接“在已存在的流（节点流或处理流）之上，为程序提供更为强大的读写功能，如BufferedReader、BufferedWriter。
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、付费专栏及课程。

余额充值