以自然顺序将唯一元素存储在集合中

Question

While I was solving a Java test I came up with the following question:

You need to store elements in a collection that guarantees that no duplicates are stored and all elements can be accessed in natural order. Which interface provides that capability?

A. java.util.Map
B. java.util.Set
C. java.util.List
D. java.util.Collection

I have no idea what is the right case here? We can store the same element in any of these collections unless in a Set , but the Set doesn't provide the natural order. What's wrong?

Answer 1

TreeSet would give you ordering (either natural ordering by default of custom ordering via a Comparator).

To be more general, SortedSet is the more general interface that offers uniqueness and ordering.

A Set that further provides a total ordering on its elements. The elements are ordered using their natural ordering, or by a Comparator typically provided at sorted set creation time. The set's iterator will traverse the set in ascending element order. Several additional operations are provided to take advantage of the ordering.

Answer 2

The correct answer for that test is Set Let's remember that it's asking for an interface that could provide that; given the right implementation , the Set interface could provide it.

• The Map interface doesn't make any guarantees around what order things are stored, as that's implementation specific. However, if you use the right implementation (that is, TreeMap as spelled out by the docs), then you're guaranteed a natural ordering and no duplicate entries.

  However, there's no requirement about key-value pairs.

• The Set interface also doesn't make any guarantees around what order things are stored in, as that's implementation specific. But, like TreeMap , TreeSet is a set that can be used to store things in a natural order with no duplicates.

  Here's how it'd look.

   Set<String> values = new TreeSet<>(); 

• The List interface will definitely allow duplicates, which instantly rules it out.

• The Collection interface doesn't have anything directly implementing it, but it is the patriarch of the entire collections hierarchy. So, in theory, code like this is legal:

   Collection<String> values = new TreeSet<>(); 

  ...but you'd lose information about what kind of collection it actually was, so I'd discourage its usage.

Answer 3

If by natural order, you mean order of insertion, then LinkedHashSet is your go to Set implementation.

The correct answers are: SortedSet gives guarantees, regarding natural order of elements. TreeSet is typical implementation

Answer 4

Strictly speaking, when choosing from the above List is the only of the interfaces that has a defined order of iteration, however it does allow duplicates.

Set and Map on the other hands, does not allow duplicates (of keys for Map ), but they also do not define the order of iteration, they are unordered by default, with HashSet / HashMap being the counter example.

Collection allows none.

So, strictly speaking - none of the suggested interfaces provide the desired capability, However, as others suggested, there are specific implementations of the interfaces that do allow natural order of elements and no duplicates, mainly the SortedSet interface and its TreeSet implementation

---

To further elaborate why Set is not a good option, if you have a variable, let it be mySet , and you want it to be ordered, users are going to be surprised when you use the Set interface, imaigine the following code:

public int processMyDataStructure(Set set) {
   //some calculation that assumes set is ordered
   return result;
}

and users provide you a HashSet as argument - you are going to get a wrong behavior from your method, because Set does not guarantee ordering. To avoid it you should have asked for an SortedSet rather than Set .

Answer 5

I've come over this question yesterday on my interview test and need to comment on that: the question (assuming one of the listed A, B, C or D answers has to be correct) is plainly wrong. There is no correct answer listed.

Nothing in Set interface guarantees the order in which the elements are to be returned. And there is no such thing, as Makoto would like it in his accepted answer , as right implementation that could theoretically do the job, because we are not asked for any implementation here, but whether interface provides the requested capability.

So, the test question with the answers provided is misguided.

Referring a bit more to accepted answer , there is one more reason for it to be wrong. Specifically, Makoto argues, that The List interface will definitely allow duplicates, which instantly rules it out. This argument may be defied by citation from List specification saying:

It is not inconceivable that someone might wish to implement a list that prohibits duplicates, by throwing runtime exceptions when the user attempts to insert them, but we expect this usage to be rare

so in my opinion, any of the answers given is equally wrong, or, as accepted answer wants it, equally correct, as we are free to write implementation of List (or Map, or Collection) behaving in any way we wish (in boundaries set by an interface specification), but interfaces and their specifications are here to guarantee some contract, and this question is really about them, not about possible implementations.