精华内容
下载资源
问答
  • 缓冲流比缓冲数组的优势在哪里呢,大家帮解决一下,非常感谢了。
  • 这要搞清楚缓冲区的原理了,缓冲区其实就是封装了一...打个比方,默认缓冲区大小是8k,如果你是用缓冲区操作10k的数据,你使用了flush方法那么数据不会丢失,但是如果没有使用fulsh方法那么得到得数据只有8k,剩下...

    这要搞清楚缓冲区的原理了,缓冲区其实就是封装了一个数组,对数据进行临时缓冲,存满后再集中对数据进行操作,这也是提高流操作数据效率的原因,当缓冲区存满后会自动对数据进行操作,不刷新也可以,但是如果不存满就必须刷新了才能把数据刷到目的地,打个比方,默认缓冲区大小是8k,如果你是用缓冲区操作10k的数据,你使用了flush方法那么数据不会有丢失,但是如果没有使用fulsh方法那么得到得数据只有8k,剩下的2k会丢失,还有不明白的欢迎留言,一家之言各位有什么高见欢迎多多指教

    =================================================================================================

    因为有一些IO流用的是缓冲方式:它有个缓冲区,一般得等到缓冲区满才写入文件。动态调用flush则不管缓冲区满不满,立即写到文件。
    如果最后缓冲区没满而关闭流,则会导致数据丢失

    展开全文
  • 初级解法:一个字符数组来存放“-”,循环控制打印出来,再usleep函数减缓程序执行速度,以便于我们看清打印过程。 看执行结果,“-”确实每次都在增加,只不过打印时不应该换行。去掉换行之后 运行结果...

    题目:编译一个进度条程序,最终实现“—”逐渐增加
    初级解法:用一个字符数组来存放“-”,用循环控制打印出来,再用usleep函数减缓程序执行速度,以便于我们看清打印过程。
    在这里插入图片描述
    在这里插入图片描述
    看执行结果,“-”确实有每次都在增加,只不过打印时不应该换行。去掉换行之后
    在这里插入图片描述
    运行结果显示:一下子“-”都打印出来了,而且“-”打印出来不是最终的10个,而是把每个num【i】都打印了出来,可是代码也是正确的。明明应该是循环一次从头打印一次,最终出来是一点点增多的十个“-”,一下子都出来是为什么呢?

    首先printf功能是向终端显示打印数据的–
    Linux下一切皆文件,当printf被当做文件操作时,将数据写入显示器设备文件,数据就会被显示在显示屏上。
    显示器文件在编程中被称为标准输出设备

    缓冲区

    这是Linux的一个优化,我们输出一个数据就要操作一次输出设备硬件,而硬件效率一般都很低,所以就在内存中划出一个缓冲区,用来存放要输出的数据,等到条件满足再一次性输出出来,大大提升了I/O效率。每个文件都有自己的缓冲区。
    在这里插入图片描述

    所以这就能解释刚才的问题,是因为“-”一直在缓冲区中堆积等到程序结束时才一下子写入标准输出文件。

    改良:手动刷新缓冲区,并且加上\r回车符
    回车\r 和 换行\n 是不一样的
    回车是回到光标起始位置,换行是光标移动到下一行
    在这里插入图片描述
    在这里插入图片描述
    这样就完成啦!

    展开全文
  • 编辑器之间隙缓冲

    2008-06-30 12:28:00
    编辑器之间隙缓冲区 ...以下对一些缓冲区做一下对比以说明为什么间隙缓冲区作为编辑器的解决方案。 1.字符数组缓冲区 如果使用普通的字符数组(char[])来作为缓冲区的话,很明显的会面临一个问题:当在数...

    编辑器之间隙缓冲区

          近一年多都在开发一个带有词法和语法分析的编辑器,其中在文本编辑缓冲区管理中,看了挺多有益的资料和文档,故拿出来总结并与大家分享一下。
          以下对一些缓冲区做一下对比以说明为什么要用间隙缓冲区作为编辑器的解决方案。
          1.字符数组缓冲区
          如果使用普通的字符数组(char[])来作为缓冲区的话,很明显的会面临一个问题:当在数组中插入或删除一个字符时,会导致数组的后半部分的移动,一个极端的例子是在数组的开头插入一个字符将导致后面的Length-1的字符逐一向后移动一个位置。很明显地,这将导致严重的性能问题。
      2.字符串缓冲区
          也许我们可以没有必要照顾字符数组是如何移动的,因为String类 已经为我们做了很多工作,但了解String后会发现,其实String具有不变性,表面上的变化实质是通过创建新字符串来实现的,频繁的创建新对象将使用不少的资源。
          3.链表缓冲区
          链表的插入和删除操作代价是很小的,所以也许可以将缓冲区中的字符作为链表的节点来构造一个链表缓冲区,但如果编辑的文本较多时,即链表较长时,迭代到链表的指定位置处所花的时间将是难于忍受的,也就是说它不能像数组那样快速地索引。
          4.间隙缓冲区
          这是一种较好的方式。
          间隙缓冲区其实也是一个数组,但我们会想办法来尽量避免频繁的字符移动。我们在插入符号(要插入或删除字符的位置)的左侧增加一个“间隙”。
          假设编辑器中的文本为“Gap text  buffer”,并且插入符号(当前编辑位置)在字符串“text”后面,那么它在缓冲区中的布局是这样的:“Gap text |||| buffer”,其中的“||||”就是我们插入的“间隙”。当我们要在当前编辑位置片新插入一个字符‘x’(“text ”后面),那么编辑器中的文本变成“Gap text x buffer”,而缓冲区中的布局变成:
    “Gap text x||| buffer”其实我们可以发现此次插入操作并没有字符的移动(这是普通字符数组所不能达到的),没有新字符串的创建(这是String所不能达到的),而它仅仅是将该字符数组中的“间隙”的第一个‘|’替换成‘x’,即仅仅是“间隙”变短了。
          同样的道理,我们发现想删除‘x’这个字符,只需要执行上述过程的逆过程,将该字符数组中的“间隙”变长,将字符‘x’替换成‘|’就可以了。可以发现在间隙缓冲区中,大多数的插入和删除操作仅仅导致了“间隙”的伸长或缩短,而缓冲区中的其他位置却是不发生任何变化的。
          只有当插入的字符过多,导致“间隙”长度接近0时,我们才有必要重新分配空间以便将“间隙”回复到一个合理长度。比如我们可以将“间隙”默认长度设置为256,当插入了255个字符后,发现“间隙”很快将被用尽了,这时我们才重新分配空间来将“间隙”恢复至256,而这中分配次数相对与插入次数是微不足道的。同样只有当删除的字符过多,导致“间隙”过大的时候,我们才有必要“缩紧”数组以求占用更少的空间。
      以下是源代码(C#的,有兴趣的可以转其它语言):
    using System;
    using System.Text;
    namespace TextBufferStrategy
    {
     public class GapTextBuffer
     {
      char[] buffer = new char[0];
      
      int gapBeginOffset = 0;
      int gapEndOffset   = 0;
      
      int minGapLength = 32;
      int maxGapLength = 256;
      
      public int Length
      {
       get
       {
        return buffer.Length - GapLength;
       }
      }
      
      int GapLength
      {
       get
       {
        return gapEndOffset - gapBeginOffset;
       }
      }
      
      public void SetContent(string text)
      {
       if (text == null)
       {
        text = String.Empty;
       }
       buffer = text.ToCharArray();
       gapBeginOffset = gapEndOffset = 0;
      }
      
      public char GetCharAt(int offset)
      {
       return offset < gapBeginOffset ? buffer[offset] : buffer[offset + GapLength];
      }
      
      public string GetText(int offset, int length)
      {
       int end = offset + length;
       
       if (end < gapBeginOffset)
       {
        return new string(buffer, offset, length);
       }
       
       if (offset > gapBeginOffset)
       {
        return new string(buffer, offset + GapLength, length);
       }
       
       int block1Size = gapBeginOffset - offset;
       int block2Size = end - gapBeginOffset;
       
       StringBuilder buf = new StringBuilder(block1Size + block2Size);
       buf.Append(buffer, offset,       block1Size);
       buf.Append(buffer, gapEndOffset, block2Size);
       return buf.ToString();
      }
      
      public void Insert(int offset, string text)
      {
       Replace(offset, 0, text);
      }
      
      public void Remove(int offset, int length)
      {
       Replace(offset, length, String.Empty);
      }
      
      public void Replace(int offset, int length, string text)
      {
       if (text == null)
       {
        text = String.Empty;
       }
       
       // Math.Max is used so that if we need to resize the array
       // the new array has enough space for all old chars
       PlaceGap(offset + length, Math.Max(text.Length - length, 0));
       text.CopyTo(0, buffer, offset, text.Length);
       gapBeginOffset += text.Length - length;
      }
      
      void PlaceGap(int offset, int length)
      {
       int deltaLength = GapLength - length;
       // if the gap has the right length, move the chars between offset and gap
       if (minGapLength <= deltaLength && deltaLength <= maxGapLength)
       {
        int delta = gapBeginOffset - offset;
        // check if the gap is already in place
        if (offset == gapBeginOffset)
        {
         return;
        }
        else if (offset < gapBeginOffset)
        {
         int gapLength = gapEndOffset - gapBeginOffset;
         Array.Copy(buffer, offset, buffer, offset + gapLength, delta);
        }
        else
        { //offset > gapBeginOffset
         Array.Copy(buffer, gapEndOffset, buffer, gapBeginOffset, -delta);
        }
        gapBeginOffset -= delta;
        gapEndOffset   -= delta;
        return;
       }
       
       // the gap has not the right length so
       // create new Buffer with new size and copy
       int oldLength       = GapLength;
       int newLength       = maxGapLength + length;
       int newGapEndOffset = offset + newLength;
       char[] newBuffer    = new char[buffer.Length + newLength - oldLength];
       
       if (oldLength == 0)
       {
        Array.Copy(buffer, 0, newBuffer, 0, offset);
        Array.Copy(buffer, offset, newBuffer, newGapEndOffset, newBuffer.Length - newGapEndOffset);
       }
       else if (offset < gapBeginOffset)
       {
        int delta = gapBeginOffset - offset;
        Array.Copy(buffer, 0, newBuffer, 0, offset);
        Array.Copy(buffer, offset, newBuffer, newGapEndOffset, delta);
        Array.Copy(buffer, gapEndOffset, newBuffer, newGapEndOffset + delta, buffer.Length - gapEndOffset);
       }
       else
       {
        int delta = offset - gapBeginOffset;
        Array.Copy(buffer, 0, newBuffer, 0, gapBeginOffset);
        Array.Copy(buffer, gapEndOffset, newBuffer, gapBeginOffset, delta);
        Array.Copy(buffer, gapEndOffset + delta, newBuffer, newGapEndOffset, newBuffer.Length - newGapEndOffset);
       }
       
       buffer         = newBuffer;
       gapBeginOffset = offset;
       gapEndOffset   = newGapEndOffset;
      }
     }
    }

    转载于:https://www.cnblogs.com/David-Li/archive/2008/06/30/1232394.html

    展开全文
  • java中的byte有什么作用?

    千次阅读 2017-05-17 09:10:49
     通常在读取非文本文件时(如图片,声音,可执行文件)需要字节数组来保存文件的内容,在下载文件时,也是byte数组作临时的缓冲器接收文件内容。所以说byte在文件操作时是必不可少的。不管是对文件写入还是读取...
    
      byte即字节的意思,是java中的基本类型,用心申明字节型的变量。

      通常在读取非文本文件时(如图片,声音,可执行文件)需要用字节数组来保存文件的内容,在下载文件时,也是用byte数组作临时的缓冲器接收文件内容。所以说byte在文件操作时是必不可少的。不管是对文件写入还是读取都要用到。
    展开全文
  • 通过定义数组的方式确实比以前一-次读取-一个字节的方式快很多,所以,看来一个缓冲区还是非常好的。 既然是这样的话, 那么,java开始在设计的时候,它也考虑到了这个问题,就专门提供了带缓冲区的字节类。 这种类...
  • 按照码农的惯性思维就是去百度、谷歌搜索看没有现成的东西可以直接拿来,然而我并没有找到,好吧不是很难的东西自己实现一个呗。开扯……  为什么环形队列? 环形队列是在实际编程极为有用的数据结构,它...
  • 直接FileInputStream的read方法读取一个字节数组read(byte[] b),和BufferedInputStream有什么不同?看不懂,昏了
  • 什么是magic number

    2020-03-09 19:35:18
    Magic number一般是指硬写到代码里的整数常量,数值是编程者自己指定的,其他人不知道数值有什么具体意义,表示不明觉厉,就称作magic number。编程教材书magic number指代初学者不定义常量直接写数的不良习惯。...
  • 我当前的解决方案使用BufferedInputStream保存到分配1024个字节的字节数组。然后将每个缓冲区保存在中,以ArrayList备后。整个过程是通过单独的线程(可调用接口)调用的。虽然不是很快。ArrayList outputArr = ...
  • Java常见面试题

    千次阅读 2019-04-11 22:43:55
    文章目录如何用数组实现队列?内部类访问局部变量的时候,为什么变量必须加上final修饰?long s = 499999999 \* 499999999 在上面的代码中,s的值是多少?NIO相关,Channels、Buffers、Selectors流与缓冲阻塞与非...
  • 在看毕向东老师基础视频关于IO流的时候,老师先讲了...那么,这里BufferedReader缓冲区(字符数组) 和 FileReaderread(char [])方法中的数组有什么区别呢?两者是相同的吗? 百思不得其解,于是查看的jav
  • 你也许问这个计算有什么用呢?先来考虑这个问题,比如今天星期一,100天之后,是星期几呢?像这个问题,就要使用求余运算,因为我们知道一周是7天,只要剩下的数字,就可以计算出来是星期几,因为每7天是一个周期。...
  • 在BufferedInputStream中,一个定义一个byte数组来存放流,文件等数据(俗称缓冲数组),如下图所示 将文件数据部分读入缓冲区,缓冲区大小为10 从缓冲区中取出1,2两个数据 调用mark(int readlimit)...
  • //一个byte数组接收发送的数据字节 request.ContentLength = buffer.Length; //告诉服务器自己上传的数组长度 request.GetRequestStream().Write(buffer, 0, buffer.Length); //写入请求流从第一位开始...
  • hoopy:移至GITLAB-源码

    2021-02-05 10:18:15
    有什么用? 如果您想为流I / O使用固定长度的缓冲区,Hoopy可以为您做到这一点。 如何安装? 通过npm : npm i hoopy --save 或者,如果您只想要git repo: git clone git@github.com:philbooth/hoopy.git 如何...
  • 比起指针,数组有这样的优势: 1.不需要初始化,数组名直接就是所在的偏移 2.不占任何空间,指针需要占用int长度空间,空数组不占任何空间。 “这个数组不占用任何内存”,意味着这样的结构节省空间;...
  • /* 初始化显示缓冲数组 */ CurrentMode=CLOCK; /* 默认的显示摸式为时钟 */ P3_1=0; /* 蜂鸣器接线引脚复位 */ } <p>void timer0(void) interrupt 1 using 1 /* 定时器 0 中断服务器&#...
  • 8.3.4 用数组名作函数参数 8.3.5 通过指针引用多维数组 8.4 通过指针引用字符串 8.4.1 字符串的引用方式 8.4.2 字符指针作函数参数 8.4.3 使用字符指针变量和字符数组的比较 8.5 指向函数的指针 8.5.1 什么是函数...
  • 内部之间又有什么联系呢? 相信你在面试过程中也遇到过类似的问题(看完这边文章,你可以知道答案的噢😯)? 接下来我们从源码的角度一步步去探究其内部实现的原理。 一切从<code>on开始 为...
  • 内存视图(Memoryview)内存视图对象到底是什么?先来看看官方手册上怎么说:内存视图...一个已经存在的原生数据块对象,比如字节,字节数组或者Numpy中的数组,这些对象有缓冲区协议定义的特性,可以用缓冲区协议定...
  • 你必须知道的495个C语言问题

    千次下载 热门讨论 2015-05-08 11:09:25
    6.12 既然数组引用会退化为指针,如果array是数组,那么array和&array又有什么区别呢? 6.13 如何声明一个数组的指针? 动态数组分配 6.14 如何在运行时设定数组的大小?怎样才能避免固定大小的数组? 6.15 ...
  • * @return 返回true,当且仅当缓冲区内可以解析的数据而你需要再次调用doDecode时;返回false,如果缓冲区内其余的数据不足以进行解析,      * 然后当更多的数据积累到缓冲区时...
  • 6、int 和 Integer 有什么区别  Java 提供两种不同的类型:引用类型和原始类型(或内置类型)。Int是java的原始数据类型,Integer是java为int提供的封装类。Java为每个原始类型提供了封装类。 原始类型 封装类 ...
  • Netty中的ByteBuf详解

    2018-05-03 14:34:34
    ByteBuf是做什么用的?Netty中传递字节数据的容器。ByteBuf的使用模式那些?使用模式描述 优点 劣势堆缓冲区数据存存储在JVM的堆空间中,又称为支撑数组,通过 hasArray 来判断是不是在堆缓冲区中 没使用池化情况...
  • 通过定义数组的方式比以前一次读取一个字节方式要快很多,看来一个缓冲区是非常好的 既然是这样的,Java在开始设计的时候,也考虑到了这个问题,就专门提供了缓冲区的字节类 这种类被成为缓冲区类,也叫高效类 写...

空空如也

空空如也

1 2 3 4 5 ... 9
收藏数 175
精华内容 70
关键字:

缓冲数组有什么用