如何获取集合的第 n 个元素

Question

更具体地说：如何获取 LinkedHashSet 的第 n 个元素（具有可预测的迭代顺序）？我想检索插入到此 Set 中的第 n 个元素（尚未出现）。

使用List 更好吗：

List<T> list = new ArrayList<T>(mySet);
T value = list.get(x); // x < mySet.size()

或toArray(T [] a) 方法：

T [] array = mySet.toArray(new T[mySet.size()]);
T value = array[y]; // y < mySet.size()

除了（可能是轻微的）性能差异之外，还有什么需要注意的吗？有明确的赢家吗？

编辑 1

注意：为什么我想要最后插入的元素并不重要，重要的是我想要它。之所以选择 LinkedHashSet，是因为它“定义了迭代顺序，即元素插入集合的顺序（insertion-order）。请注意，如果将元素重新插入集合中，则插入顺序不受影响。”

编辑 2

这个问题似乎已经转移到讨论任何 Set 实现是否可以永远保留原始插入顺序。所以我在http://pastebin.com/KZJ3ETx9 上放了一些简单的测试代码来证明是的，LinkedHashSet 确实保留了插入顺序（与其迭代顺序相同），正如它的 Javadoc 所声称的那样。

编辑 3

修改了问题的描述，这样大家就不会太专注于检索Set 的最后一个元素（我原本以为问题的标题就足够暗示了——显然我错了）。

Answer 1

此方法基于更新后的要求返回第 n 个元素，而不仅仅是最后一个元素。如果来源是例如一个标识符为mySet的Set，最后一个元素可以被nthElement(mySet, mySet.size()-1)选中。

如果n 与Set 的大小相比较小，则此方法可能比例如转换为ArrayList。

  /**
   * Return an element selected by position in iteration order.
   * @param data The source from which an element is to be selected
   * @param n The index of the required element. If it is not in the 
   * range of elements of the iterable, the method returns null.
   * @return The selected element.
   */
  public static final <T> T nthElement(Iterable<T> data, int n){
    int index = 0;
    for(T element : data){
      if(index == n){
        return element;
      }
      index++;
    }
    return null;
  }

Answer 2

如果你想检索最后一个元素，我会使用 LinkedHashSet 的迭代器：

Iterator<T> it = linkedHashSet.iterator();
T value = null;

while (it.hasNext()) {
    value = it.next();
}

循环执行后的值将引用最后一个元素。

Answer 3

所以我决定对@Juvanis 的回答稍作改动。

获取 LinkedHashSet 中的第 n 个元素：

Iterator<T> itr = mySet.iterator();
int nth = y;
T value = null;

for(int i = 0; itr.hasNext(); i++) {
    value = itr.next();
    if (i == nth) {
        break;
    }
}

第二版代码：

public class SetUtil {

    @Nullable
    public static <T> T nthElement(Set<T> set, int n) {
        if (null != set && n >= 0 && n < set.size()) {
            int count = 0;
            for (T element : set) {
                if (n == count)
                    return element;
                count++;
            }
        }
        return null;
    }
}

注意：稍作修改，上述方法可用于所有Iterables<T>。

这避免了确保Set 和List 保持同步的开销，并且还避免了每次都必须创建一个新的List（这将比任何数量的算法复杂性都更耗时)。

显然我使用Set 来确保唯一性，我宁愿避免冗长解释为什么我需要索引访问。

Answer 4

您可以使用以下解决方案， 这里我在 HashSet 中添加了 ModelClass 的对象。

ModelClass m1 = null;
int nth=scanner.nextInt();
for(int index=0;index<hashset1.size();index++){
    m1 = (ModelClass) itr.next();
    if(nth == index) {
        System.out.println(m1);
        break;
    }
}

Answer 5

Set 是无序的，因此最后插入的元素的信息会丢失。因此，您不能插入最后一个元素。所以首先不要使用 Set，或者，如果你真的想跟踪最后一个元素，创建一个包含这样的类

class mySetAndLast extends Set{
   T last;
   Set<T> mySet;       
}

现在的问题是“插入的最后一个元素”是什么。想象一下你的集合是空的

-> insert x -> ok, x is the last inserted 
-> insert y (y!=x) -> ok: y is the last inserted 
-> insert x -> ? 

现在是 x 还是 y 最后插入？ x 没有被插入，因为 y 是最后插入的元素并且 x 已经是集合的一个元素，另一方面 x 从用户的角度来看是最后插入的..

Answer 6

为了您自己的内部目的，您可以从任何 List 实现“破解”您自己的 Set：

public class ListSet<E> extends ArrayList<E> implements Set<E> {
    @Override
    public boolean add(E item) {
        return contains(item) ? false : super.add(item);
    }

    // ... and same for add(int, E), addAll(...), etc.
}

该示例很慢（添加的 O(n)），但由于您是实现它的人，您可以根据您的规范为contains() 使用更智能的代码返回它。