“最后100个字节”的采访场景

前几天，我在一次采访中遇到了这个问题，想知道一些可能的最佳答案（我回答得不太好哈哈）：

场景：有一个网页正在监视通过某个网络发送的字节。每次发送一个字节时，都会调用recordByte（）函数来传递该字节，每天可能发生数十万次。此页面上有一个按钮，当按下该按钮时，将在屏幕上显示传递给recordByte（）的最后100个字节（通过调用下面的print方法来执行此操作）。

以下是我被要求填写的代码：

public class networkTraffic {
    public void recordByte(Byte b){
    }
    public String print() {
    }
}

存储100个字节的最佳方法是什么？一个列表？好奇如何最好地做到这一点。

像这样的东西（循环缓冲区）：

byte[] buffer = new byte[100];
int index = 0;

public void recordByte(Byte b) {
   index = (index + 1) % 100;
   buffer[index] = b; 
}

public void print() {
   for(int i = index; i < index + 100; i++) {
       System.out.print(buffer[i % 100]);
   }
}

使用循环缓冲区的好处：

1. 您可以静态保留空间。在实时网络应用程序（VoIP，流式传输..）中，经常这样做是因为您不需要存储传输的所有数据，而只需要存储包含要处理的新字节的窗口即可。
2. 快速：可以用读写成本为O（1）的数组实现。

我不知道Java，但是必须有一个队列概念，您可以使字节排队直到队列中的项目数达到100，此时您将使一个字节出队，然后使另一个字节出队。

public void recordByte(Byte b)
{ 
  if (queue.ItemCount >= 100)
  {
    queue.dequeue();    
  }
  queue.enqueue(b);
}

您可以通过查看以下项目进行打印：

public String print() 
{ 
  foreach (Byte b in queue)
  {
    print("X", b);  // some hexadecimal print function
  }
}  

使用数组的循环缓冲区：

1. 100字节数组
2. 跟踪头索引在哪里
3. 为了recordByte()将当前字节放入A [i]，i = i + 1％100；
4. 对于print()，return subarray（i + 1，100）与subarray（0，i）连接

使用链表的队列（或Java队列）：

1. 用于recordByte()将新字节添加到末尾
2. 如果新长度超过100，则删除第一个元素
3. 对于 print()简单的打印列表

这是我的代码。它可能看起来有些晦涩，但是我很确定这是最快的方法（至少是在C ++中，而不是Java）：

public class networkTraffic {
    public networkTraffic() {
      _ary = new byte[100];
      _idx = _ary.length;
    }

    public void recordByte(Byte b){
      _ary[--_idx] = b;
      if (_idx == 0) {
        _idx = _ary.length;
      }   
    }

    private int _idx;
    private byte[] _ary;
}

需要注意的几点：

• 调用recordByte（）时，没有分配/取消分配数据。
• 我没有使用％，因为它比直接比较和使用if慢（分支预测在这里也可能会有所帮助）
• --_idx比_idx--不涉及任何临时变量要快。
• 我倒数为0，因为这样，我不必_ary.length每次都获得呼叫，而是在到达第一个条目时仅获得100次。也许这不是必需的，编译器可以解决。
• 如果对recordByte（）的调用少于100次，则其余为零。

最简单的方法是将其推入数组。数组可容纳的最大大小为100个字节。不断增加字节流，因为它们正在通过网络流式传输。在数组中的前100个字节之后，当第101个字节出现时，请删除开头的字节（即第0个）。继续这样做。这基本上是一个队列。FIFO概念。下载完成后，您将剩下最后100个字节。

不仅在下载之后，而且在任何给定的时间点，此数组都将具有最后100个字节。

@Yottagray无法到达问题所在？似乎有许多通用方法（数组，循环数组等）和特定于语言的方法（byteArray等）。我想念什么吗？

具有非阻塞I / O的多线程解决方案：

private static final int N = 100;
private volatile byte[] buffer1 = new byte[N];
private volatile byte[] buffer2 = new byte[N];
private volatile int index = -1;
private volatile int tag;

synchronized public void recordByte(byte b) {
  index++;
  if (index == N * 2) {
    //both buffers are full
    buffer1 = buffer2;
    buffer2 = new byte[N];
    index = N;
  }
  if (index < N) {
    buffer1[index] = b;
  } else { 
    buffer2[index - N] = b;
  }
}

public void print() {
  byte[] localBuffer1, localBuffer2;
  int localIndex, localTag;
  synchronized (this) {
   localBuffer1 = buffer1;
   localBuffer2 = buffer2;
   localIndex = index;
   localTag = tag++;
  }
  int buffer1Start = localIndex - N >= 0 ? localIndex - N + 1 : 0;
  int buffer1End = localIndex < N ? localIndex : N - 1;      
  printSlice(localBuffer1, buffer1Start, buffer1End, localTag);
  if (localIndex >= N) {
    printSlice(localBuffer2, 0, localIndex - N, localTag);
  }
}

private void printSlice(byte[] buffer, int start, int end, int tag) {
  for(int i = start; i <= end; i++) {
    System.out.println(tag + ": "+ buffer[i]);
  }
}

只是为了它。如何使用ArrayList<Byte>？说为什么不呢？

public class networkTraffic {
    static ArrayList<Byte> networkMonitor;          // ArrayList<Byte> reference
    static { networkMonitor = new ArrayList<Byte>(100); }   // Static Initialization Block
    public void recordByte(Byte b){
        networkMonitor.add(b);
        while(networkMonitor.size() > 100){
            networkMonitor.remove(0);
        }
    }
    public void print() {
        for (int i = 0; i < networkMonitor.size(); i++) {
            System.out.println(networkMonitor.get(i));
        }
        // if(networkMonitor.size() < 100){
        //  for(int i = networkMonitor.size(); i < 100; i++){
        //      System.out.println("Emtpy byte");
        //  }
        // }
    }
}