Thiam Teck Oon's Profile

The TreeSet class keeps the elements of a set sorted in a specified order. However, the time that it takes to add, remove, or find elements in a set is generally longer than that required for a set managed by a HashSet.

they are always sorted in their natural order.

it keeps its elements in the same order in which they were inserted into the set. Adding and removing elements in a LinkedHashSet object is a little bit slower than for a HashSet

Sets managed by the ConcurrentSkipListSet class can be safely modified by multiple threads at the same time, with no need to use locks.

The CopyOnWriteArraySet class is used to solve a specific concurrency problem without having to resort to locks.

Queues based on the LinkedList class do not block.

A PriorityQueue object keeps objects in a queue sorted in a specified order

Queues based on the PriorityQueue include methods that block.

For situations when multiple threads are waiting to perform operations on a queue, the behavior of an ArrayBlockingQueue object will be more consistent and predictable than for a LinkedBlockingQueue.

However, the LinkedBlockingQueue class may provide better throughput.

The methods to add objects to or remove objects from a ConcurrentLinkedQueue take a constant amount of time that is not related to the number of objects in the queue. However, the size operation takes time proportionate to the number of objects in the queue.

The Delayed interface defines a getDelay method that returns a delay expressed in a specified unit of time. Objects cannot be removed from a DelayQueue while their delay is a positive number.

The SynchronousQueue class blocks. A SynchronousQueue object is always empty. A SynchronousQueue object's put method blocks unless another thread is waiting for the object's take method to return. A SynchronousQueue object's take method blocks unless another thread is waiting for the object's put method to return.

The CopyOnWriteArrayList class is functionally similar to the ArrayList class, with one important difference. All operations that change the contents of a CopyOnWriteArrayList collection cause the underlying array to be replaced with a copy of itself before the contents of the array are changed. Any active iterators will continue to see the unmodified array, so there is no need for locks.

Iterators created by a CopyOnWriteArrayList object cannot change the underlying array. Though these iterators do have methods for changing the underlying collection, their implementations throw an UnsupportedOperationException instead of modifying the underlying collection.