我想使用一个已排序的集合，但我可以通过索引访问其中的元素，即我想要同时具有 Set 和 List 特征的东西。 Java.util.TreeSet 非常接近我的需要，但不允许通过索引访问。
我能想到几个选项：
在各种选项之间存在各种权衡。我希望有人能给我一些好的建议。要回答有关“您为什么要这样做？”的潜在问题，请阅读Apriori 算法。
【问题讨论】：
标签： java list performance set
https://github.com/geniot/indexed-tree-map
我遇到了同样的问题。于是我拿了java.util.TreeMap的源代码写了IndexedTreeMap。它实现了我自己的 IndexedNavigableMap：
public interface IndexedNavigableMap<K, V> extends NavigableMap<K, V> {
K exactKey(int index);
Entry<K, V> exactEntry(int index);
int keyIndex(K k);
}
该实现基于在红黑树更改时更新节点权重。权重是给定节点下的子节点数加一 - self。例如当一棵树向左旋转时：
private void rotateLeft(Entry<K, V> p) {
if (p != null) {
Entry<K, V> r = p.right;
int delta = getWeight(r.left) - getWeight(p.right);
p.right = r.left;
p.updateWeight(delta);
if (r.left != null) {
r.left.parent = p;
}
r.parent = p.parent;
if (p.parent == null) {
root = r;
} else if (p.parent.left == p) {
delta = getWeight(r) - getWeight(p.parent.left);
p.parent.left = r;
p.parent.updateWeight(delta);
} else {
delta = getWeight(r) - getWeight(p.parent.right);
p.parent.right = r;
p.parent.updateWeight(delta);
}
delta = getWeight(p) - getWeight(r.left);
r.left = p;
r.updateWeight(delta);
p.parent = r;
}
}
updateWeight 只是将权重更新到根：
void updateWeight(int delta) {
weight += delta;
Entry<K, V> p = parent;
while (p != null) {
p.weight += delta;
p = p.parent;
}
}
当我们需要通过索引找到元素时，这里是使用权重的实现：
public K exactKey(int index) {
if (index < 0 || index > size() - 1) {
throw new ArrayIndexOutOfBoundsException();
}
return getExactKey(root, index);
}
private K getExactKey(Entry<K, V> e, int index) {
if (e.left == null && index == 0) {
return e.key;
}
if (e.left == null && e.right == null) {
return e.key;
}
if (e.left != null && e.left.weight > index) {
return getExactKey(e.left, index);
}
if (e.left != null && e.left.weight == index) {
return e.key;
}
return getExactKey(e.right, index - (e.left == null ? 0 : e.left.weight) - 1);
}
查找键的索引也非常方便：
public int keyIndex(K key) {
if (key == null) {
throw new NullPointerException();
}
Entry<K, V> e = getEntry(key);
if (e == null) {
throw new NullPointerException();
}
if (e == root) {
return getWeight(e) - getWeight(e.right) - 1;//index to return
}
int index = 0;
int cmp;
index += getWeight(e.left);
Entry<K, V> p = e.parent;
// split comparator and comparable paths
Comparator<? super K> cpr = comparator;
if (cpr != null) {
while (p != null) {
cmp = cpr.compare(key, p.key);
if (cmp > 0) {
index += getWeight(p.left) + 1;
}
p = p.parent;
}
} else {
Comparable<? super K> k = (Comparable<? super K>) key;
while (p != null) {
if (k.compareTo(p.key) > 0) {
index += getWeight(p.left) + 1;
}
p = p.parent;
}
}
return index;
}
你可以在https://github.com/geniot/indexed-tree-map找到这项工作的结果
【讨论】：
几点：
有点无法回答，但是当我最后一次需要重新实现频繁项集挖掘算法时，我选择了 FP-growth，它的性能与先验相当（或更好），并且，在我看来，更容易实现。该技术是由 Jiawei Han 等人开发的，基本上在 Data Mining: Concepts and Techniques 中有专门的章节。
有几个开源工具可以接受非常标准化的输入（每行一个整数列表；整数表示项，行表示项集）。其中一些为您提供算法选择。其中许多都可以在此处获得许可许可证：http://fimi.ua.ac.be/src/
请记住，仅使用任何 List 实现不会让您访问 O(1) 元素，除非您专门使用数组/向量。更有可能的是，保留一个大部分或完全排序的数组（使用二进制搜索查找超过特定限制的元素，以及用于随机访问的常规索引），您将获得更好的里程数。
【讨论】：
也许 Treeset 和 apache commons collections API CollectionUtils.get() 的结合可以解决您的问题
【讨论】：
我会调查LinkedHashSet。它维护 HashSet 的插入顺序。
【讨论】：