Cfrtjryk

There's an implementation of LinkedHashSet in Java. Although this is limited with its functionality, it will do the basic job.
I used interfaces so then I can use that interface for BST.

Set interface :

package interfaces.set;



public interface Set<E> extends Iterable<E>

{

    int size();

    boolean isEmpty();

    boolean add(E e);

    boolean remove(E e);

    boolean contains(E e);

    E get(E e);

}

LinkedHashSet class :

package set;



import interfaces.set.Set;



import java.util.Iterator;

import java.util.LinkedList;

import java.util.List;



public class LinkedHashSet<E> implements Set<E>

{

    private int size;

    private int capacity;

    private List<E> buckets;



    public LinkedHashSet()

    {

        this(500);

    }



    public LinkedHashSet(int capacity)

    {

        size = 0;

        this.capacity = capacity;

        buckets = (LinkedList<E>) new LinkedList[this.capacity];

    }



    @Override

    public int size()

    {

        return size;

    }



    @Override

    public boolean isEmpty()

    {

        return size() == 0;

    }



    @Override

    public boolean add(E e)

    {

        int i = e.hashCode() % capacity;

        if (buckets[i] == null) buckets[i] = new LinkedList <>();

        for (int j = 0; j < buckets[i].size(); j++) if(e.equals(buckets[i].get(j))) return false;

        buckets[i].add(e);

        size++;

        return true;

    }



    @Override

    public boolean remove(E e)

    {

        int i = e.hashCode() % capacity;

        if(buckets[i] != null)

        {

            for(int j = 0; j < buckets[i].size(); j++)

            {

                if(e.equals(buckets[i].get(j)))

                {

                    buckets[i].remove(e);

                    return true;

                }

            }

        }

        return false;

    }



    @Override

    public boolean contains(E e)

    {

        return get(e) != null;

    }



    @Override

    public E get(E e)

    {

        int i = e.hashCode() % capacity;

        if(buckets[i] != null)

        {

            for(int j = 0; j < buckets[i].size(); j++)                  if(e.equals(buckets[i].get(j))) return buckets[i].get(j);

        }

    }

    return null;





    @Override

    public Iterator<E> iterator()

    {

        List<E> content = new LinkedList <>();

        for (int i = 0; i < capacity; i++) if (buckets[i] != null) content.addAll(buckets[i]);

        return content.iterator();

    }

}