In Java we have `HashSet&lt;Integer&gt;`, I need similar structure in Python to use contains like below:

    A = [1, 2, 3]
    S = set()
    S.add(2)
    for x in A:
        if S.contains(x):
            print &quot;Example&quot;

Could you please help?

Contains of HashSet&lt;Integer&gt; in Python

How can I iterate over a `Set`/`HashSet` without the following?

    Iterator iter = set.iterator();
    while (iter.hasNext()) {
        System.out.println(iter.next());
    }


How to Iterate over a Set/HashSet without an Iterator?

According to the contract for a Set in Java, &quot;it is not permissible for a set to contain itself as an element&quot; ([source][1]). However, this is possible in the case of a HashSet of Objects, as demonstrated here:

    Set&lt;Object&gt; mySet = new HashSet&lt;&gt;();
    mySet.add(mySet);
    assertThat(mySet.size(), equalTo(1));

This assertion passes, but I would expect the behavior to be to either have the resulting set be 0 or to throw an Exception. I realize the underlying implementation of a HashSet is a HashMap, but it seems like there should be an equality check before adding an element to avoid violating that contract, no? 

  [1]: https://docs.oracle.com/javase/8/docs/api/java/util/Set.html

Should a HashSet be allowed to be added to itself in Java?

Why can&#39;t I preallocate a `hashset&lt;T&gt;`?

There are times when i might be adding a lot of elements to it and i want to eliminate resizing. 


Why can&#39;t I preallocate a hashset&lt;T&gt;

Let&#39;s say I have this code in Java:

    HashSet&lt;String&gt; wordSet = new HashSet&lt;String&gt;();
    String a = &quot;hello&quot;;
    String b = &quot;hello&quot;;
    wordSet.add(a);

Would `wordSet.contains(b);` return `true` or `false`? From what I understand, `a` and `b` refer to different objects even though their values are the same. So `contains()` should return `false`. However, when I run this code, it returns `true`. **Will it always return `true` no matter where String object `b` is coming from as long as `b` contains the value `&quot;hello&quot;`? Am I guaranteed this always?** If not, when am I not guaranteed this? And what if I wanted to do something similar with objects other than Strings?

Would a Java HashSet&lt;String&gt;&#39;s contains() method test equality of the strings or object identity?

&gt; **Possible Duplicate:**  
&gt; [Efficiently finding the intersection of a variable number of sets of strings](https://stackoverflow.com/questions/2851938/efficiently-finding-the-intersection-of-a-variable-number-of-sets-of-strings)  

&lt;!-- End of automatically inserted text --&gt;

Say, have two Hashset, how to calculate the intersection of them?


    Set&lt;String&gt; s1 = new HashSet&lt;String&gt;();
    
    Set&lt;String&gt; s2 = new HashSet&lt;String&gt;();
    
    S1 INT S2 ?



How to calculate the intersection of two sets?

I need to create a `Set` with initial values.

    Set&lt;String&gt; h = new HashSet&lt;String&gt;();
    h.add(&quot;a&quot;);
    h.add(&quot;b&quot;);

Is there a way to do this in one line of code? For instance, it&#39;s useful for a final static field.

How to initialize HashSet values by construction?

Apart from the fact that `HashSet` does not allow duplicate values, what is the difference between `HashMap` and `HashSet`?

I mean implementation wise? It&#39;s a little bit vague because both use _hash tables_ to store values.



Difference between HashSet and HashMap?

Can you explain what is the difference between `HashSet&lt;T&gt;` and `List&lt;T&gt;` in .NET? 

Maybe you can explain with an example in what cases `HashSet&lt;T&gt;` should be preferred against `List&lt;T&gt;` ?


What is the difference between HashSet&lt;T&gt; and List&lt;T&gt;?

I wanted to store some pixels locations without allowing duplicates, so the first thing comes to mind is `HashSet&lt;Point&gt;` or similar classes. However this seems to be very slow compared to something like `HashSet&lt;string&gt;`.

For example, this code:

    HashSet&lt;Point&gt; points = new HashSet&lt;Point&gt;();
    using (Bitmap img = new Bitmap(1000, 1000))
    {
        for (int x = 0; x &lt; img.Width; x++)
        {
            for (int y = 0; y &lt; img.Height; y++)
            {
                points.Add(new Point(x, y));
            }
        }
    }

takes about 22.5 seconds.

While the following code *(which is not a good choice for obvious reasons)* takes only 1.6 seconds:

    HashSet&lt;string&gt; points = new HashSet&lt;string&gt;();
    using (Bitmap img = new Bitmap(1000, 1000))
    {
        for (int x = 0; x &lt; img.Width; x++)
        {
            for (int y = 0; y &lt; img.Height; y++)
            {
                points.Add(x + &quot;,&quot; + y);
            }
        }
    }

**So, my questions are:**

- Is there a reason for that? I checked [this answer][1], but 22.5 sec is way more than the numbers shown in that answer.
- Is there a better way to store points without duplicates?


  [1]: https://stackoverflow.com/a/10348367/4934172

Why is HashSet&lt;Point&gt; so much slower than HashSet&lt;string&gt;?

What is the difference between them? I know that 

&gt; A LinkedHashSet is an ordered version of HashSet that
maintains a doubly-linked List across all elements. Use this class instead of HashSet
when you care about the iteration order. When you iterate through a HashSet the
order is unpredictable, while a LinkedHashSet lets you iterate through the elements
in the order in which they were inserted. 

But in sourcecode of LinkedHashSet there are only calling constructors of HashSet. So where is double-linked List and insertion order?


HashSet vs LinkedHashSet

Please consider the below piece of code:

    HashSet hs = new HashSet();
    hs.add(&quot;hi&quot;); -- (1)
    hs.add(&quot;hi&quot;); -- (2)

`hs.size()` will give 1 as `HashSet` doesn&#39;t allow duplicates so only one element will be stored.

I want to know if we add the duplicate element, then does it replace the previous element or it simply doesn&#39;t add it?  

Also, what will happen using`HashMap` for the same case?

Does adding a duplicate value to a HashSet/HashMap replace the previous value

I have a class that is `IComparable`:

    public class a : IComparable
    {
        public int Id { get; set; }
        public string Name { get; set; }
    
        public a(int id)
        {
            this.Id = id;
        }
    
        public int CompareTo(object obj)
        {
            return this.Id.CompareTo(((a)obj).Id);
        }
    }

When I add a list of object of this class to a hash set:

    a a1 = new a(1);
    a a2 = new a(2);
    HashSet&lt;a&gt; ha = new HashSet&lt;a&gt;();
    ha.add(a1);
    ha.add(a2);
    ha.add(a1);

Everything is fine and `ha.count` is `2`, but:

    a a1 = new a(1);
    a a2 = new a(2);
    HashSet&lt;a&gt; ha = new HashSet&lt;a&gt;();
    ha.add(a1);
    ha.add(a2);
    ha.add(new a(1));

Now `ha.count` is `3`.

 1. Why doesn&#39;t `HashSet` respect `a`&#39;s `CompareTo` method.
 2. Is `HashSet` the best way to have a list of unique objects?
    

How does HashSet compare elements for equality?

I am exploring the `HashSet&lt;T&gt;` type, but I don&#39;t understand where it stands in collections.

Can one use it to replace a `List&lt;T&gt;`? I imagine the performance of a `HashSet&lt;T&gt;` to be better, but I couldn&#39;t see individual access to its elements.

Is it only for enumeration?

When should I use the HashSet&lt;T&gt; type?

HashSet is based on HashMap.

If we look at `HashSet&lt;E&gt;` implementation, everything is been managed under `HashMap&lt;E,Object&gt;`.

`&lt;E&gt;` is used as a key of `HashMap`.

And we know that `HashMap` is not thread safe. That is why we have `ConcurrentHashMap` in Java.

Based on this, I am confused that **why we don&#39;t have a ConcurrentHashSet which should be based on the `ConcurrentHashMap`?**

Is there anything else that I am missing? I need to use `Set` in a multi-threaded environment.


Also, If I want to create my own `ConcurrentHashSet` can I achieve it by just replacing the `HashMap` to `ConcurrentHashMap` and leaving the rest as is?

Why there is no ConcurrentHashSet against ConcurrentHashMap

For lists, we use the `Collections.sort(List)` method. What if we want to sort a `HashSet`?

How to sort a HashSet?

Is there a collection in C# that will not let you add duplicate items to it? For example, with the silly class of

    public class Customer {
        public string FirstName { get; set; }
        public string LastName { get; set; }
        public string Address { get; set; }

        public override int GetHashCode() {
            return (FirstName + LastName + Address).GetHashCode();
        }
        
        public override bool Equals(object obj) {
            Customer C = obj as Customer;
            return C != null &amp;&amp; String.Equals(this.FirstName, C.FirstName) &amp;&amp; String.Equals(this.LastName, C.LastName) &amp;&amp; String.Equals(this.Address, C.Address);
        }
    }

The following code will (obviously) throw an exception:

    Customer Adam = new Customer { Address = &quot;A&quot;, FirstName = &quot;Adam&quot;, LastName = &quot;&quot; };
    Customer AdamDup = new Customer { Address = &quot;A&quot;, FirstName = &quot;Adam&quot;, LastName = &quot;&quot; };

    Dictionary&lt;Customer, bool&gt; CustomerHash = new Dictionary&lt;Customer, bool&gt;();
    CustomerHash.Add(Adam, true);
    CustomerHash.Add(AdamDup, true);

But is there a class that will similarly guarantee uniqueness, but without KeyValuePairs? I thought `HashSet&lt;T&gt;` would do that, but having read the docs it seems that class is just a set implementation (*go figure*).



Collection that allows only unique items in .NET?

So, if I try to remove elements from a Java *HashSet* while iterating, I get a *ConcurrentModificationException*.  What is the best way to remove a subset of the elements from a *HashSet* as in the following example?

    Set&lt;Integer&gt; set = new HashSet&lt;Integer&gt;();
    
    for(int i = 0; i &lt; 10; i++)
    	set.add(i);
    
    // Throws ConcurrentModificationException
    for(Integer element : set)
    	if(element % 2 == 0)
    		set.remove(element);

Here is a solution, but I don&#39;t think it&#39;s very elegant:
    
    Set&lt;Integer&gt; set = new HashSet&lt;Integer&gt;();
    Collection&lt;Integer&gt; removeCandidates = new LinkedList&lt;Integer&gt;();
    
    for(int i = 0; i &lt; 10; i++)
    	set.add(i);
    
    for(Integer element : set)
    	if(element % 2 == 0)
    		removeCandidates.add(element);
    
    set.removeAll(removeCandidates);

Thanks!


Remove Elements from a HashSet while Iterating

    HashSet&lt;T&gt; t = new HashSet&lt;T&gt;();
    // add 10 million items


    Dictionary&lt;K, V&gt; t = new Dictionary&lt;K, V&gt;();
    // add 10 million items.


Whose `.Contains` method will return quicker?

Just to clarify, my requirement is I have 10 million objects (well, strings really) that I need to check if they exist in the data structure. I will NEVER iterate.

HashSet&lt;T&gt; versus Dictionary&lt;K, V&gt; w.r.t searching time to find if an item exists

I&#39;ve always loved trees, that nice `O(n*log(n))` and the tidiness of them. However, every software engineer I&#39;ve ever known has asked me pointedly why I would use a `TreeSet`. From a CS background, I don&#39;t think it matters all that much which you use, and I don&#39;t care to mess around with hash functions and buckets (in the case of `Java`).

In which cases should I use a `HashSet` over a `TreeSet`?

Hashset vs Treeset

Jon Skeet recently raised an interesting programming topic on his blog: [&quot;There&#39;s a hole in my abstraction, dear Liza, dear Liza&quot;](https://codeblog.jonskeet.uk/2010/07/29/there-s-a-hole-in-my-abstraction-dear-liza-dear-liza/) (emphasis added):

&gt; I have a set – a `HashSet`, in fact. I want to remove some items from it… and many of the items may well not exist. In fact, in our test case, *none* of the items in the &quot;removals&quot; collection will be in the original set. This sounds – and indeed *is* – extremely easy to code. After all, we’ve got [`Set&lt;T&gt;.removeAll`](https://docs.oracle.com/javase/6/docs/api/java/util/Set.html#removeAll(java.util.Collection)) to help us, right?
&gt;
&gt; We specify the size of the &quot;source&quot; set and the size of the &quot;removals&quot; collection on the command line, and build both of them. The source set contains only non-negative integers; the removals set contains only negative integers. We measure how long it takes to remove all the elements using `System.currentTimeMillis()`, which isn’t the world most accurate stopwatch but is more than adequate in this case, as you’ll see. Here’s the code:
&gt; 
&gt;     import java.util.*;
&gt;     public class Test 
&gt;     { 
&gt;         public static void main(String[] args) 
&gt;         { 
&gt;            int sourceSize = Integer.parseInt(args[0]); 
&gt;            int removalsSize = Integer.parseInt(args[1]); 
&gt;             
&gt;            Set&lt;Integer&gt; source = new HashSet&lt;Integer&gt;(); 
&gt;            Collection&lt;Integer&gt; removals = new ArrayList&lt;Integer&gt;(); 
&gt;             
&gt;            for (int i = 0; i &lt; sourceSize; i++) 
&gt;            { 
&gt;                source.add(i); 
&gt;            } 
&gt;            for (int i = 1; i &lt;= removalsSize; i++) 
&gt;            { 
&gt;                removals.add(-i); 
&gt;            } 
&gt;             
&gt;            long start = System.currentTimeMillis(); 
&gt;            source.removeAll(removals); 
&gt;            long end = System.currentTimeMillis(); 
&gt;            System.out.println(&quot;Time taken: &quot; + (end - start) + &quot;ms&quot;); 
&gt;         }
&gt;     }
&gt;
&gt; Let’s start off by giving it an easy job: **a source set of 100 items, and 100 to remove:**
&gt;
&gt; &lt;!-- language: lang-none --&gt;
&gt;
&gt;     c:UsersJonTest&gt;java Test 100 100
&gt;     Time taken: 1ms
&gt;
&gt; Okay, so we hadn’t expected it to be slow… clearly we can ramp things up a bit. How about a source of one million items and 300,000 items to remove?
&gt;
&gt; &lt;!-- language: lang-none --&gt;
&gt;
&gt;     c:UsersJonTest&gt;java Test 1000000 300000
&gt;     Time taken: 38ms
&gt;
&gt; Hmm. That still seems pretty speedy. Now I feel I’ve been a little bit cruel, asking it to do all that removing. Let’s make it a bit easier – 300,000 source items and 300,000 removals:
&gt;
&gt; &lt;!-- language: lang-none --&gt;
&gt;
&gt;     c:UsersJonTest&gt;java Test 300000 300000
&gt;     Time taken: 178131ms
&gt;
&gt; Excuse me? Nearly three *minutes*? Yikes! Surely it ought to be easier to remove items from a *smaller* collection than the one we managed in 38ms?

Can someone explain why this is happening? Why is the `HashSet&lt;T&gt;.removeAll` method so slow?



The HashSet&lt;T&gt;.removeAll method is surprisingly slow

I have a list of a few thousand integer keys. The only thing I need to do with this list is say whether or not a given value is in the list.

For C# I would use a `HashSet` to make that look-up fast. What&#39;s the JavaScript equivalent?

***

Minimal support level: IE 9+, jQuery (current)

What is the JavaScript equivalent to a C# HashSet?

I&#39;ve read [this question][1] about why it is not possible, but haven&#39;t found a solution to the problem.

I would like to retrieve an item from a .NET [`HashSet&lt;T&gt;`][2]. I&#39;m looking for a method that would have this signature:

    /// &lt;summary&gt;
    /// Determines if this set contains an item equal to &lt;paramref name=&quot;item&quot;/&gt;, 
    /// according to the comparison mechanism that was used when the set was created. 
    /// The set is not changed. If the set does contain an item equal to 
    /// &lt;paramref name=&quot;item&quot;/&gt;, then the item from the set is returned.
    /// &lt;/summary&gt;
    bool TryGetItem&lt;T&gt;(T item, out T foundItem);

Searching the set for an item with such a method would be O(1). The only way to retrieve an item from a `HashSet&lt;T&gt;` is to enumerate all items which is O(n).

I haven&#39;t find any workaround to this problem other then making my own `HashSet&lt;T&gt;` or use a `Dictionary&lt;K, V&gt;`. Any other idea?

**Note:**  
I don&#39;t want to check if the `HashSet&lt;T&gt;` contains the item. I want to get the reference to the item that is stored in the `HashSet&lt;T&gt;` because I need to update it (without replacing it by another instance). The item I would pass to the `TryGetItem` would be equal (according to the comparison mechanism that I&#39;ve passed to the constructor) but it would not be the same reference.

  [1]: https://stackoverflow.com/questions/1494812/why-cant-i-retrieve-an-item-from-a-hashset-without-enumeration
  [2]: http://msdn.microsoft.com/en-us/library/bb359438.aspx

How to retrieve actual item from HashSet&lt;T&gt;?

I have method with HashSet&lt;string&gt; parameter. And I need to do case-insensitive Contains within it:

    public void DoSomething(HashSet&lt;string&gt; set, string item)
    {
        var x = set.Contains(item);
        ... 
    }

Is it any way to make existing HashSet case-insensitive (do not create new one)?

I&#39;m looking for solution with best perfomance.

**Edit**

Contains can be called multiple times. So IEnumerable&lt;T&gt; extensions are not acceptable for me due to lower perfomance than native HashSet Contains method.

**Solution**

Since, answer to my question is NO, it is impossible, I&#39;ve created and used following method:

    public HashSet&lt;string&gt; EnsureCaseInsensitive(HashSet&lt;string&gt; set)
    {
        return set.Comparer == StringComparer.OrdinalIgnoreCase
               ? set
               : new HashSet&lt;string&gt;(set, StringComparer.OrdinalIgnoreCase);
    }


Make HashSet&lt;string&gt; case-insensitive

I understand that the Set&lt;K&gt; returned from a Map&lt;K,V&gt;&#39;s keySet() method does not guarantee any particular order.

My question is, does it guarantee the **same** order over multiple iterations.  For example

    Map&lt;K,V&gt; map = getMap();

    for( K k : map.keySet() )
    {
    }

    ...

    for( K k : map.keySet() )
    {
    }

In the above code, assuming that the map is **not** modified, will the iteration over the keySets be in the same order.  Using Sun&#39;s jdk15 it **does** iterate in the same order, but before I depend on this behavior, I&#39;d like to know if all JDKs will do the same.


**EDIT**

I see from the answers that I cannot depend on it.  Too bad.  I was hoping to get away with not having to build some new Collection to guarantee my ordering.  My code needed to iterate through, do some logic, and then iterate through again with the same ordering.  I&#39;ll just create a new ArrayList from the keySet which will guarantee order.

is the Java HashMap keySet() iteration order consistent?

**HashSet**
The C# HashSet data structure was introduced in the .NET Framework 3.5. A full list of the implemented members can be found at the [HashSet MSDN][1] page.


 2. Where is it used?
 3. Why would you want to use it?


  [1]: http://msdn.microsoft.com/en-us/library/bb359438.aspx

Define: What is a HashSet?

With a list you can do:

    list.AddRange(otherCollection);

There is no add range method in a `HashSet`.
What is the best way to add another `ICollection` to a `HashSet`?

Is there an AddRange equivalent for a HashSet in C#

Does the [`HashSet`](https://msdn.microsoft.com/en-us/library/bb359438(v=vs.110).aspx) collection introduced in .NET 3.5 preserve insertion order when iterated using `foreach`? 

The [documentation][1] states, that the collection is not sorted, but it doesn&#39;t say anything about insertion order. A pre-release BCL [blog entry][2] states that it is unordered, but [this article][3] states that it is designed to preserve insertion order. My limited testing suggests, that order is preserved, but that could be a coincidence.

  [1]: http://msdn.microsoft.com/en-us/library/bb397727.aspx
  [2]: http://blogs.msdn.com/bclteam/archive/2006/11/09/introducing-hashset-t-kim-hamilton.aspx
  [3]: http://www.vcskicks.com/hashset.php

Does HashSet preserve insertion order?

I am trying to determine if two `HashSet` objects in .NET 3.5 (C#) are equal sets, *i.e.* contain the same values. This seems like something one would obviously want to do but none of the provided functions seem to give you this information.

The way I can think to do this is by checking if the count of the two sets are equal *and* one set is a subset (not proper) of the other. I think the only way that can happen is if they are equal sets. Example code:

    HashSet&lt;int&gt; set1 = new HashSet&lt;int&gt;();
    set1.Add(1);
    set1.Add(2);
    set1.Add(3);
    
    HashSet&lt;int&gt; set2 = new HashSet&lt;int&gt;();
    set2.Add(1);
    set2.Add(2);
    set2.Add(3);
    
    if(set1.Count == set2.Count &amp;&amp; set1.IsSubsetOf(set2))
    {
        // do something
    }

Would this always work? Is there a better way? Why doesn&#39;t `HashSet` have a  `public bool IsEqualSetWith()` function?

How do you determine if two HashSets are equal (by value, not by reference)?

How to use `HashSet&lt;string&gt;.Contains()` method in case -insensitive mode?

How to use HashSet&lt;string&gt;.Contains() method in case -insensitive mode?

I had a interview today and the person taking my interview puzzled me with his statement asking if it possible that `TreeSet` equals `HashSet` but not `HashSet` equals `TreeSet`. I said &quot;no&quot; but according to him the answer is &quot;yes&quot;. 

How is it even possible?

Is it possible that TreeSet equals HashSet but not HashSet equals TreeSet

I&#39;ve seen other questions about getting objects from `Set`&#39;s based on index value and I understand why that is not possible. But I haven&#39;t been able to find a good explanation for why a get by object is not allowed so thought I would ask.

`HashSet` is backed by a `HashMap` so getting an object from it should be pretty straightforward. As it is now, it appears I would have to iterate over each item in the `HashSet` and test for equality which seems unnecessary.

I could just use a `Map` but I have no need for a key:value pair, I just need a `Set`.


For example say I have `Foo.java`:

	package example;

	import java.io.Serializable;

	public class Foo implements Serializable {
		
		String _id;
		String _description;
		
		public Foo(String id){
			this._id = id
		}

		public void setDescription(String description){
			this._description = description;
		}
		
		public String getDescription(){
			return this._description;
		}
		
		public boolean equals(Object obj) {
			//equals code, checks if id&#39;s are equal
		}
		
		public int hashCode() {
			//hash code calculation
		}

	}

and `Example.java`:

	package example;

	import java.util.HashSet;

	public class Example {
		
		public static void main(String[] args){
			HashSet&lt;Foo&gt; set = new HashSet&lt;Foo&gt;();
			
			Foo foo1 = new Foo(&quot;1&quot;);
			foo1.setDescription(&quot;Number 1&quot;);
			
			set.add(foo1);
			set.add(new Foo(&quot;2&quot;));
			
			//I want to get the object stored in the Set, so I construct a object that is &#39;equal&#39; to the one I want.
			Foo theFoo = set.get(new Foo(&quot;1&quot;)); //Is there a reason this is not allowed?
			System.out.println(theFoo.getDescription); //Should print Number 1
		}
		
	}


Is it because the equals method is meant to test for &quot;absolute&quot; equality rather than &quot;logical&quot; equality (in which case `contains(Object o)` would be sufficient)?

Why doesn&#39;t java.util.HashSet have a get(Object o) method?

I need a HashSet that preserves insertion ordering, are there any implementations of this in the framework?

HashSet that preserves ordering

I want to build a `HashSet&lt;u8&gt;` from a `Vec&lt;u8&gt;`. I&#39;d like to do this

1. in one line of code,
2. copying the data only once,
3. using only `2n` memory, 

but the only thing I can get to compile is this piece of .. junk, which I think copies the data twice and uses `3n` memory.

    fn vec_to_set(vec: Vec&lt;u8&gt;) -&gt; HashSet&lt;u8&gt; {
        let mut victim = vec.clone();
        let x: HashSet&lt;u8&gt; = victim.drain(..).collect();
        return x;
    }

I was hoping to write something simple, like this:

    fn vec_to_set(vec: Vec&lt;u8&gt;) -&gt; HashSet&lt;u8&gt; {
        return HashSet::from_iter(vec.iter());
    }

but that won&#39;t compile:

&lt;!-- language: none --&gt;

    error[E0308]: mismatched types
     --&gt; &lt;anon&gt;:5:12
      |
    5 |     return HashSet::from_iter(vec.iter());
      |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected u8, found &amp;u8
      |
      = note: expected type `std::collections::HashSet&lt;u8&gt;`
      = note:    found type `std::collections::HashSet&lt;&amp;u8, _&gt;`

.. and I don&#39;t really understand the error message, probably because I need to RTFM.

All Hashset Solutions on Gang of Coders

Total of 34 Hashset Solutions

Contains of HashSet<Integer> in Python

How to Iterate over a Set/HashSet without an Iterator?

Should a HashSet be allowed to be added to itself in Java?

Why can't I preallocate a hashset<T>

Would a Java HashSet<String>'s contains() method test equality of the strings or object identity?

How to calculate the intersection of two sets?

How to initialize HashSet values by construction?

Difference between HashSet and HashMap?

What is the difference between HashSet<T> and List<T>?

Why is HashSet<Point> so much slower than HashSet<string>?

HashSet vs LinkedHashSet

Does adding a duplicate value to a HashSet/HashMap replace the previous value

How does HashSet compare elements for equality?

When should I use the HashSet<T> type?

Why there is no ConcurrentHashSet against ConcurrentHashMap

How to sort a HashSet?

Collection that allows only unique items in .NET?

Remove Elements from a HashSet while Iterating

HashSet<T> versus Dictionary<K, V> w.r.t searching time to find if an item exists

Hashset vs Treeset

The HashSet<T>.removeAll method is surprisingly slow

What is the JavaScript equivalent to a C# HashSet?

How to retrieve actual item from HashSet<T>?

Make HashSet<string> case-insensitive