有限排序集

Question

我正在寻找元素数量有限的 SortedSet 实现。因此，如果添加了更多元素，则比较器将决定是否添加该项目并从 Set 中删除最后一个元素。

SortedSet<Integer> t1 = new LimitedSet<Integer>(3);
t1.add(5);
t1.add(3);
t1.add(1);
// [1,3,5]
t1.add(2);
// [1,2,3]
t1.add(9);
// [1,2,3]
t1.add(0);
// [0,1,2]

标准 API 中是否有一种优雅的方式来实现这一点？

我写了一个 JUnit 测试来检查实现：

@Test
public void testLimitedSortedSet() {
final LimitedSortedSet<Integer> t1 = new LimitedSortedSet<Integer>(3);
t1.add(5);
t1.add(3);
t1.add(1);
System.out.println(t1);
// [1,3,5]
t1.add(2);
System.out.println(t1);
// [1,2,3]
t1.add(9);
System.out.println(t1);
// [1,2,3]
t1.add(0);
System.out.println(t1);
// [0,1,2]
Assert.assertTrue(3 == t1.size());
Assert.assertEquals(Integer.valueOf(0), t1.first());
}

Answer 1

使用标准 API，您必须自己完成，即扩展排序集类之一并将您想要的逻辑添加到 add() 和 addAll() 方法。应该不会太难。

顺便说一句，我不完全理解你的例子：

t1.add(9);
// [1,2,3]

集合之后不应该包含[1,2,9]吗？

编辑：我想现在我明白了：您只想保留添加到集合中的最小的 3 个元素，对吗？

编辑 2：示例实现（未优化）可能如下所示：

class LimitedSortedSet<E> extends TreeSet<E> {

  private int maxSize;

  LimitedSortedSet( int maxSize ) {
    this.maxSize = maxSize;
  }

  @Override
  public boolean addAll( Collection<? extends E> c ) {
    boolean added = super.addAll( c );        
    if( size() > maxSize ) {
      E firstToRemove = (E)toArray( )[maxSize];
      removeAll( tailSet( firstToRemove ) );
    }   
    return added;
  }

  @Override
  public boolean add( E o ) {    
    boolean added =  super.add( o );
    if( size() > maxSize ) {
      E firstToRemove = (E)toArray( )[maxSize];
      removeAll( tailSet( firstToRemove ) );
    }
    return added;
  }
}

请注意，tailSet() 返回包含参数的子集（如果在集合中）。这意味着如果您无法计算下一个更高的值（不需要在集合中），您将不得不读取该元素。这是在上面的代码中完成的。

如果您可以计算下一个值，例如如果你有一组整数，做一些tailSet( lastElement + 1 ) 就足够了，你不必读取最后一个元素。

或者，您可以自己迭代集合并删除您要保留的最后一个元素之后的所有元素。

另一种选择，虽然这可能更有效，但在插入元素之前检查大小并相应地删除。

更新：正如 msandiford 正确指出的那样，应该删除的第一个元素是索引 maxSize 处的元素。因此，无需读取（重新添加？）最后一个想要的元素。

重要提示： 正如@DieterDP 正确指出的那样，上面的实现违反了Collection#add() api 合同，该合同规定，如果一个集合由于任何原因拒绝添加一个元素，而不是它是重复的，则必须抛出异常。

在上面的示例中，元素是首先添加的，但由于大小限制可能会再次删除，或者可能会删除其他元素，因此这违反了合同。

要解决这个问题，您可能需要更改 add() 和 addAll() 以在这些情况下抛出异常（或者可能在任何情况下使它们无法使用）并提供替代方法来添加不违反任何规则的元素现有的 api 合约。

在任何情况下，应谨慎使用上述示例，因为将其与不知道违规的代码一起使用可能会导致不需要的且难以调试的错误。

Answer 2

我会说这是装饰器模式的典型应用，类似于Collections类暴露的装饰器集合：unmodifiableXXX、synchronizedXXX、singletonXXX等。我会以Guava的ForwardingSortedSet为基类，写一个类用您需要的功能装饰现有的SortedSet，如下所示：

public final class SortedSets {

    public <T> SortedSet<T> maximumSize(
        final SortedSet<T> original, final int maximumSize){

        return new ForwardingSortedSet<T>() {

            @Override
            protected SortedSet<T> delegate() {
                return original;
            }

            @Override
            public boolean add(final T e) {
                if(original.size()<maximumSize){
                    return original.add(e);
                }else return false;
            }

            // implement other methods accordingly
        };
    }

}

Answer 3

不，使用现有的 Java 库没有类似的东西。

但是，是的，您可以使用组合构建如下所示的。我相信这会很容易。

public class LimitedSet implements SortedSet {

    private TreeSet treeSet = new TreeSet();

    public boolean add(E e) {
        boolean result = treeSet.add(e);
        if(treeSet.size() >= expectedSize) {
            // remove the one you like ;)
        }
        return result;
    }

    // all other methods delegate to the "treeSet"

}

更新 看完你的评论

因为您需要始终删除最后一个元素：

• 您可以考虑在内部维护堆栈
• 它会增加 O(n) 的内存复杂度
• 但可以用 O(1)... 恒定时间检索最后一个元素

我相信它应该可以解决问题