Why doesn't java.util.HashSet have a get(Object o) method?

I've seen other questions about getting objects from Set's based on index value and I understand why that is not possible. But I haven'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'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<Foo> set = new HashSet<Foo>();
		
		Foo foo1 = new Foo("1");
		foo1.setDescription("Number 1");
		
		set.add(foo1);
		set.add(new Foo("2"));
		
		//I want to get the object stored in the Set, so I construct a object that is 'equal' to the one I want.
		Foo theFoo = set.get(new Foo("1")); //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 "absolute" equality rather than "logical" equality (in which case contains(Object o) would be sufficient)?

Java Map/Collection Cheat Sheet

Will it contain key/value pair or values only?

> 1) If it contains pairs, the choice is a map. Is order important? > > . 1-1) If yes, follow insertion order or sort by keys?

. . 1-1-1) If ordered, LinkedHashMap

. . 1-1-2) If sorted, TreeMap

. 1-2) If order is not important, HashMap

> 2) If it stores only values, the choice is a collection. Will it contain duplicates?

. 2-1) If yes, ArrayList

> . 2-2) If it will not contain duplicates, is primary task searching for elements > (contains/remove)?

. . 2-2-1) If no, ArrayList

> . . 2-2-2) If yes, is order important?

. . . 2-2-2-1) If order is not important, HashSet

> . . . 2-2-2-2) If yes, follow insertion order or sort by values?

. . . . 2-2-2-2-1) if ordered, LinkedHashSet

. . . . 2-2-2-2-2) if sorted, TreeSet

A Set is a Collection of objects which treats a.equals(b) == true as duplicates, so it doesn't make sense to try to get the same object you already have.

If you are trying to get(Object) from a collection, a Map is likely to be more appropriate.

What you should write is

Map<String, String> map = new LinkedHashMap<>();

map.put("1", "Number 1");
map.put("2", null);
String description = map.get("1");

> if an object is not in the set (based on equals), add it, if it is in the set (based on equals) give me the set's instance of that object

In the unlikely event you need this you can use a Map.

Map<Bar, Bar> map = // LinkedHashMap or ConcurrentHashMap

Bar bar1 = new Bar(1);
map.put(bar1, bar1);

Bar bar1a = map.get(new Bar(1));

Your last sentence is the answer.

get(Object o) would run through the HashSet looking for another object being equal to o (using equals(o) method). So it is indeed the same as contains(o), only not returning the same result.

If you want to know that new Foo("1"); object is already present in the set then you need to use contains method as:

boolean present =  set.contains(new Foo("1"));

The get kind of method i.e. set.get(new Foo("1")); is not supported because it doesn't make sense. You are already having the object i.e. new Foo("1") then what extra information you would be looking through get method.

HashSet is a little bit simplier than HashMap. If you don't need the features of HashMap, why use it? If the method like getObject(ObjectType o) was implemented by Java we dont need to iterate over the set after calling contain() methode...

The reason why there is no get is simple:

If you need to get the object X from the set is because you need something from X and you dont have the object.

If you do not have the object then you need some means (key) to locate it. ..its name, a number what ever. Thats what maps are for right.

map.get( "key" ) -> X!

Sets do not have keys, you need yo traverse them to get the objects.

So, why not add a handy get( X ) -> X

That makes no sense right, because you have X already, purist will say.

But now look at it as non purist, and see if you really want this:

Say I make object Y, wich matches the equals of X, so that set.get(Y)->X. Volia, then I can access the data of X that I didn have. Say for example X has a method called get flag() and I want the result of that.

Now look at this code.

Y

X = map.get( Y );

So Y.equals( x ) true!

but..

Y.flag() == X.flag() = false. ( Were not they equals ?)

So, you see, if set allowed you to get the objects like that It surely is to break the basic semantic of the equals. Later you are going to live with little clones of X all claming that they are the same when they are not.

You need a map, to store stuff and use a key to retrieve it.

A common use case of a get method on Set might be to implement an intern set. If that's what you're trying to achieve, consider using the Interner interface and Interners factory from Google Guava.

if you only want know what are in the Hashset, you can use .toString(); method to display all Hashset Contents separated by comma.

I've got the same problem as the thread author and I've got a real reason why a Set should have a get method: I overwrote equals of e.g. X, the content of the set Set and so the contained object is not necessarily the same as the checked one. In my scenario I'll remove semantic doubles in an other collection and enrich the "original" with some relations of the "double" so I need the "original" to be able to drop the double.

get(Object o) is useful when we have one information linked to other information just like key value pair found in HashMap .So using get() method on one information we can get the second information or vice-versa.

Now, if HashSet provides get(Object o) method you need to pass an object. So if you have the object to pass to the get(Object o) method that means you already have the object, then what is need of get(Object o) method.

As everyone mentioned before, there is no such method and for good reasons. That being said, if you wish to get a certain object from a HashSet in java 8 using a one-liner (almost), simply use streams. In your case, it would be something like:

Foo existing = set.stream().filter(o -> o.equals(new Foo("1"))).collect(Collectors.toList()).iterator().next();

Note that an exception will be thrown if the element doesn't exist so it is technically not a one-liner, though if the filter is properly implemented it should be faster than a traditional iteration over the collection elements.