class LinkedHashSet[<]E[>] extends HashSet<E> implements SequencedSet<E>, Cloneable, java.io.Serializable {

public LinkedHashSet(int initialCapacity, float loadFactor) {
super(initialCapacity, loadFactor, true);
}

public LinkedHashSet(int initialCapacity) {
super(initialCapacity, .75f, true);
}

// Constructs a new, empty linked hash set with the default initial capacity (16) and load factor (0.75).
public LinkedHashSet() {
super(16, .75f, true);
}

@SuppressWarnings("this-escape")
public LinkedHashSet(Collection<? extends E> c) {
super(HashMap.calculateHashMapCapacity(Math.max(c.size(), 12)), .75f, true);
addAll(c);
}

@Override
public Spliterator<E> spliterator() {
return Spliterators.spliterator(this, Spliterator.DISTINCT | Spliterator.ORDERED);
}

public static <T> LinkedHashSet<T> newLinkedHashSet(int numElements) {
if (numElements < 0) {
throw new IllegalArgumentException("Negative number of elements: " + numElements);
}
return new LinkedHashSet<>(HashMap.calculateHashMapCapacity(numElements));
}

LinkedHashMap<E, Object> map() {
return (LinkedHashMap<E, Object>) map;
}

public void addFirst(E e) {
map().putFirst(e, PRESENT);
}

public void addLast(E e) {
map().putLast(e, PRESENT);
}

public E getFirst() {
return map().sequencedKeySet().getFirst();
}

public E getLast() {
return map().sequencedKeySet().getLast();
}

public E removeFirst() {
return map().sequencedKeySet().removeFirst();
}

public E removeLast() {
return map().sequencedKeySet().removeLast();
}
}