输入输出IO流

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

文章目录

1.数据源

数据源：提供数据的原始媒介。
数据源分为：源设备、目标设备。
源设备：为程序提供数据，一般对应输入流。
目标设备：程序数据的目的地，一般对应输出流

2.流

数据源就像水箱，流(stream)就像水管中流着的水流，程序就是我们最终的用户。 流是一个抽象、动态的概念，是一连串连续动态的数据集合。
在这里插入图片描述

当程序需要读取数据源的数据时，就会通过IO流对象开启一个通向数据源的流，通过这个IO流对象相关方法可以顺序读取流中的数据。

3.IO流的分类

输入(Input)指的是：将外部(硬盘、数据库、浏览器等)数据写入到程序中（核心含义是“读”，读取外部数据）。
输出(Output)指的是：将程序中的数据写出到外界（核心含义是“写”，将数据写出到外部系统）。
1、 按流的方向分类
输入流：数据流向是数据源到程序(InputStream、Reader结尾的流)
输出流：数据流向是程序到目的地(OutPutStream、Writer结尾的流)
2、 按处理的数据单元分类
字节流：按照字节读取数据(InputStream、OutputStream)，命名上以stream结尾的流一般是字节流。
字符流：按照字符读取数据(Reader、Writer)，命名上以Reader/Writer结尾的流一般是字符流。
3、按处理对象不同分类
节点流（普通流）：可以直接从数据源或目的地读写数据。
处理流（包装流）：不直接连接到数据源或目的地，是“处理流的流”。通过对其它流进行封装，目的主要是简化操作和提高程序的性能。
节点流处于IO操作的第一线，所有操作必须通过他们进行；处理流可以对节点流进行包装，提高性能或提高程序的灵活性。
在这里插入图片描述

4.字节流

字节流是以字节(二进制数据)方式读写数据,主要用于操作二进制数据，Java中字节流对象分为两种:字节输入流对象InputStream,字节输出流对象OutputStream,这两个是抽象类所以无法直接创建对象,需要使用其子孙类创建：
字节输入流对象InputStream子类FileInputStream
字节输出流对象OutputStream子类FileOutputStream
字节流是万能流,他可以读取计算机中的任意类型文件或程序或音频视频等等。

4.1文件字节输入流

1. FileInputStream类概述

FileInputStream类是InputStream的子类,实现类父类中所有的方法,方法与父类也是相同的,主要用于数据的读取
FileInputStream类是节点流(普通流),是操作文件数据的基本流

2. FileInputStream类构造方法

  1. public FileInputStream(String name):创建对象并指定文件位置
    1. name:String类型指定文件位置
  2. public FileInputStream(File file):创建对象并指定文件位置
    1. file:File类型指定文件位置

3. FileInputStream类常用方法

  1. public abstract int read():读取数据到Java应用程序,一次读取一个字节数据
  2. public int read(byte b[]):读取数据到Java应用程序,一次读取一个字节数组数据
  3. public int read(byte b[], int off, int len):读取数据到Java应用程序,一次读取一个字节数组数据,并指定数据的起始位置以及数据长度
  4. public int available():读取数据的总长度(总字节数)
  5. public void close():关闭输入流并释放资源

4.2文件字节输出流

1. FileOutputStream类概述

FileOutputStream类是OutputStream的子类,实现类父类中所有的方法,方法与父类也是相同的,主要用于数据的写出
FileOutputStream类是节点流(普通流),是操作文件数据的基本流

2. FileOutputStream类构造方法

  1. public FileOutputStream(String name):创建对象并指定文件输出的位置
    1. name:String类型指定文件位置
  2. public FileOutputStream(String name, boolean append):创建对象并指定文件输出的位置,以及是否为追加文本
    1. name:String类型指定文件位置
    2. append:true为追加文本,false为不追加文本(默认为false)
  3. public FileOutputStream(File file):创建对象并指定文件输出的位置
    1. file:File类型指定文件位置
    2. append:true为追加文本,false为不追加文本(默认为false)
  4. public FileOutputStream(File file, boolean append):创建对象并指定文件输出的位置,以及是否为追加文本
    1. file:File类型指定文件位置
    2. append:true为追加文本,false为不追加文本(默认为false)

3. FileOutputStream类常用方法

  1. public abstract void write(int b):从Java应用程序写出数据到文件,一次写出一个字节数据
  2. public void write(byte b[]):从Java应用程序写出数据到文件,一次写出一个字节数组数据
  3. public void write(byte b[], int off, int len):从Java应用程序写出数据到文件,一次写出一个字节数组数据,并指定数据的起始位置以及数据长度
  4. public void flush():强制刷新流数据,将还在数据流中的数据强制写出
  5. public void close():关闭输出流并释放资源
    public static void main(String[] args) {
        //1.定义源文件
        String sourcePath = "text.txt";
		//2.定义目的地
        String targetPath = "src/Demo.txt";
//        copyFile(sourcePath,targetPath);
        //1.定义源文件
        //图片的绝对路径
        sourcePath = "C:\\Users\\huashuo\\Pictures\\Saved Pictures\\9.jpg";
        //2.定义目的地
        //拷贝的相对路径
        targetPath = "src/img/demo.gif";
//        copyFile(sourcePath,targetPath);
        //1.定义源文件
        //视频的绝对路径
        sourcePath = "C:\\Users\\huashuo\\Videos\\MgtvVideos\\Myvedio\\FamilyTime.mp4";
        //2.定义目的地
        //拷贝的相对路径
        targetPath = "src/video/demo.avi";
//        copyFile(sourcePath,targetPath);
        //1.定义源文件
        //软件的绝对路径
        sourcePath = "D:\\软件\\Install Termius.exe";
        // 2. 定义目的地
        // 拷贝的相对路径
        targetPath = "src/soft/Install Termius.exe";
        copyFile(sourcePath,targetPath);
    }
    private static void copyFile(String sourcePath, String targetPath){
        // 使用JDK1.7新特性try...with...resource
        try(
               //1.字节输入流对象
               InputStream fis = new FileInputStream(sourcePath);
               //2.字节输出流对象
               OutputStream fos = new FileOutputStream(targetPath);
       ){
           //3.定义一个接收数据的字节数组
           byte[] bytes = new byte[1024];
           //4.声明length属性，用于接收读取数据的长度
           int length;
           //5.循环读取字节数据
           while((length=fis.read(bytes)) != -1){
               //6.循环写出数据
               fos.write(bytes,0,length);
               //7.强制刷新流数据
               fos.flush();
           }
       }catch (Exception e){
           e.printStackTrace();
       }
    }
   /**
     * 拷贝文件步骤
     * // 1. 字节输入流对象
     * // 2. 字节输出流对象
     * // 3. 定义byte数组,用于接收读取的数据
     * // 4. 声明length属性,用于接收读取数据的长度
     * // 5. while循环读取数据
     * // 6. 循环写出数据
     * // 7. 强制刷新流数据
     * // 8. 释放资源
     */

5字符流

字符流是以字符方式读写数据,主要操作文字,文字并不是单指汉子,包括所有国家文字
Java中字符流对象分为两种:字符输入流对象Reader,字符输出流对象Writer,这两个是抽象类所以无法直接创建对象,需要使用其子孙类创建
字符输入流对象Reader子类FileReader
字符输出流对象Writer子类FileWriter
字符流只能读写使用文本文档打开后可以看的懂得文件,如果文本文档打开是乱码的则无法读写

5.1. FileWriter类

1. FileWriter类概述

FileWriter类是OutputStreamWriter的子类是Writer类的孙子,所有的方法全都来自于OutputStreamWriter类,方法与父类也是相同的,主要用于数据的写出
FileWriter类是节点流(普通流),是操作文件数据的基本流

2. FileWriter类构造方法

  1. public FileWriter(String fileName):创建对象并指定文件输出的位置
  2. public FileWriter(String fileName, boolean append):创建对象并指定文件输出的位置,以及是否为追加内容
  3. public FileWriter(File file):创建对象并指定文件输出的位置
  4. public FileWriter(File file, boolean append):创建对象并指定文件输出的位置,以及是否为追加内容

3. FileWriter类常用方法

  1. public void write(int c):从Java应用程序写出数据到文件,一次写出一个字符数据
  2. public void write(char cbuf[]):从Java应用程序写出数据到文件,一次写出一个字符数组数据
  3. abstract public void write(char cbuf[], int off, int len):从Java应用程序写出数据到文件,一次写出一个字符数组数据,并指定数据起始位置和数据长度
  4. public void write(String str):从Java应用程序写出数据到文件,一次写出一个字符串数据
  5. public void write(String str, int off, int len):从Java应用程序写出数据到文件,一次写出一个字符串数据,并指定数据起始位置和数据长度
  6. public void flush():强制刷新流数据,将还在数据流中的数据强制写出
  7. public void close():关闭输出流并释放资源

5.2. FileReader类

1. FileReader类概述

FileReader类是InputStreamReader的子类是Reader类的孙子,所有的方法全都来自于InputStreamReader类,方法与父类也是相同的,主要用于数据的写出
FileReader类是节点流(普通流),是操作文件数据的基本流

2. FileReader类构造方法

  1. public FileReader(String fileName):创建对象并指定文件位置
  2. public FileReader(File file):创建对象并指定文件位置

3. FileReader类常用方法

  1. public int read():读取数据到Java应用程序,一次读取一个字符数据
  2. public int read(char cbuf[]):读取数据到Java应用程序,一次读取一个字符数组数据
  3. abstract public int read(char cbuf[], int off, int len):读取数据到Java应用程序,一次读取一个字符数组数据,并指定数据起始位置和数据长度
  4. abstract public void close():关闭输入流对象释放资源
   public static void main(String[] args) {
        //1.定义源文件
        String sourcePath = "text.txt";
        //2.定义目的地
        String targetPath = "src/Demo.txt";
//        copyFile(sourcePath,targetPath);
        //1.定义源文件
        //图片的绝对路径
        sourcePath = "C:\\Users\\huashuo\\Pictures\\Saved Pictures\\8.jpg";
        //2.定义目的地
        //拷贝的相对路径
        targetPath = "src/img/demo2.jpg";
//        copyFile(sourcePath,targetPath);
        //1.定义源文件
        //视频的绝对路径
        sourcePath = "C:\\Users\\huashuo\\Videos\\MgtvVideos\\Myvedio\\FamilyTime.mp4";
        //2.定义目的地
        //拷贝的相对路径
        targetPath = "src/video/demo2.avi";
        copyFile(sourcePath,targetPath);

    }
    /**
     * 拷贝文件步骤
     * // 1. 字符输入流对象
     * // 2. 字符输出流对象
     * // 3. 定义char数组,用于接收读取的数据
     * // 4. 声明Length属性,用于接收读取数据的长度
     * // 5. while循环读取数据
     * // 6. 循环将读取的数据写出到文件
     * // 7. 强制刷新流数据
     * // 8. 释放资源
     * 因为图片和视频是二进制数据传输的，拷贝时用的是字符拷贝，会对源数据造成损毁无法正常展示。
     */
    private static void copyFile(String sourcePath, String targetPath){
        // 使用JDK1.7新特性try...with...resource
        try(
               //1.创建源文件输入流对象
               Reader fr = new FileReader(sourcePath);
               //2.创建目的地输出流对象
               Writer fw = new FileWriter(targetPath)
        ){
            //3.创建一个接收数据的字符数组
            char[] chars = new char[1024];
            //4.创建length变量，声明接收的数据长度
            int length;
            //5.循环遍历数据
            while((length = fr.read(chars)) != -1){
                //6.将每次遍历读取到chars中的数据输出到目的地
                fw.write(chars,0,length);
                //7.强制刷新流数据
                fw.flush();
            }
            //8.释放资源使用JDK1.7新特性try...with...resource自动释放资源
        }catch (IOException e){
            e.printStackTrace();
        }
    }

6.缓冲流

缓冲流属于处理流(包装流),主要作用是用于包装节点流(普通流)对象,可以包装的由字节流和字符流,包装后可以提升读写的效率
缓冲流原理:缓冲流是将读取的数据线存放在内存,当读取的数据存满时再从内存写出到文件或读取到程序
缓冲流分为两类:1. 字节缓冲流,2. 字符缓冲流,提升字节流与字符流的读写效率

6.1. 字节缓冲流

字节缓冲流用于包装字节流对象,提升字节流读写速度
字节缓冲输入流对象BufferedInputStream
字节缓冲输出流对象BufferedOutputStream

1. 字节缓冲输出流对象BufferedOutputStream

1. 字节缓冲输出流对象BufferedOutputStream构造方法
  1. public BufferedOutputStream(OutputStream out):创建对象并指定字节输出流对象
  2. public BufferedOutputStream(OutputStream out, int size):创建对象并指定字节输出流对象,并指定缓冲区大小
2. 字节缓冲输出流对象BufferedOutputStream常用方法
  1. public synchronized void write(byte b[], int off, int len):从Java应用程序写出数据到文件,一次写出一个字节数组数据,并指定数据起始位置和数据长度
  2. public void flush():强制刷新流数据,将还在数据流中的数据强制写出
  3. public void close():关闭输出流并释放资源

2. 字节缓冲输入流对象BufferedInputStream

1. 字节缓冲输入流对象BufferedInputStream构造方法
  1. public BufferedInputStream(InputStream in):创建对象并指定字节输入流对象
  2. public BufferedInputStream(InputStream in, int size):创建对象并指定字节输入流对象,以及缓冲区大小
2. 字节缓冲输入流对象BufferedInputStream常用方法
  1. public int read(byte b[]):读取数据到Java应用程序,一次读取一个字节数组数据
  2. public int available():获取数据的长度
  3. public void close():关闭输入流释放资源
  public static void main(String[] args) {
        // 1. 源文件位置
        String sourcePath = "D:/ideaIUPortable.zip";
        // 2. 目的地位置
        String targetPath = "src/ideaIUPortable.zip";
        // 3. 拷贝文件方法
        copyFile(sourcePath, targetPath);
    }

    /**
     * 缓冲流拷贝流程
     * // 1. 创建字节流对象
     * // 2. 创建缓冲流对象
     * // 3. 定义byte数组,用于接收读取的数据
     * // 4. 声明length属性,用于接收读取数据的长度
     * // 5. while循环读取数据
     * // 6. 循环读取的数据写出到文件
     * // 7. 强制刷新流数据
     * // 8. 释放资源
     */
    private static void copyFile(String sourcePath, String targetPath) {
        // 使用JDK1.7try...with...resource
        try (
                // 1. 创建字节流对象
                InputStream is = new FileInputStream(sourcePath);
                OutputStream os = new FileOutputStream(targetPath);
                // 2. 创建缓冲流对象
                BufferedInputStream bis = new BufferedInputStream(is);
                BufferedOutputStream bos = new BufferedOutputStream(os)
        ) {
            // 3. 定义byte数组,用于接收读取的数据
            byte[] bytes = new byte[1024 * 1024];
            // 4. 声明length属性,用于接收读取数据的长度
            int length;
            // 记录拷贝起始时间
            long start = System.currentTimeMillis();
            // 5. while循环读取数据
            while ((length = bis.read(bytes)) != -1) {
                // 6. 循环读取的数据写出到文件
                bos.write(bytes, 0, length);
                // 7. 强制刷新流数据
                bos.flush();
            }
            // 记录拷贝结束时间
            long end = System.currentTimeMillis();
            // 计算耗时
            System.out.println("拷贝耗时:" + (end - start));
            // 8. 释放资源使用JDK1.7try...with...resource自动释放资源
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

6.2. 字符缓冲流

字符缓冲流用于包装字符流对象,提升字符流读写速度
字符缓冲输入流对象BufferedReader
字符缓冲输出流对象BufferedWriter

1. 字符缓冲输出流对象BufferedWriter

1. 字符缓冲输出流对象BufferedWriter构造方法
  1. public BufferedWriter(Writer out):创建对象并指定字符输出流对象
  2. public BufferedWriter(Writer out, int sz):创建对象并指定字符输出流对象以及缓冲区大小
2. 字符缓冲输出流对象BufferedWriter常用方法
  1. public void write(String str):从Java应用程序写出数据到文件,一次写出一个字符串的数据
  2. public void newLine():新行,输出一个换行符(由于Windows,Linux,macOS系统的换行符不一样所以如果手写换行符则可能会出现在其他系统中失效的问题)
  3. public void flush():强制刷新流数据
  4. public void close():关闭输出流并释放资源

2. 字符缓冲输入流对象BufferedReader

1. 字符缓冲输入流对象BufferedReader构造方法
  1. public BufferedReader(Reader in):创建对象并指定字符输入流对象
  2. public BufferedReader(Reader in, int sz):创建对象并指定字符输入流对象以及缓冲区大小
2. 字符缓冲输入流对象BufferedReader常用方法
  1. public String readLine():读取数据到Java应用程序,一次读取一行数据
  2. public void close():关闭输入流并释放资源
    public static void main(String[] args) {
        // 1. 源文件位置
        String sourcePath = "src/com/powernode/demo12/Demo.java";
        // 2. 目的地位置
        String targetPath = "src/com/powernode/demo12/Demo.txt";
        // 3. 拷贝方法
        copyFile(sourcePath, targetPath);
    }

    /**
     * 拷贝文件方法
     * // 1. 创建字符流对象
     * // 2. 创建缓冲流对象
     * // 3. 定义String变量,接收读取的数据
     * // 4. while循环读取数据
     * // 5. 将读取的数据写出到文件
     * // 6. 强制刷新
     * // 7. 释放资源
     */
    private static void copyFile(String sourcePath, String targetPath) {
        // 使用JDK1.7新特性try...with...resource
        try (
                // 1. 创建字符流对象
                Reader r = new FileReader(sourcePath);
                Writer w = new FileWriter(targetPath);
                // 2. 创建缓冲流对象
                BufferedReader br = new BufferedReader(r);
                BufferedWriter bw = new BufferedWriter(w);
        ) {
            // 3. 定义String变量,接收读取的数据
            String readLine;
            // 4. while循环读取数据
            while ((readLine = br.readLine()) != null) {
                // 5. 将读取的数据写出到文件
                bw.write(readLine);
                // 输出换行符
                bw.newLine();
                // 6. 强制刷新
                bw.flush();
            }
            // 7. 释放资源使用JDK1.7新特性try...with...resource自动释放资源
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
码农小白123
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
IO输入流和输出流
weixin_70647138的博客
12-11 1030
输入：将文件以数据流的形式读取到Java程序中输出：通过Java程序将数据流写到文件中1、 IO是指Input/Output，即输入和输出Input指把数据从外部读到内存（磁盘、网络--->>>内存）Output指把数据从内存读到外部（内存--->>>磁盘文件、网络）2、代码是在内存中运行的，数据必须读进内存才能处理。3、IO流单向顺序读写，它以byte（字节）为最小单位，因此也称字节流。
Java IO输入输出流
12-22
Java程序对数据的操作是通过“流”IO的方式，IO流用来 处理设备之间的输一局传输（上传和下载文件） 2，流 流是一种有顺序有起点和终点的集合（字节），是对数据传输的一种抽象，它就是为了数据传输。 3，流的分类 ...
简单的输入输出流（1）
f_junhao的博客
02-06 497
Java.io 包几乎包含了所有操作输入、输出需要的类。所有这些流类代表了输入源和输出目标。 Java.io 包中的流支持很多种格式，比如：基本类型、对象、本地化字符集等等。 一个流可以理解为一个数据的序列。输入流表示从一个源读取数据，输出流表示向一个目标写数据。 Java 为 I/O 提供了强大的而灵活的支持，使其更广泛地应用到文件传输和网络编程中。**读取控制台输入 Java 的控制台输
IO流的输入和输出
Aia0325的博客
07-23 191
IO流 1.in输入（读取），out输出（写入） 流的分类： 节点流：连接数据源的流 过滤流：对其他流进行了封装 数据：字节流、字符流 2.FileInputStream/FileOutputSteam 节点流-字节流 字节流一般用于传输文件（复制，上传，下载） 3.BufferedReader/BufferedWriter 字符流过滤流 可以直接读取字符（读取一行字符）......
Java IO 标准的输入流和输出流
JomBarry的博客
08-24 229
Java io 标准的输入流和输出流 列出的为较为常用的相关知识，因为我也是一名小白，所以希望能够通过博客来督促自> 己学习，若有错误请联系我！！！希望能够一起共同进步，共同成长！ java io 标准的输入和输出 使用java IO 我们可以对外界设备已相同的方式进行读写完成数据交换。 java IO将“读”与“写”按照方向进行了划分： 输入：从外界到程序的方向，用于让程序获取外...
IO流中 ----输入流和输出流总结
m0_59880694的博客
08-03 240
IO常用流
java中的io的输入输出理解和记忆
Handsome2013的博客
07-02 462
1.java中的io的输入输出理解和记忆 最基本的包括了输入和输出 InputStream（字节输入流） Reader(字符输入流，读入：就像我们人默读就是将东西输入到我们脑袋） OutputStream（字节输出流） Writer（字符输出流，写出：我们把字写到黑板就是写出给别人看的） （注意：下边主要使用数组容器来作为内存，本地文件作为输出端，还可以使用其他东西作为输入...
IO流、输入、输出流
H215919719的博客
08-20 1631
IO流、输入、输出流
IO流输入输出流入门详解
m0_62929907的博客
06-12 3488
io
Java IO流学习总结一：输入输出流
热门推荐
赵彦军
01-09 6万+
Java IO流学习总结一：输入输出流 转载请标明出处：http://blog.csdn.net/zhaoyanjun6/article/details/53761199 本文出自【赵彦军的博客】 Java流类图结构：流的概念和作用流是一组有顺序的，有起点和终点的字节集合，是对数据传输的总称或抽象。即数据在两设备间的传输称为流，流的本质是数据传输，根据数据传输特性将流抽象为各种类，方便更直
IO输入输出流
07-01
IO输入输出流，java的IO使用开发，简单易学。
IO流--输入输出
03-16
想了解IO输入输出流的学者可以看看，里面有详细的讲解及源代码。
IO输入输出体系.rar
07-26
io流简介 File类 createNewFile() File.pathSwparator 与系统有关的路径分隔符，它被表示为一个字符串 windows为 分号";" File.pathSwparatorChar 与系统有关的路径分割符，它被表示为一个字符 File.separator 与...
C# IO输入输出流
04-26
流Stream，FileStream、BinaryReader与TextReade等类 File类、FileInfo、Directory 和DirectoryInfo等类 XmlReader、XmlWriter和XmlDocument类处理XML数据 使用和管理应用程序配置文件信息
operator ＜=＞ (spaceship operator)
janeqi1987的专栏
05-28 988
= 与!= 操作符为了检查是否相等，现在定义== 操作符就够了。当编译器找不到表达式的匹配声明a!=b 时，编译器会重写表达式并查找!(a==b)。若这不起作用，编译器也会尝试改变操作数的顺序，所以也会尝试!(b==a):a!=b,!(b==a)因此，对于TypeA 的a 和TypeB 的b，编译器将能够识别并编译a!= b若需要的话，可以这样做• 一个独立函数operator!• 一个独立函数operator==(TypeA, TypeB)
Java 异常处理中try-catch块、finally子句以及自定义异常的使用
最新发布
Itmastergo的博客
05-31 785
异常是程序运行过程中出现的非正常情况。Java 使用异常类（Exception 类及其子类）来表示这些异常情况。异常处理的核心思想是将正常的程序流程与异常处理流程分离开来，使代码更加清晰和可维护。Throwable 类：所有异常和错误的基类。Error 类：表示系统级的错误，程序通常无法处理，比如内存不足（OutOfMemoryError）。Exception 类：表示程序中可以处理的异常情况。RuntimeException 类。
Java手动启动jar包
liangweihao的博客
05-29 286
【代码】Java手动启动jar包。
java调用cmd执行命令
weixin_45210565的博客
05-28 252
3、exec(String command, String[] envp) ，在调用外部程序之前设置系统环境变量，该变量仅供command入参使用，envp每个元素为一个系统环境变量，并且字符串格式为“环境变量名=环境变量值”。2、exec(String[] cmdArray) ，调用外部程序，入参cmdArray的元素将组合成为一条完整的外部可执行程序的启动路径或命令。1、exec(String command) ，调用外部程序，入参command为外部可执行程序的启动路径或命令。
java多线程创建方式
weixin_57763462的博客
05-28 1072
这种方式是通过创建一个实现了Runnable接口的类，并实现run()方法来创建线程。然后将这个类的对象作为参数传递给Thread类的构造器，并调用Thread对象的start()方法来启动线程。这种方式是通过创建一个实现了Callable接口的类，实现call()方法，并使用FutureTask或者ExecutorService来创建线程。这种方式的优点在于，由于Java不支持多重继承，如果你的类需要继承其他类，那么实现Runnable接口将是唯一的选择。// 在这里定义线程的执行逻辑。
c++io流文件输入输出
01-06
C++的IO流提供了丰富的功能来进行文件的输入和输出操作。下面是C++中文件输入输出的示例： 1. 文件输入流（ifstream）： ```cpp #include #include using namespace std; int main() { ifstream inputFile; ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值