所以最初，我有这个代码：

import java.util.*;

public class sandbox {
    public static void main(String[] args) {
        HashSet<Integer> hashSet = new HashSet<>();
        for (int i = 0; i < 100_000; i++) {
            hashSet.add(i);
        }

        long start = System.currentTimeMillis();

        for (int i = 0; i < 100_000; i++) {
            for (Integer val : hashSet) {
                if (val != -1) break;
            }

            hashSet.remove(i);
        }

        System.out.println("time: " + (System.currentTimeMillis() - start));
    }
}

在我的计算机上运行嵌套的 for 循环大约需要 4 秒，我不明白为什么要花这么长时间。外循环运行 100,000 次，内循环应该运行 1 次（因为 hashSet 的任何值永远不会是 -1）并且从 HashSet 中删除一个项目是 …

我在C#中有一个hashset,如果在迭代通过hashset时遇到条件,我将删除它,并且不能使用foreach循环执行此操作,如下所示.

foreach (String hashVal in hashset) 
{
     if (hashVal == "somestring") 
     {
            hash.Remove("somestring");
     }
}

那么,如何在迭代时删除元素？

老问题

我的理解是C#在某种意义上HashSet和set类型上都有.我明白什么HashSet是.但为什么set是一个单独的词呢？为什么不是每一套都是HashSet<Object>？

新问题

为什么C#没有泛型Set类型,类似于Dictionary类型？从我的角度来看,我希望有一个具有标准查找/添加/删除性能的集合.我不关心它是用哈希还是别的来实现的.那么为什么不创建一个实际上HashSet在这个版本的C#中实现的集合类,但在将来的版本中可能有些不同？

或者为什么不至少接口ISet？

回答

感谢所有在下面回答的人:ICollection实现了很多你期望的东西ISet.但是,从我的观点来看,ICollection实现IEnumerable虽然集合不必是可枚举的 - 例如:1到2之间的实数集合(更多,集合可以动态生成).我同意这是一个小咆哮,因为"普通程序员"很少需要不可数集.

好的,我想我明白了.HashSet绝对意味着被召唤,Set但这个词Set在某种意义上是保留的.更具体地说,.NET体系结构的创建者希望为不同的语言提供一致的集合(sic!).这意味着标准类的每个名称都不得与.NET语言中的任何关键字一致.Set然而,这个词在VB.NET中使用,它实际上是不区分大小写的(是吗？),所以遗憾的是那里没有空间可操作.

谜团已揭开 :)

结语

Alex Y.的新答案链接到MSDN页面,该页面描述了即将推出的.NET 4.0界面ISet,该界面的行为与我认为的应该完全相同并且由其实现HashedSet.好结局.

我正在尝试使用HashSet来存储我创建的类的对象,但显然相同的对象似乎有两个不同的哈希值,这就是为什么contains方法没有意识到该对象已经在HashSet中.这导致我的程序耗尽堆内存.

我不认为我做错了什么,但无论如何我想要第二意见.我做过类似的操作,之前一切正常,这使得这特别烦人.我很感激任何帮助.

这是我的代码

move1 = new Move(t,s);
if(move1.hashCode()==new Move(t,s).hashCode())
    System.out.println("match");
move2 = new Move(s,t);
moves.add(move1); 
moves.add(move2);
if(moves.contains(new Move(t,s)))
    System.out.println("match found");

这是Move类:

public class Move {
    private int move1;
    private int move2;

    Move(int m1, int m2)
    {
        move1 = m1;
        move2 = m2;
    }

    public String toString()
    {
         return String.valueOf(move1)+" "+String.valueOf(move2);
    }
}

这是我得到的输出

Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
    at java.util.HashMap.addEntry(HashMap.java:797)
    at java.util.HashMap.put(HashMap.java:431)
    at java.util.HashSet.add(HashSet.java:194)
    at makeMove.<init>(makeMove.java:33)

我想知道为什么HashSet,LinkedHashSet和TreeSet实现不允许null元素？每当我尝试运行以下代码时,它会抛出一个空指针异常.

public static void main(String[] args) {

    HashSet<Integer> hashSet = new HashSet<Integer>();

    hashSet.add(2);
    hashSet.add(5);
    hashSet.add(1);
//  hashSet.add(null);  will throw null pointer 
    hashSet.add(999);
    hashSet.add(10);
    hashSet.add(10);
    hashSet.add(11);
    hashSet.add(9);
    hashSet.add(10);
    hashSet.add(000);
    hashSet.add(999);
    hashSet.add(0);

    Iterator<Integer> it = hashSet.iterator();
    while(it.hasNext()){
        int i = it.next();
        System.out.print(i+" ");
    }
    }

请指导我.

我想建立一个HashSet<u8>来自Vec<u8>.我想这样做

1. 在一行代码中,
2. 仅复制一次数据,
3. 仅使用2n记忆,

但我唯一可以编译的就是这段...垃圾,我认为这两次复制数据并使用3n内存.

fn vec_to_set(vec: Vec<u8>) -> HashSet<u8> {
    let mut victim = vec.clone();
    let x: HashSet<u8> = victim.drain(..).collect();
    return x;
}

我希望写一些简单的东西,比如:

fn vec_to_set(vec: Vec<u8>) -> HashSet<u8> {
    return HashSet::from_iter(vec.iter());
}

但那不会编译:

error[E0308]: mismatched types
 --> <anon>:5:12
  |
5 |     return HashSet::from_iter(vec.iter());
  |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected u8, found &u8
  |
  = note: expected type `std::collections::HashSet<u8>`
  = note:    found type `std::collections::HashSet<&u8, _>`

..我真的不明白错误信息,可能是因为我需要RTFM.

我正在解决在给定数组中找到不同整数的数量的基本问题。

我的想法是声明一个std::unordered_set，将所有给定的整数插入到集合中，然后输出集合的大小。这是我实现此策略的代码：

#include <iostream>
#include <fstream>
#include <cmath>
#include <algorithm>
#include <vector>
#include <unordered_set>

using namespace std;

int main()
{
    int N;
    cin >> N;
    
    int input;
    unordered_set <int> S;
    for(int i = 0; i < N; ++i){
        cin >> input;
        S.insert(input);
    }
    
    cout << S.size() << endl;

    return 0;
}

这种策略几乎适用于所有输入。在其他输入情况下，它超时。

我很好奇我的程序为什么会超时，所以我cout << i << endl;在 for 循环中添加了一行。我发现当我进入输入案例时，53000循环的第一次左右迭代几乎会立即通过，但之后100每秒只会发生几次迭代。

我已经阅读了O(N)如果发生大量冲突，散列集如何以插入结束，所以我认为输入在std::unordered_set.

然而，这是不可能的。std::unordered_set用于整数的哈希函数将它们映射到自身（至少在我的计算机上），因此不同整数之间不会发生冲突。我使用写在这个链接上的代码访问了哈希函数。

我的问题是，输入本身是否有可能 …

我什么时候应该选择其中一个？是否有任何指针建议您使用正确的STL容器？

我想在HashSet和HashMap中找到最大的数字.假设我的HashSet中有数字[22,6763,32,42,33],我想在我当前的HashSet中找到最大的数字.我会这样做吗？和HashMap一样.我希望你能帮助我.谢谢.

这是我的Python代码:

len_sums = 0
for i in xrange(100000):
    set_1 = set(xrange(1000))
    set_2 = set(xrange(500, 1500))
    intersection_len = len(set_1.intersection(set_2))
    len_sums += intersection_len
print len_sums

这是我的Rust代码:

use std::collections::HashSet;

fn main() {
    let mut len_sums = 0;
    for _ in 0..100000 {
        let set_1: HashSet<i32> = (0..1000).collect();
        let set_2: HashSet<i32> = (500..1500).collect();
        let intersection_len = set_1.intersection(&set_2).count();
        len_sums += intersection_len;
    }
    println!("{}", len_sums);
}

我相信这些大致相当.我得到以下表现结果:

time python set_performance.py
50000000

real    0m11.757s
user    0m11.736s
sys 0m0.012s

和

rustc set_performance.rs -O       
time ./set_performance 50000000

real    0m17.580s …