广告
返回顶部
首页 > 资讯 > 后端开发 > Python >java中的IO流
  • 263
分享到

java中的IO流

java中的IO流javaIO流 2022-11-12 11:11:16 263人浏览 独家记忆

Python 官方文档:入门教程 => 点击学习

摘要

目录java中的io流1.普通字节流2.字节缓冲流3.转换流4.常用的IO类FileReader和BufferedReader5.总结java中的IO流 前言: 在java中IO类

java中的IO流

前言:

在java中IO类很庞大,初学的时候觉得傻傻分不清楚。其实java流归根结底的原理是普通字节流,字节缓冲流,转换流。最基础的是普通字节流,即从硬盘读取字节写入到内存中,但在实际使用中又发现一些特殊的需求,所以java语言的设计者这引入了字节缓冲流和转换流。所有的java IO类对IO的处理都是基于这三种流中的一种或多种;在介绍完三种流的概念之后,会对IO流的部分java类做介绍。

1.普通字节流

以FileInputStream为例子。FileInputStream的硬盘读取方式分为两种,一次读取一个字节和一次读取一个字节数组。字节数组的大小不同,实际IO耗时也不同,1为示例代码,3展示了1代码中读写耗时随字节数组大小的变化趋势。随着字节数组的增大,读写耗时减小,主要是硬盘寻道时间(seek time)和旋转时间(rotational latency)的减少。在硬盘读写耗时很长时,内存读写的耗时相比硬盘读写可以忽略,硬盘读写的耗时分为寻道时间(seek time)、旋转时间(rotational latency)和传输时间(transfer time),传输时间相对于寻道时间和旋转时间(寻道时间和旋转时间后合并称为寻址时间)可以忽略【1】。硬盘的寻址时间在一个块中的第一个字节耗时长,一个块中的其余字节可以忽略。当字节数组增大时(从32增加到1024*16 byte),寻址一个块中的第一个字节的场景线性减少,寻址时间也线性减少,因此IO耗时呈线性减少趋势。当字节数组大小继续增大(从1024 * 8增加到1024 * 1024 * 16),此时寻址时间已降到很低,相比传输时间可以忽略时,IO耗时的变化趋于平稳。当字节数组大小继续增大时,读写耗时又出现增大的趋势,这个我还没找到原因。当在数组较大(大于1024 *1024 *4)时,read(byte[])方法中除去读写之外也会有其它耗时,测试代码如2,测试数据如图3附表,这个机制我还不清楚(可能需要深入了解JVM的底层实现了),3中在计算读写耗时时应减去这部分时间。

示例代码


public class Demo01_Copy {

 public static void main(String[] args) throws IOException {
  File src = new File ("e:\\foxit_Offline_FoxitInst.exe");
  File dest = new File("e:\\ithema\\foxit_Offline_FoxitInst.exe");

  byte[] bytes = new byte[1024*128];//调整字节数组的大小,看IO耗时的变化
  long time1 = System.currentTimeMillis();
  copyFile2(src,dest,bytes);
  long time2 = System.currentTimeMillis();
  System.out.println(time2 -time1);
 }
 
 public static void copyFile2(File src,File dest,byte[] bytes) throws IOException{
  InputStream in = new FileInputStream(src);
  OutputStream os = new FileOutputStream(dest);
  
  int len = 0;
  while((len = in.read(bytes))!=-1){
   os.write(bytes,0,len);
  }
  in.close();
  os.close();
 }
}

 1.通过FileInputStream一次读取一个字节数组


public class Demo02_Copy {
    public static void main(String[] args) throws IOException {
        File src = new File ("e:\\1.txt");
        File dest = new File("e:\\ithema\\1.txt");

        byte[] bytes = new byte[1024*128];//调整字节数组的大小,看IO耗时的变化
        long time1 = System.currentTimeMillis();
        copyFile2(src,dest,bytes);
        long time2 = System.currentTimeMillis();
        System.out.println(time2 -time1);
    }

    public static void copyFile2(File src,File dest,byte[] bytes) throws IOException{
        InputStream in = new FileInputStream(src);
        OutputStream os = new FileOutputStream(dest);

        int len = 0;
        while((len = in.read(bytes))!=-1){
            os.write(bytes,0,len);
        }
        in.close();
        os.close();
    }
}

2.测试除硬盘内存读写外的其它耗时(1.txt文件为空)

 3.当字节数组大小变化,读写总耗时的变化趋势(折线图数据来源于表格中蓝色背景填充的数据)

当数组大小从32逐渐增大到1024*16byte时,IO耗时呈线性减少,这基于FileInputStream的read(byte[])实现。read(byte[])的源码如4所示,read(byte b[])是一个本地方法,它保证了硬盘的寻址时间在读取一个数组大小的字节块的第一个字节耗时较长,字节块的其余字节可以忽略。而相对于read()方法,一个字节一个字节读取,每读取一个字节都要重新进行硬盘寻址。


public class FileInputStream extends InputStream
{
    public int read(byte b[]) throws IOException {
        return readBytes(b, 0, b.length);
    }
    
     
    private native int readBytes(byte b[], int off, int len) throws IOException;
}

4.FileInputStream 的 read(byte[]) 方法源码

2.字节缓冲流

假设现在你要写一个程序以计算一个text文件的行数。一种方法是使用read()方法从硬盘中一次读取1个字节到内存中,并检查该字节是不是换行符“\n”【2】。这种方法已被证明是低效的。

更好的方法是使用字节缓冲流,先将字节从硬盘一次读取一个缓冲区大小的字节到内存中的读缓冲区,然后在从读缓冲区中一次读取一个字节。在逐字节读取读取缓冲区时,检查字节是不是换行符'\n'。字节缓冲流BufferedInputStream的源码如5所示,先从硬盘读取一个缓冲大小的字节块到缓冲区,然后逐个读取缓冲区的字节;当缓冲区的字节读取完毕后,在调用fill()方法填充缓冲区。字节缓冲流BufferedInputStream的缓冲区大小为8192。6中对比了字节缓冲流和普通字节流的读写效率;字节缓冲流的读耗时仅为8ms,而没有缓冲区的普通字节流的耗时为567ms。图7中展示了6中字节缓冲流读写文件的示意图。


public class BufferedInputStream extends FilterInputStream {
    private static int DEFAULT_BUFFER_SIZE = 8192;
    
 public synchronized int read() throws IOException {
        //当缓冲区的字节已被读取完毕后,调用fill()方法从硬盘读取字节块填充缓冲区;
        if (pos >= count) {
            fill();
            if (pos >= count)
                return -1;
        }
        //返回缓冲区的一个字节
        return getBufIfOpen()[pos++] & 0xff;
    }

 private void fill() throws IOException {
        byte[] buffer = getBufIfOpen();
        //初始定义int markpos = -1;
        if (markpos < 0)
            pos = 0;            
        else if (pos >= buffer.length)  
            if (markpos > 0) {  
                int sz = pos - markpos;
                System.arraycopy(buffer, markpos, buffer, 0, sz);
                pos = sz;
                markpos = 0;
            } else if (buffer.length >= marklimit) {
                markpos = -1;   
                pos = 0;        
            } else if (buffer.length >= MAX_BUFFER_SIZE) {
                throw new OutOfMemoryError("Required array size too large");
            } else {            
                int nsz = (pos <= MAX_BUFFER_SIZE - pos) ?
                        pos * 2 : MAX_BUFFER_SIZE;
                if (nsz > marklimit)
                    nsz = marklimit;
                byte nbuf[] = new byte[nsz];
                System.arraycopy(buffer, 0, nbuf, 0, pos);
                if (!bufUpdater.compareAndSet(this, buffer, nbuf)) {
                    // Can't replace buf if there was an async close.
                    // Note: This would need to be changed if fill()
                    // is ever made accessible to multiple threads.
                    // But for now, the only way CAS can fail is via close.
                    // assert buf == null;
                    throw new IOException("Stream closed");
                }
                buffer = nbuf;
            }
        count = pos;
        //从硬盘读取一个缓冲区大小的块到缓冲区
        int n = getInIfOpen().read(buffer, pos, buffer.length - pos);
        if (n > 0)
            count = n + pos;
    }
}

 5.BufferedInputStream的read()方法源码


public class Demo03_Copy {

 public static void main(String[] args) throws IOException {
  File src = new File ("e:\\settings.xml");
  File dest = new File("e:\\ithema\\settings.xml");

  byte[] bytes = new byte[1024*128];
  long time1 = System.currentTimeMillis();
  //耗时:567 ms
        //copyFile1(src,dest);
  //耗时:8 ms
  copyFile3(src,dest);
  long time2 = System.currentTimeMillis();
  System.out.println(time2 -time1);
 }

    //使用普通字节流
 public static void copyFile1(File src,File dest) throws IOException{
  InputStream in = new FileInputStream(src);
  OutputStream os = new FileOutputStream(dest);
  int len = 0;
  int lineSum = 1;
  while((len = in.read())!= -1){
   if(len == '\n'){
    lineSum++;
   }
   os.write(len);
  }
  System.out.println("lineSum:"+lineSum);
  in.close();
  os.close();
 }
 
    //使用字节缓冲流
 public static void copyFile3(File src,File dest) throws IOException{
  
  InputStream in = new BufferedInputStream(new FileInputStream(src));
  OutputStream os = new BufferedOutputStream(new FileOutputStream(dest));
  
  int len = 0;
  int lineSum = 1;
  while((len = in.read())!=-1){
   if(len == '\n'){
    lineSum ++;
   }
   os.write(len);
  }
  System.out.println("lineSum:"+lineSum);
  in.close();
  os.close();
 }
}

6.字节缓冲流和普通字节流的读写效率对比

 

 7.使用字节缓冲流在图6中读写文件的示意图

3.转换流

转换流实现了在指定的编码方式下进行字节编码和字符编码的转换。转换流如果直接从硬盘一次一个字节读取的转换流效率也很低,所以转换流一般都是基于字节缓冲流的。转换流InputStreamReader的使用如8所示,图中代码底层的执行流程图如9所示。InputStreamReader 的源码解析图如10所示,转码的关键代码如11所示。如11,一个字符的字符编码所占字节个数固定为2个字节,但一个字符的字符编码经过转换流按UTF-8格式转换为字节编码后,字节编码所占字节个数为1~4个。


public class Demo01_InputStreamReader {
 public static void main(String[] args) throws IOException {
  readUTF();
 }
    
    //一次读取一个字符
 public static void readUTF() throws IOException{
  InputStreamReader isr = new InputStreamReader(new FileInputStream("e:\\2.txt"),"UTF-8");
  int ch = 0;
  while((ch = isr.read())!=-1){
   System.out.println((char)ch);
  }
  isr.close();
 }
}

8. 使用转换流InputStreamReader一次读取一个字符

 

9 .InputStreamReader在read()时的底层流程图(文件中的字节编码可通过FileInputStream读取查看)

 

10 .InputStreamReader的read()源码解析图


class UTF_8 extends Unicode{
    private CoderResult decodeArrayLoop(ByteBuffer paramByteBuffer, CharBuffer paramCharBuffer)
    {
      byte[] arrayOfByte = paramByteBuffer.array();
      int i = paramByteBuffer.arrayOffset() + paramByteBuffer.position();
      int j = paramByteBuffer.arrayOffset() + paramByteBuffer.limit();
      char[] arrayOfChar = paramCharBuffer.array();
      int k = paramCharBuffer.arrayOffset() + paramCharBuffer.position();
      int m = paramCharBuffer.arrayOffset() + paramCharBuffer.limit();
      int n = k + Math.min(j - i, m - k);
      while ((k < n) && (arrayOfByte[i] >= 0))
        arrayOfChar[(k++)] = (char)arrayOfByte[(i++)];
      while (i < j)
      {
        int i1 = arrayOfByte[i];
        if (i1 >= 0)
        {
          if (k >= m)
            return xflow(paramByteBuffer, i, j, paramCharBuffer, k, 1);
          arrayOfChar[(k++)] = (char)i1;
          i++;
        }
        else
        {
          int i2;
          if ((i1 >> 5 == -2) && ((i1 & 0x1E) != 0))
          {
            if ((j - i < 2) || (k >= m))
              return xflow(paramByteBuffer, i, j, paramCharBuffer, k, 2);
            i2 = arrayOfByte[(i + 1)];
            if (isNotContinuation(i2))
              return malfORMedForLength(paramByteBuffer, i, paramCharBuffer, k, 1);
            arrayOfChar[(k++)] = (char)(i1 << 6 ^ i2 ^ 0xF80);
            i += 2;
          }
          else
          {
            int i3;
            int i4;
            if (i1 >> 4 == -2)
            {
              i2 = j - i;
              if ((i2 < 3) || (k >= m))
              {
                if ((i2 > 1) && (isMalformed3_2(i1, arrayOfByte[(i + 1)])))
                  return malformedForLength(paramByteBuffer, i, paramCharBuffer, k, 1);
                return xflow(paramByteBuffer, i, j, paramCharBuffer, k, 3);
              }
              i3 = arrayOfByte[(i + 1)];
              i4 = arrayOfByte[(i + 2)];
              if (isMalformed3(i1, i3, i4))
                return malformed(paramByteBuffer, i, paramCharBuffer, k, 3);
              char c = (char)(i1 << 12 ^ i3 << 6 ^ (i4 ^ 0xFFFE1F80));
              if (Character.isSurrogate(c))
                return malformedForLength(paramByteBuffer, i, paramCharBuffer, k, 3);
              arrayOfChar[(k++)] = c;
              i += 3;
            }
            else if (i1 >> 3 == -2)
            {
              i2 = j - i;
              if ((i2 < 4) || (m - k < 2))
              {
                i1 &= 255;
                if ((i1 > 244) || ((i2 > 1) && (isMalformed4_2(i1, arrayOfByte[(i + 1)] & 0xFF))))
                  return malformedForLength(paramByteBuffer, i, paramCharBuffer, k, 1);
                if ((i2 > 2) && (isMalformed4_3(arrayOfByte[(i + 2)])))
                  return malformedForLength(paramByteBuffer, i, paramCharBuffer, k, 2);
                return xflow(paramByteBuffer, i, j, paramCharBuffer, k, 4);
              }
              i3 = arrayOfByte[(i + 1)];
              i4 = arrayOfByte[(i + 2)];
              int i5 = arrayOfByte[(i + 3)];
              int i6 = i1 << 18 ^ i3 << 12 ^ i4 << 6 ^ (i5 ^ 0x381F80);
              if ((isMalformed4(i3, i4, i5)) || (!Character.isSupplementaryCodePoint(i6)))
                return malformed(paramByteBuffer, i, paramCharBuffer, k, 4);
              arrayOfChar[(k++)] = Character.highSurrogate(i6);
              arrayOfChar[(k++)] = Character.lowSurrogate(i6);
              i += 4;
            }
            else
            {
              return malformed(paramByteBuffer, i, paramCharBuffer, k, 1);
            }
          }
        }
      }
      return xflow(paramByteBuffer, i, j, paramCharBuffer, k, 0);
    }
}

11 .UTF_8中将字节编码解码为字符编码的方法decodeArrayLoop()

4.常用的IO类FileReader和BufferedReader

FileReader(String fileName)和InputStreamReader(new FileInputStream(String fileName))是等价的,如12所示,具体实现参见第3节。BufferedReader的实现与FileReader不同,它们的性能对比如13所示。14展示了BufferedReader的使用,这为了和7中InputStreamReader(new FileInputStream(String fileName))的使用做对比。14中代码底层的执行流程图如15所示。BufferedReader的方法read()的源码解析如16所示。BufferedReader和FileReader在字符编码和字节编码的转换时都调用了CharsetDecoder.decode()方法;不同的是BufferedReader一次转换了8192个字符(15),而FileReader一次只转换了2个字符(9)。但由于BufferedReader和FileReader的字节缓冲区大小于均为8192个字节,因此BufferedReader与FileReader效率相差不大。


public class FileReader extends InputStreamReader {
    public FileReader(String fileName) throws FileNotFoundException {
        super(new FileInputStream(fileName));
    }
}

12.FileReader(String filePath)的构造方法


public class Demo01_Copy {

 public static void main(String[] args) throws IOException {
  File src = new File ("e:\\foxit_Offline_FoxitInst.exe");
  File dest = new File("e:\\ithema\\foxit_Offline_FoxitInst.exe");

  long time1 = System.currentTimeMillis();
        //耗时:3801 ms
  //copyFile5(src,dest,bytes);
  //耗时:2938 ms
  copyFile6(src,dest);
  long time2 = System.currentTimeMillis();
  System.out.println(time2 -time1);
 }


 public static void copyFile5(File src ,File dest) throws IOException {
  FileReader fr = new FileReader(src);
  FileWriter fw = new FileWriter(dest);
  int len = 0;
  while((len=fr.read())!=-1){
   fw.write(len);
  }
  fr.close();
  fw.close();
 }

 public static void copyFile6(File src,File dest) throws IOException{
  BufferedReader br = new BufferedReader(new FileReader(src));
  BufferedWriter bw = new BufferedWriter(new FileWriter(dest));
  int len = 0;
  while((len=br.read())!=-1){
   bw.write(len);
  }
  br.close();
  bw.close();
 }
}

13.FileReader和BufferedReader的性能对比


public class Demo01_BufferedReader {
 public static void main(String[] args) throws IOException {
  readUTF();
 }
    
    //一次读取一个字符
 public static void readUTF() throws IOException{
  BufferedReader br = new BufferedReader(
            new InputStreamReader(new FileInputStream("e:\\2.txt"),"UTF-8"));
  int ch = 0;
  while((ch = br.read())!=-1){
   System.out.println((char)ch);
  }
  br.close();
 }
}

14.使用BufferedReader一次读取一个字符(与图7做对比)

 

15.BufferedReader在read()时的底层流程图(与图8做对比)

 

16.BufferedReader的read()源码解析图(与图9做对比)

5.总结

普通字节流是基础,是最简单高效的流。如果没有特殊的需求,只是高效的进行文件读写,选择合适的字节数组大小,一次从硬盘读取一个字节数组大小的字节块,其效率是最高的。

字节缓冲流是为行数统计,按行读取等特殊需求而设计的。相比于直接从硬盘一次读取一个字节;先从硬盘一次读取一个缓冲区大小的字节块到缓冲区(位于内存),再从缓冲区一个字节一个字节的读取并判断是不是行末尾('\n')的效率更高。

转换流实现了在指定的编码方式下进行字节编码和字符编码的转换。转换流如果直接从硬盘一次一个字节读取的转换流效率也很低,所以转换流一般都是基于字节缓冲流的。

以上就是java中的IO流的详细内容,更多关于java中的IO流的资料请关注编程网其它相关文章!,希望大家以后多多支持编程网!

--结束END--

本文标题: java中的IO流

本文链接: https://www.lsjlt.com/news/134028.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com    QQ/279061341

本篇文章演示代码以及资料文档资料下载

下载Word文档到电脑,方便收藏和打印~

下载Word文档
猜你喜欢
  • java中的IO流
    目录java中的IO流1.普通字节流2.字节缓冲流3.转换流4.常用的IO类FileReader和BufferedReader5.总结java中的IO流 前言: 在java中IO类...
    99+
    2022-11-12
    java中的IO流 java IO流
  • java IO流
    目录 序 一、IO流开篇 1、概念 2、流的分类 3、IO流的作用 4、IO流的使用场景 二、字节流 1、字节流抽象基类 2、字节流写数据 (1)基本步骤 (2)三种方式 (3)两个问题 (4)异常处理 3、字节缓冲流 (1)基本分类&概述...
    99+
    2023-09-04
    java 后端 沉默是今晚的康桥...
  • Java中IO流概述
    目录1.InputStream 和 OutputStream 继承结构图:2.Reader 和 Writer 继承结构图:3. 内容4.面试题1.字节流和字符流的区别?2.什么是 I...
    99+
    2022-11-13
    JAVA中的IO流概述 Java中IO流
  • java中的IO流如何分类
    一、IO:上传下载,写入写出 流: 一连串流动的数据,以先入先出的方式进行流动,管道,以程序为中心、程序与网络|文件|服务器|数组..(相关课程推荐:java视频教程)分类1)按照流向: 输入流;输出流2)操作单元分: 字节流 (万能流...
    99+
    2016-05-18
    java入门 java IO 分类
  • Java中IO流的示例分析
    这篇文章主要为大家展示了“Java中IO流的示例分析”,内容简而易懂,条理清晰,希望能够帮助大家解决疑惑,下面让小编带领大家一起研究并学习一下“Java中IO流的示例分析”这篇文章吧。I/O简介I/O是Input/output的缩写,在ja...
    99+
    2023-06-20
  • Java中IO流的详细介绍
    这篇文章主要介绍“Java中IO流的详细介绍”,在日常操作中,相信很多人在Java中IO流的详细介绍问题上存在疑惑,小编查阅了各式资料,整理出简单好用的操作方法,希望对大家解答”Java中IO流的详细介绍”的疑惑有所帮助!接下来,请跟着小编...
    99+
    2023-06-20
  • 深入浅析Java中IO流的字节流
    这期内容当中小编将会给大家带来有关深入浅析Java中IO流的字节流,文章内容丰富且以专业的角度为大家分析和叙述,阅读完这篇文章希望大家可以有所收获。Java中IO流 字节流实例详解IO流(输入流、输出流),又分为字节流、字符流。  流是磁盘...
    99+
    2023-05-31
    java io流 字节流
  • 深入浅析Java 中的IO流字符流
    这期内容当中小编将会给大家带来有关深入浅析Java 中的IO流字符流,文章内容丰富且以专业的角度为大家分析和叙述,阅读完这篇文章希望大家可以有所收获。Java—IO流 字符流  java的文本(char)是16位无符号整数,是字符的unic...
    99+
    2023-05-31
    java io流 字符流
  • Java-IO流实验
    目录前言一、资源管理器[1]. 题目[2]. 实例[3]. 代码二、文件复制与剪切[1]. 题目[2]. 复制[3]. 剪切[4]. 代码三、文件数据读写[1]. 题目[2]. 实例...
    99+
    2022-11-12
    Java流 IO流 java实验
  • Java io流 详解
    文章目录 前言一、IO流的分类二、流的原理及流的数量三、Java IO流对象1. 输入字节流InputStream2. 输出字节流OutputStream 前言 "IO流"(Inpu...
    99+
    2023-09-17
    java 开发语言
  • JAVA—IO流详解
    1. 流概述 1.1. 什么是IO IO:Input/Output即输入&输出,也称之为流(河流,水流),指的是数据从一个地点到另一个地点过程;对于计算机来说文件的拷贝过程,文件的编写保存,显示功能都是使用到IO;将数据的传输过程看做一个输...
    99+
    2023-08-16
    java jvm 网络
  • Java IO流是什么
    这篇文章主要讲解了“Java IO流是什么”,文中的讲解内容简单清晰,易于学习与理解,下面请大家跟着小编的思路慢慢深入,一起来研究和学习“Java IO流是什么”吧!IO概述在这一小节,我会试着给出Java IO(java.io)包下所有类...
    99+
    2023-06-02
  • Java-IO流的示例分析
    小编给大家分享一下Java-IO流的示例分析,相信大部分人都还不怎么了解,因此分享这篇文章给大家参考一下,希望大家阅读完这篇文章后大有收获,下面让我们一起去了解一下吧!前言项目结构如下,在使用代码的时候注意修改成你自己的包名和类名一、资源管...
    99+
    2023-06-20
  • 一文带你读懂Java中的IO流
    一文带你读懂Java中的IO流?针对这个问题,这篇文章详细介绍了相对应的分析和解答,希望可以帮助更多想解决这个问题的小伙伴找到更简单易行的方法。1、IO解决问题解决设备与设备之间的数据传输问题,比如 硬盘—->内存 内存—–>硬...
    99+
    2023-05-31
    java io流 ava
  • 深入浅析Java中IO流的 RandomAccessFile类
    这篇文章将为大家详细讲解有关深入浅析Java中IO流的 RandomAccessFile类,文章内容质量较高,因此小编分享给大家做个参考,希望大家阅读完这篇文章后对相关知识有一定的了解。RandomAccessFilejava提供的对文件内...
    99+
    2023-05-31
    java randomaccessfile io流
  • Java IO中包装流的示例分析
    这篇文章主要介绍了Java IO中包装流的示例分析,具有一定借鉴价值,感兴趣的朋友可以参考下,希望大家阅读完这篇文章之后大有收获,下面让小编带着大家一起了解一下。根据功能分为节点流和包装流(处理流)节点流:可以从或向一个特定的地方...
    99+
    2023-06-26
  • IO流在Java中的作用有哪些
    IO流在Java中的作用有哪些?很多新手对此不是很清楚,为了帮助大家解决这个难题,下面小编将为大家详细讲解,有这方面需求的人可以来学习下,希望你能有所收获。Java io简介Java io系统的设计初衷,就是为了实现“文件、控制台、网络设备...
    99+
    2023-05-31
    java io流
  • 关于Java中的IO流总结(推荐)
    流的继承关系,以及字节流和字符流。 节点流FileOutputStream和FileInputStream和处理流BufferedInputStream和BufferedOutputStream。以及对应的FileOutputWriter...
    99+
    2023-05-31
    java io流 ava
  • 如何快速了解Java中的IO流
    这篇文章主要介绍“如何快速了解Java中的IO流”,在日常操作中,相信很多人在如何快速了解Java中的IO流问题上存在疑惑,小编查阅了各式资料,整理出简单好用的操作方法,希望对大家解答”如何快速了解Java中的IO流”的疑惑有所帮助!接下来...
    99+
    2023-06-16
  • Java IO流深入理解
    目录阻塞(Block)和非阻塞(Non-Block)同步(Synchronization)和异步(Asynchronous)BIO与NIO对比面向流与面向缓冲阻塞与非阻塞选择器的问世...
    99+
    2022-11-12
    JavaIO流 Java深入理解
软考高级职称资格查询
编程网,编程工程师的家园,是目前国内优秀的开源技术社区之一,形成了由开源软件库、代码分享、资讯、协作翻译、讨论区和博客等几大频道内容,为IT开发者提供了一个发现、使用、并交流开源技术的平台。
  • 官方手机版

  • 微信公众号

  • 商务合作