Java Program to Implement LinkedHashSet API

// Java program to implement LinkedHashSet API

import java.util.*;

class LinkedHashSetImplementation<E> {
    private LinkedHashSet<E> set;

    // Constructor creates a new LinkedHashSet
    public LinkedHashSetImplementation()
    {
        set = new LinkedHashSet<E>();
    }

    // Constructor creates a new empty linkedhash set
    // according to the given set
    public LinkedHashSetImplementation(
        Collection<? extends E> set1)
    {
        set = new LinkedHashSet<E>(set1);
    }

    // Returns the size of the set
    public int size() { return set.size(); }

    // Returns true if set is empty otherwise return false
    public boolean isEmpty() { return set.isEmpty(); }

    // Returns true if set contains specified value
    public boolean contains(Object val)
    {
        return set.contains(val);
    }

    // Returns an iterator over set elements
    public Iterator<E> iterator() { return set.iterator(); }

    // Returns an array containing all of the elements of
    // the set
    public Object[] toArray() { return set.toArray(); }

    // Returns an array containing all of the elements of
    // the set
    public <T> T[] toArray(T[] a) { return set.toArray(a); }

    // Add element to the set
    public boolean add(E ele) { return set.add(ele); }

    // Removes the specified element from the set if it is
    // present
    public boolean remove(Object ele)
    {
        return set.remove(ele);
    }

    // Returns true if the set contains all of the elements
    // of the specified collection
    public boolean containsAll(Collection<?> c)
    {
        return set.containsAll(c);
    }

    // Adds all of the elements in the specified collection
    // to the set
    public boolean addAll(Collection<? extends E> col)
    {
        return set.addAll(col);
    }

    // Retains only the elements in this set that are
    // contained in the specified collection
    public boolean retainAll(Collection<?> col)
    {
        return set.retainAll(col);
    }

    // Removes from this set all of its elements that are
    // contained in the given collection
    public boolean removeAll(Collection<?> col)
    {
        return set.retainAll(col);
    }

    // Removes all of the elements from the set
    public void clear() { set.clear(); }

    // Compares the specified object with the set
    public boolean equals(Object obj)
    {
        return set.equals(obj);
    }

    // Returns the hash code value for the set
    public int hashCode() { return set.hashCode(); }
}
public class GFG {
    public static void main(String[] arg)
    {
        LinkedHashSetImplementation<Integer> set
            = new LinkedHashSetImplementation<>();

        // Add elements to set
        set.add(10);
        set.add(20);
        set.add(30);
        set.add(40);
        set.add(50);
        set.add(30);
        set.add(40);

        // Print the size of the set
        System.out.println("Size of the LinkedHashset: "
                           + set.size());

        // Iterate set elements
        System.out.println(
            "The LinkedHashSet elements are:");

        Iterator it = set.iterator();

        while (it.hasNext()) {
            // print set data
            System.out.println(it.next());
        }

        // Check whether set is empty or not
        System.out.println("The linkedHashSet is empty: "
                           + set.isEmpty());

        // Print true if set contains 60 else print false
        System.out.println("LinkedHashSet contains 60: "
                           + set.contains(60));

        // Print true if set contains 40 else print false
        System.out.println("LinkedHashSet contains 40: "
                           + set.contains(40));

        // Remove element from Set
        set.remove(40);

        // print size
        System.out.println("Size of the linkedHashSet:"
                           + set.size());

        // Delete all the elements of the set
        set.clear();

        System.out.println("Size of the set after clear:"
                           + set.size());
    }
}