凯哥带你从零学大数据系列之Java篇---第二十六章 IO流详解_jdkio流(2)

于 2024-04-29 03:30:05 发布
阅读量230 收藏 9
点赞数 3
分类专栏： 程序员 文章标签： 大数据 java python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_84301352/article/details/138297936
版权 
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;

/**
 * @Description 字节输出流，写文件
 */
public class OutputStreamTest {
    public static void main(String[] args) {
        // 1. 实例化一个管道，连接文件和程序。
        //    对于FileOutputStream来说，如果目标文件不存在，则会自动的创建。
        //    当无法创建这个文件的时候(父级目录不存在)，创建会失败，会触发 FileNotFoundException 。
        try (OutputStream outputStream = new FileOutputStream("file\\day25\\dst", true)) {
            // 2. 准备需要写入到这个文件中的数据
            String message = "你好，师姐";
            // 3. 将数据写入到输出流中，由输出流写入到文件中
            outputStream.write(message.getBytes());

            // 冲刷缓冲区，将缓冲区中的数据强制流动到文件中。
            // 在流关闭的时候，会自动的调用。
            outputStream.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
​

2.6. 案例: 文件拷贝

2.6.1. 需求分析

实现， 将一个文件拷贝到另外一个地方。 注意， 这个不是剪切， 拷贝完成之后， 原文件还在。

实现方式： 借助两个流来完成。

  • 使用字节流输入， 循环读取原文件中的数据。
  • 使用字节输出流， 将每次读取到的数据， 写入到目标文件中。
2.6.2. 示例代码
import java.io.*;

/**
 * @Description 使用字节流实现文件的拷贝
 */
public class FileCopy {
    public static void main(String[] args) {
        boolean ret = copy("C:\\Users\\luds\\Desktop\\src.mp4", "C:\\Users\\luds\\Desktop\\dst.mp4");
        System.out.println(ret);
    }

    /**
     * 实现功能: 将源文件中的数据拷贝到目标文件
     * @param srcPath 原文件路径
     * @param dstPath 目标文件路径
     * @return 拷贝的结果
     */
    private static boolean copy(String srcPath, String dstPath) {
        // 1. 判断目标路径上，是否有文件存在
        File dst = new File(dstPath);
        if (dst.exists()) {
            return false;
        }
        // 2. 实现文件的拷贝
        try (InputStream inputStream = new FileInputStream(srcPath);
             OutputStream outputStream = new FileOutputStream(dst)) {
            // 拷贝的过程
            // 2.1. 实例化一个字节数组
            byte[] array = new byte[1024];
            // 2.2. 声明一个整型变量，用来记录每次读取到了多少个字节的数据
            int length = 0;
            // 2.3. 循环读取数据
            while ((length = inputStream.read(array)) != -1) {
                // 2.4. 将读取到的数据，写入到输出流中
                outputStream.write(array, 0, length);
            }
            // 2.5. 冲刷缓冲区
            outputStream.flush();
            return true;
        }
        catch (IOException e) {
            e.printStackTrace();
            return false;
        }
    }
}

2.7. Reader

2.7.1. Reader的简介

这是一个字符输入流。 从方向来说， 是一个输入流， 数据是从文件中流动到程序中， 是为了读取文件中的数据的。 从数据单位来说， 这个流中流动的数据是以字符为单位的。

2.7.2. 读取文件
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;

/**
 * @Description 字符输入流读取数据
 */
public class ReaderTest {
    public static void main(String[] args) {
        // 读取过程与字节输入流完全相同，只需要将使用到的类换一下即可。
        try (Reader reader = new FileReader("file\\day25\\src")) {
            // 1. 实例化一个字符数组
            char[] array = new char[100];
            // 2. 声明一个变量，用来记录每次读取到了多少个数据
            int length = 0;
            // 3. 循环读取数据
            while ((length = reader.read(array)) != -1) {
                String str = new String(array, 0, length);
                System.out.print(str);
            }
        }
        catch (IOException e) {
            e.printStackTrace();
        }
    }
}

2.8. Writer

2.8.1. Writer的简介

字符输出流。 从方向上来分， 是一个输出流， 数据从程序中流动到文件中， 实现文件的写操作。 从流中流动的数据单位来分， 是一个字符流， 流中流动的数据是以字符为单位的。

2.8.2. 文件的写操作
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;

/**
 * @Description 使用字符流写数据
 */
public class WriterTest {
    public static void main(String[] args) {
        // 1. 实例化相关的类
        try (Writer writer = new FileWriter("file\\day25\\target", true)) {
            // 2. 将数据写入到输出流中
            writer.write("hello, world");
            // 3. 冲刷缓冲区
            writer.flush();
        }
        catch (IOException e) {
            e.printStackTrace();
        }
    }
}

2.9. 案例: 文件拷贝

2.9.1. 需求分析

实现， 将一个文件拷贝到另外一个地方。 注意， 这个不是剪切， 拷贝完成之后， 原文件还在。

实现方式： 借助两个流来完成。

  • 使用字符输入流， 循环读取原文件中的数据。
  • 使用字符输出流， 将每次读取到的数据， 写入到目标文件中。
2.9.2. 示例代码
/**
  * 使用字符流实现文件的拷贝
  * @param srcPath 原文件路径
  * @param dstPath 目标文件路径
  */
private static void fileCopy2(String srcPath, String dstPath) {
    // 2. 循环读取目标文件中的数据
    try (Reader reader = new FileReader(srcPath); Writer writer = new FileWriter(dstPath)) {
        // 3. 循环读取源文件中的数据
        char[] array = new char[100];
        int length = 0;
        while ((length = reader.read(array)) != -1) {
            // 4. 将读取到的数据写入到输出流
            writer.write(array, 0, length);
        }
        writer.flush();
        return true;
    }
    catch (IOException e) {
        e.printStackTrace();
        return false;
    }
}

3. 常见的其他流

3.1. 缓冲流

3.1.1. 缓冲流的简介

给普通的IO流， 套上一个缓冲区。 所有的使用缓冲流进行的读写操作， 都是和缓冲区进行交互的， 避免了频繁的IO操作。 这样一来， 带来的好处就是可以提高读写的效率。 这个缓冲区， 其实是一个数组。

常见的缓冲流:

  • BufferedInputStream : 缓冲字节输入流
  • BufferedOutputStream ： 缓冲字节输出流
  • BufferedReader ： 缓冲字符输入流
  • BufferedWriter ： 缓冲字符输出
3.1.2. 缓冲字节流
import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;

/**
 * @Description BufferedInputStream使用
 */
public class BufferedInputStreamTest {
    public static void main(String[] args) {
        // 过程和InputStream一模一样的
        // 缓冲字节输入流流是需要基于一个字节输入流来进行实例化的
        // 在这里，BufferedInputStream构造方法中的InputStream对象，只是用来做当前的对象的实例化，在使用结束的时候，理论上来讲，是需要关闭的
        // 实际在使用中，使用结束后，只需要关闭BufferedInputStream即可。
        try (BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream("file\\day26\\source"))) {
            // 1. 实例化一个字节数组
            byte[] array = new byte[1024];
            // 2. 声明一个整型变量，用来记录每次读取了多少个字节数据
            int length = 0;
            // 3. 循环读取
            while ((length = bufferedInputStream.read(array)) != -1) {
                // 4. 将读取到的数据转成字符串输出到控制台
                String msg = new String(array, 0, length);
                System.out.println(msg);
            }
        }
        catch (IOException e) {
            e.printStackTrace();
        }
    }
}

import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;

/*
 * @Description BufferedOutputStream
 */
public class BufferedOutputStreamTest {
    public static void main(String[] args) {
        // 1. 实例化一个缓冲字节输出流对象
        try (BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(new FileOutputStream("file\\day26\\target")))  {
            // 2. 将数据写入到输出流中
            bufferedOutputStream.write("hello world".getBytes());
            bufferedOutputStream.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
3.1.3. 缓冲字符流
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

/**
 * @Description
 */
public class BufferedReaderTest {
    public static void main(String[] args) {
        // 借助一个字符流，实例化一个缓冲字符输入流
        try (BufferedReader bufferedReader = new BufferedReader(new FileReader("file\\day26\\src"))) {
            // 从流中读取数据
            char[] array = new char[100];
            int length = 0;
            while ((length = bufferedReader.read(array)) != -1) {
                System.out.print(new String(array, 0, length));
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

/**
 * @Description
 */
public class BufferedWriterTest {
    public static void main(String[] args) {
        // 借助一个字符输出流，实例化一个缓冲字符输出流对象
        try (BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("file\\day26\\dst"))) {
            bufferedWriter.write("hello world");
            bufferedWriter.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
3.1.4. 缓冲流中的特殊方法

BufferedReader 类中多了一个方法 readLine()

  • 意义: 读取缓冲流中的一行数据， 可以逐行读取。 一直到读取到的数据是null， 表示数据读取完了， 没有下一行数据了。
  • 注意事项: readLine() 是逐行读取， 但是， 只能读取到一行中的内容， 并不能读取走换行符。
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

/*
 * @Date 2020/4/26
 * @Description
 */
public class BufferedReaderSpecial {
    public static void main(String[] args) {
        try (BufferedReader reader = new BufferedReader(new FileReader("file\\day26\\src"))) {
            // 1. 定义一个字符串，用来接收每一行读取到的数据
            String line = "";
            // 2. 循环读取数据
            while ((line = reader.readLine()) != null) {
                // 3. 将读取到的数据输出
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

BufferedWriter 类中多了一个方法 newLine()

  • 意义： 无参的方法， 写一个换行符。
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

/**
 * @Description
 */
public class BufferedWriterSpecial {
    public static void main(String[] args) {
        try (BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("file\\day26\\dst"))) {
            bufferedWriter.write("hello world");
            bufferedWriter.newLine();
            bufferedWriter.write("你好，世界");
            bufferedWriter.newLine();
            bufferedWriter.write("end");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

使用缓冲字符流进行文件的拷贝

import java.io.*;

/**
 * @Description 使用缓冲字符流实现文本文件的拷贝
 */
public class BufferedCopy {
    public static void main(String[] args) {
        try (BufferedReader reader = new BufferedReader(new FileReader("file\\day26\\src"));
             BufferedWriter writer = new BufferedWriter(new FileWriter("file\\day26\\destination"))) {
            String line = "";
            while ((line = reader.readLine()) != null) {
                writer.write(line);
                writer.newLine();
            }
            writer.flush();
        }
        catch (IOException e) {
            e.printStackTrace();
        }
    }

3.2. Scanner类

3.2.1. 简介

这个类， 并不是一个IO流。 是一个扫描器， 这个类最主要的作用， 是从一个文件中或者从一个流中浏览数据。 在这个类中封装了若干个方法， 方便了数据的读取。

3.2.2. API

注意事项

这里nextLine和BufferedReader中的readLine都可以读取一行数据。 但是区别在于： 结束条件不同。

  • BufferedReader: 如果读取到的数据是null, 说明没有下一行数据了。
  • Scanner: 如果没有下一行了，再去读取，会出现异常。 所以， 此时的结束条件是 hasNextLine() 为false。
import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;
import java.util.regex.Pattern;

/**
 * @Description Scanner类的方法
 */
public class ScannerTest {
    public static void main(String[] args) {
        // 其实，Scanner在使用结束之后，也是需要进行关闭的。 调用close方法。
        try (Scanner scanner = new Scanner(new File("file\\day26\\src"))) {
            // 读取文件中的内容
            while (scanner.hasNextLine()) {
                System.out.println(scanner.hasNextLine());
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }

3.3. 标准输入输出流

3.3.1. 简介

标准输入流: http://System.in : 连接了程序和控制台。 读取控制台中的内容。

标准输出流: System.out ： 连接了程序和控制台。 将程序中的内容输出到控制台。

3.3.2. 标准输入流

import java.io.BufferedInputStream;
import java.io.IOException;
import java.util.Scanner;

/**
 * @Description 标准输入流
 */
public class SystemInTest {
    public static void main(String[] args) {
        try (BufferedInputStream bis = new BufferedInputStream(System.in)) {
            byte[] array = new byte[128];
            int length = 0;
            while ((length = bis.read(array)) != -1) {
                String str = new String(array, 0, length);
                System.out.println(str);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

3.3.3. 标准输出流

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintStream;

/**
 * @Description 标准输出流
 */
public class SystemOutTest {
    public static void main(String[] args) {
        PrintStream original = System.out;
        // PrintStream: 是一个打印流，可以将数据输出到指定位置。
        try (PrintStream ps = new PrintStream(new FileOutputStream("file\\day26\\logs", true))) {
            // ps.println("hello world！");
            // 重定向标准输出流
            System.setOut(ps);

            System.out.println("123");
        }
        catch (IOException e) {
            e.printStackTrace();
        } finally {
            System.setOut(original);
        }

        System.out.println("你好");

        // System.out;      标准输出流地址
        // System.out -> ps
    }
}

3.4. 转换流

3.4.1. 为什么要用转换流

在进行文件读取的时候， 如果项目采用的字符集和文件的字符集不同，会出现乱码的情况。

3.4.2. 输入流
import java.io.*;

/**
 * @Description 转换流
 *      转换输入流：可以以指定的字符集读取某一个文件中的数据
 *      转换输出流：可以以指定的字符集把数据写入到某一个文件
 */
public class TransforeTest {
    public static void main(String[] args) {
        read();
    }
    private static void read() {
        // 当前的项目是 utf-8, 读取的文件是 GBK


### 给大家的福利


**零基础入门**


对于从来没有接触过网络安全的同学，我们帮你准备了详细的学习成长路线图。可以说是最科学最系统的学习路线，大家跟着这个大的方向学习准没问题。


![](https://img-blog.csdnimg.cn/img_convert/95608e9062782d28f4f04f821405d99a.png)


同时每个成长路线对应的板块都有配套的视频提供：


![在这里插入图片描述](https://img-blog.csdnimg.cn/direct/a91b9e8100834e9291cfcf1695d8cd42.png#pic_center)


因篇幅有限，仅展示部分资料


网络安全面试题


![](https://img-blog.csdnimg.cn/img_convert/80674985176a4889f7bb130756893764.png)


绿盟护网行动


![](https://img-blog.csdnimg.cn/img_convert/9f3395407120bb0e1b5bf17bb6b6c743.png)


还有大家最喜欢的黑客技术


![](https://img-blog.csdnimg.cn/img_convert/5912337446dee53639406fead3d3f03c.jpeg)


**网络安全源码合集+工具包**


![](https://img-blog.csdnimg.cn/img_convert/5072ce807750c7ec721c2501c29cb7d5.png)


![](https://img-blog.csdnimg.cn/img_convert/4a5f4281817dc4613353c120c9543810.png)

**所有资料共282G**，朋友们如果有需要全套《网络安全入门+黑客进阶学习资源包》，可以扫描下方二维码领取（如遇扫码问题，可以在评论区留言领取哦）~




**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**[需要这份系统化资料的朋友，可以点击这里获取](https://bbs.csdn.net/topics/618540462)**


**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**
2401_84301352
关注
  • 3
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
GB_T15843.6-2018信息技术_安全技术_实体鉴别第6部分：采用人工数据传递的机制.pdf
05-27
GB_T15843.6-2018信息技术_安全技术_实体鉴别第6部分：采用人工数据传递的机制
IO流 （字节流、字符流）
qq_46030254的博客
06-08 4666
IO流的作用：就是可以对文件或者网络中的数据进行读、写的操作。如下图所示IO流在Java中有很多种，不同的流来干不同的事情。Java把各种流用不同的类来表示，这些流的继承体系如下图所示：IO流分为两大派系：1.字节流：字节流又分为字节输入流、字节输出流2.字符流：字符流由分为字符输入流、字符输出流。
最全最详细的IO流教程
奔跑的熊猫
05-27 7990
最全最详细的IO流教程
IO流详解.
lwj_07的博客
04-01 5767
一、IO流概述 IO流： 什么是IO？ I：Input O：Output (断电内存数据消失) 二、IO流的分类 Io流的分类? 有多种分类方式: 一种方式是按照流的方向进行分类: 以内存作为参照物,往内存中去，叫做输入(Input)。或者叫做读(Read)。从内存中出来，叫做输出(Output)。或者叫做写(Write) 另一种方式是按照读取数据方式不同进行分类: 有的流是按照字节的方式读取数据，一次读取1个字节byte,等同于一次读...
IO 流超级详细讲解
业精于勤，荒于嬉
03-31 1269
从该输入流读取一个字节的数据。如果没有输入可用，此方法将阻止。//如果返回-1 , 表示读取完= -1)}//转成 char 显示 }1. new FileOutputStream(filePath) 创建方式，当写入内容是，会覆盖原来的内容2. new FileOutputStream(filePath, true) 创建方式，当写入内容是，是追加到文件后面3. 写入一个字节 fileOutputStream.write('H');4. 写入字符串 String str = "world!
IO流 详细介绍（秒懂百科）
weixin_55772633的博客
08-17 999
voidclose()关闭此输入流并释放与该流关联的所有系统资源。read()从输入流读取下一个数据字节。（多次调用会按顺序依次读取）返回-1表示读取完毕int从输入流中读取一定数量的字节并将其存储在缓冲区数组 b 中。int将输入流中最多 len 个数据字节读入字节数组。
Java-飞机大战小游戏
03-31
飞机大战小游戏，如有侵权请联系删除
凯哥三论数据中台 外发版.pdf
07-02
凯哥三论数据中台 外发版.pdf
千峰凯哥python第3章 Django
05-15
此文件是凯哥Python基础第三章的讲义文件目录如下 1、Django基本流程走通 2、Django中的模型 3、Django中的视图 4、Django中的模板 5、Django的高级使用 6、Django爱鲜蜂项目第一天 7、Django爱鲜蜂项目第二天 8、...
千峰凯哥python第2章 前端基础
05-15
此文件是凯哥Python基础第四章的讲义文件目录如下 1、html&css;基础 2、html&css;提升 3、JavaScript基础 4、JavaScript提升 5、JavaScript进阶与轮播和飞机大战坦克 6、JQuery基础 7、JQuery提升 8、H5C3基础 9、...
IO流的介绍
weixin_52014130的博客
07-08 1784
1.IO流属于一种Java技术，主要用于处理数据传输。通过IO与外界进行数据交互，通信等。 2.IO流适用于文件，图片，音乐，视频等等的传输任务。 3.通信的目标也存在多种。例如：文件，数据库，网络地址，硬件设备等等。1.按流的方向分为：输入流和输出流。【硬盘《-----》内存】2.按流的数据单位不同分为：字节流和字符流。Byte《-----》char3.按流的功能不同分为：节点流和处理流(装饰流)。注意：输入流：外部/内部设备向内存的方向进行数据传输。输出流：内存向外部/内
IO流详解及常用方法
千锋教育
02-20 1152
此时， 在try结构执行结束的时候， 会自动的调用AutoClosable接口实现类中的close方法， 进行流的关闭。从流中流动的数据单位来分， 是一个字节流， 流中流动的数据是以字节为单位的。从流中流动的数据单位来分， 是一个字符流， 流中流动的数据是以字符为单位的。从方向来说， 是一个输入流， 数据是从文件中流动到程序中， 是为了读取文件中的数据的。从方向来说， 是一个输入流， 数据是从文件中流动到程序中， 是为了读取文件中的数据的。流: 指的是一串流动的数据， 在数据在流中按照指定的方向进行流动。
IO流的详解，彻底了解IO流
菠萝吹雪爱Java的博客
02-02 2379
Java对数据的操作是通过流的方式,学好IO流可以方便地实现数据的输入/输出操作，其重要性不言而喻。以下是本篇文章的思维导图以上就是今天要讲的内容，本文从操作系统进行文件读写入手，对同步、异步、阻塞、非阻塞以及它们组合而成的IO模式进行了介绍，还介绍了Linux操作系统中的五种IO模型，相信大家应该有了一定的了解。如有不恰当的地方，还请雅正。参考资料：1.要问技术多NB，请问IO模型知多少？2.Java IO流详解3.Java中五中IO模型详解文章知识点与官方知识档案匹配，可进一步学习相关知识。
IO流详解
Maddoxzhi的博客
10-26 1533
I/O是Input和Output的缩写，I/O技术是非常实用的技术，用于处理数据传输，如读/写文件，网络通讯等 Java程序中，对于数据的输入/输出操作以“流（Stream）”的方式进行 Java.io包下提供了各种“流”类和接口，用以获取不同种类的数据，并通过方法输入或输出数据 输入input：读取外部数据（磁盘、光盘等存储设备的数据）到程序（内存）中 输出output：将程序（内存）数据输出到磁盘、光盘等存储设备中
Java io流 详解
m0_68987535的博客
06-11 4214
"IO流"（Input/Output stream）指的是Java中用于处理输入输出（I/O）数据的机制。在Java中，所有的输入和输出都被抽象为“流”对象，并通过输入流读取数据、输出流写入数据。Java的I/O包提供了丰富的类和方法来支持不同类型的流，输入流和输出流之间可以自由地进行转换。它们分别主要包括字节流和字符流两种类型。其中，字节流是操作二进制数据的流，可以处理任何类型的数据，常见的例如InputStream和OutputStream；
JAVA—IO流详解
weixin_48006490的博客
09-01 7799
IO:Input/Output即输入&输出，也称之为流（河流，水流），指的是数据从一个地点到另一个地点过程；对于计算机来说文件的拷贝过程，文件的编写保存，显示功能都是使用到IO；将数据的传输过程看做一个输入输出。现实角度考虑可以将耳朵作为输入流，将嘴巴当做输出流输入输出介质：文件网络键盘（输入）显示器（输出）
面试官：请讲一讲IO流核心模块与基本原理是什么？
程序媛小琬的博客
08-20 968
前言 一、IO流与系统 IO技术在JDK中算是极其复杂的模块，其复杂的一个关键原因就是IO操作和系统内核的关联性，另外网络编程，文件管理都依赖IO技术，而且都是编程的难点，想要整体理解IO流，先从Linux操作系统开始。 Linux空间隔离 Linux使用是区分用户的，这个是基础常识，其底层也区分用户和内核两个模块： User space：用户空间 Kernel space：内核空间 常识用户空间的权限相对内核空间操作权限弱很多，这就涉及到用户与内核两个模块间的交互，此时部署在服务上的应用如果需要请求系
IO流的概念
weixin_45845391的博客
04-25 3358
IO流的概念 IO就是Input和Output的简写，也就是输入和输出的含义 IO流就是读写数据时像流水一样从一端流到另外一端，因此得名为"流" 基本分类 按照读写数据的基本单位不同，分为字节流和字符流 其中字节流主要指以字节为单位进行数据读写的流，可以读写任意类型的的文件 其中字符流主要指以字符（2个字节）为单位进行数据读写的流，只能读写文本文件。 按照读写数据的方向不同，分为输入流和输出流（站在程序的角度） 其中输入流主要指从文件中读取数据内容输入到程序中，也就是读文件 其中输出流主要指将程序中的数据内
简述IO流
weixin_56177676的博客
04-16 1205
注：本文章由本人整理笔记。参考韩顺平IO流专题链接在此 IO流，就是Input流 (输入流) 和Output流 (输出流) 的简写。JavaIO流根据处理数据类型的不同分为字符流和字节流，根据数据流向不同分为输入流和输出流，对输入流只能进行读操作，对输出流只能进行写操作，程序中需要根据待传输数据的不同特性而使用不同的流。 （1）、文件 文件 :文件,对我们并不陌生，文件是保存数据的地方,比如大家经常使用的word文档,txt文件,excel文件..都是文件。它既可以保存一张图...
docker下载jdk镜像文件
最新发布
08-19
要在Docker中下载JDK镜像文件，您可以使用以下命令： ``` docker pull <镜像名称> ``` 对于OpenJDK的官方镜像，可以使用以下命令来下载： ``` docker pull openjdk ``` 如果您需要特定版本的JDK，可以指定标签，例如： ``` docker pull openjdk:11 ``` 这将下载OpenJDK 11版本的镜像文件。请注意，您需要确保已经安装并配置了Docker。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值