public static void main(String[] args) {

	LinkedHashSet<String> linkedHashSet = new LinkedHashSet<String>();
	HashSet<String> hashSet = new HashSet<String>();

	List<Integer> toInsert = Arrays.asList(10, 11, 12, 88, 89, 90, 99);

	System.out.println("Item insertion order:\n" + Arrays.toString(toInsert.toArray()) + "\n");
	for (int i : toInsert) {
		linkedHashSet.add(Integer.toString(i));
		hashSet.add(Integer.toString(i));
	}

	System.out.println(LinkedHashSet.class.getSimpleName() + " iteration order:\n"
			+ Arrays.toString(linkedHashSet.toArray()) + "\n");
	System.out.println(
			HashSet.class.getSimpleName() + " iteration order:\n" + Arrays.toString(hashSet.toArray()) + "\n");

	System.out.println("____________________________________________________________________");
	System.out.println("Reverse the order of added items and re-add them again. (In reverse order.)");
	Collections.reverse(toInsert);

	System.out.println("Item insertion order:\n" + Arrays.toString(toInsert.toArray()) + "\n");
	for (int i : toInsert) {
		linkedHashSet.add(Integer.toString(i));
		hashSet.add(Integer.toString(i));
	}

	System.out.println(LinkedHashSet.class.getSimpleName() + " iteration order:\n"
			+ Arrays.toString(linkedHashSet.toArray()) + "\n");
	System.out.println(HashSet.class.getSimpleName() + " iteration order:\n" + Arrays.toString(hashSet.toArray()));

}

import java.util.AbstractQueue;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;

import org.junit.Assert;
import org.junit.Test;

public class LinkedHashQueueTest extends Assert {

	@Test
	public void checkIterationOrder() {

		final Queue<String> queue = new LinkedList<String>();
		final LinkedHashSet<String> linkedHashSet = new LinkedHashSet<String>();

		final List<Integer> toInsert = Arrays.asList(10, 11, 12, 88, 89, 90, 99);

		for (final int i : toInsert) {
			linkedHashSet.add(Integer.toString(i));
			queue.add(Integer.toString(i));
		}

		final Queue<String> hashQueue = new LinkedHashQueue<String>(linkedHashSet);

		final ArrayList<String> queuePollOrder = new ArrayList<String>();
		final ArrayList<String> hashQueuePollOrder = new ArrayList<String>();

		while (!queue.isEmpty()) {
			queuePollOrder.add(queue.poll());
		}

		while (!hashQueue.isEmpty()) {
			hashQueuePollOrder.add(hashQueue.poll());
		}

		assertTrue(queue.isEmpty());
		assertTrue(hashQueue.isEmpty());

		final String[] expecteds = new String[] { "10", "11", "12", "88", "89", "90", "99" };

		assertArrayEquals(expecteds, queuePollOrder.toArray());
		assertArrayEquals(expecteds, hashQueuePollOrder.toArray());
		assertArrayEquals(queuePollOrder.toArray(), hashQueuePollOrder.toArray());

	}

	public class LinkedHashQueue<E> extends AbstractQueue<E> {

		private final LinkedHashSet<E> delegate;

		public LinkedHashQueue(final LinkedHashSet<E> delegate) {
			this.delegate = delegate;
		}

		@Override
		public boolean offer(final E e) {
			return delegate.add(e);
		}

		@Override
		public E poll() {
			final Iterator<E> itr = delegate.iterator();
			if (itr.hasNext()) {
				final E next = itr.next();
				itr.remove();
				return next;
			}
			return null;
		}

		@Override
		public E peek() {
			final Iterator<E> itr = delegate.iterator();
			if (itr.hasNext()) {
				return itr.next();
			}
			return null;
		}

		@Override
		public Iterator<E> iterator() {
			return delegate.iterator();
		}

		@Override
		public int size() {
			return delegate.size();
		}

		/**
		 * This is overridden due to performance issues. To avoid iteration and
		 * check containment with a simple hash.
		 * 
		 * <p>
		 * {@inheritDoc}
		 */
		@Override
		public boolean contains(final Object o) {
			return delegate.contains(o);
		}

	}

}