是否有任何数据结构可以保留迭代顺序并删除旧记录？

Question

我有一个用例，我想从多个线程将条目填充到数据结构中，因此它必须是线程安全的，并且在达到特定大小后开始删除旧记录。而且我还想以相同的插入顺序迭代数据结构。

所以我决定在这里使用Guava Cache，但令我惊讶的是，Guava asMap() 方法不会以任何特定顺序返回元素。

private final Cache<Integer, Integer> cache =
      CacheBuilder.newBuilder().maximumSize(10)
          .removalListener(
              RemovalListeners.asynchronous(new CustomListener(), executorService)
          ).build();

cache.put(1, 1);
cache.put(2, 2);
cache.put(3, 3);
cache.put(4, 4);
cache.put(5, 5);
cache.put(6, 6);

for (Entry<Integer, Integer> entry : cache.asMap().entrySet()) {
  System.out.println(entry.getKey() + "=" + entry.getValue());
}

输出：

2=2
6=6
1=1
4=4
3=3
5=5

我可以在这里使用什么其他有效的数据结构，它可以为我保留迭代顺序，并且在达到大小时可靠删除旧记录，并在我的删除侦听器中有一些回调能弄清楚哪些记录被丢弃了吗？

任何示例都会有很大帮助。我正在使用 Java 7，还不能切换到 Java 8。

所以我应该能够在迭代时得到这样的东西，而且它应该自动删除旧记录：

1=1
2=2
3=3
4=4
5=5
6=6

Answer 1

对于 Java 7，您可以使用 Caffeine 的前身 ConcurrentLinkedHashMap：

ConcurrentMap<Integer, Integer> cache =
        new ConcurrentLinkedHashMap.Builder<Integer, Integer>()
                .maximumWeightedCapacity(10)
                .build();

cache.put(1, 1);
cache.put(2, 2);
cache.put(3, 3);
cache.put(4, 4);
cache.put(5, 5);
cache.put(6, 6);

for (Entry<Integer, Integer> entry : cache.entrySet()) {
    System.out.println(entry.getKey() + "=" + entry.getValue());
}

输出

1=1
2=2
3=3
4=4
5=5
6=6

更多详情请见ExampleUsage · ben-manes/concurrentlinkedhashmap Wiki。

Answer 2

保留迭代顺序的常见数据结构是，

• 队列
• 双端队列
• 链表等。

但是，最适合您需求的解决方案是使用 deque，它提供了一些内置功能，例如，

add(element)：在尾部添加一个元素。

addFirst(element)：向头部添加一个元素。

addLast(element)：在尾部添加一个元素。

offer(element)：在尾部添加一个元素并返回一个布尔值来说明插入是否成功。

offerFirst(element)：向头部添加一个元素并返回一个布尔值 说明插入是否成功。

offerLast(element)：在尾部添加一个元素并返回一个布尔值来说明插入是否成功。

iterator(): 为这个双端队列返回一个迭代器。

descendingIterator()：返回一个与此双端队列相反顺序的迭代器。

push(element)：向头部添加一个元素。

pop(element)：从头部移除一个元素并返回它。

removeFirst()：移除头部元素。

removeLast()：移除尾部的元素。

有关双端队列的更多信息：https://examples.javacodegeeks.com/core-java/util/deque-util/java-util-deque-example/

Answer 3

鉴于您在示例中显示了put(k, v)，我假设您也将此数据结构用于基于键的查找，因此简单的队列并不理想。

在这种情况下，您可以使用由Collection.synchronized 包裹的LikedHashMap，并实现removeEldest 方法。下面的示例没有显示多个线程，但应该可以很好地处理多个线程。为了对要移除的项目执行您自己的计算，您在BoundedMap 的子类中实现entryRemoved 方法：

import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Collections;

class BoundedMap<K, V> extends LinkedHashMap<K, V> {
  private final int capacity;

  public BoundedMap(int capacity) {
    this.capacity = capacity;
  }

  @Override
  protected boolean removeEldestEntry(Map.Entry<K, V> eldest){
    if(size() > capacity) {
      remove(eldest.getKey());
      entryRemoved(eldest);
    }
    return false;
  }

  public void entryRemoved(Map.Entry<K,V> entry) {
  }
}

public class Test {
  public static void main(String[] args) {
    Map<Integer, Integer> m = Collections.synchronizedMap(
      new BoundedMap<Integer, Integer>(5) {
        @Override
        public void entryRemoved(Map.Entry entry) {
          System.out.println(entry);
        }
    });
    System.out.println("--- adding");
    for (int i=0; i<8; i++) {
      m.put(i, -i);
    }
    System.out.println("-- iterating");
    for(Map.Entry<Integer, Integer> entry : m.entrySet()) {
      System.out.println(entry);
    }
  }
}

Answer 4

您可以通过覆盖removeEldestEntry() 的java.util.LinkedHashMap 的简单子类来执行此操作，如其Javadoc 中所述。