import java.util.ArrayList;

/**
 * Set-Variante B
 * 
 * @author Rainer Helfrich
 * @version 26.9.2020
 */
public class SetVarianteB extends Set
{
    private ArrayList<Integer> daten;

    /**
     * Erzeugt ein neues leeres Set
     */
    public SetVarianteB()
    {
        daten = new ArrayList<Integer>();
    }

    /**
     * Gibt zurück, ob die Menge kein Element enthält
     * @return true, wenn die Menge leer ist; false sonst
     */
    public boolean istLeer()
    {
        return daten.isEmpty();
    }

    /**
     * Gibt die Mächtigkeit der Menge zurück
     * @return Die Anzahl der Elemente in der Menge
     */
    public int anzahl()
    {
        return daten.size();
    }

    /**
     * Bestimmt die Differenzmenge der Menge selbst und der Menge s.
     * @param s Die Menge, die von dieser Menge abgezogen werden soll.
     * @return Ein neues Set, das alle Elemente dieser Menge enthält, die nicht in s enthalten sind.
     */
    public Set differenz(Set s)
    {
        Set ergebnis = new SetVarianteB();
        for(int v : daten)
        {
            if (!s.enthaelt(v))
            {
                ergebnis.einfuegen(v);
            }
        }
        return ergebnis;
    }

    /**
     * Gibt zurück, ob diese Menge eine Untermenge der Menge s ist.
     * @param s Die Menge, die geprüft werden soll.
     * @return true, wenn jedes Element dieser Menge in s enthalten ist; false sonst
     */
    public boolean untermenge(Set s)
    {
        for (int v : daten)
        {
            if (!s.enthaelt(v))
            {
                return false;
            }
        }
        return true;
    }

    /**
     * Bestimmt die Vereinigungsmenge der Menge selbst und der Menge s.
     * @param s Die Menge, mit der die Vereinigungsmenge bestimmt werden soll
     * @return Ein neues Set, das die Vereinigungsmenge der beiden Mengen repräsentiert.
     */
    public Set vereinigungsmenge(Set s)
    {
        Set ergebnis = new SetVarianteB();
        for (int v : daten)
        {
            ergebnis.einfuegen(v);
        }
        for (int v : s.alsArray())
        {
            ergebnis.einfuegen(v);
        }
        return ergebnis;
    }

    protected int[] alsArray()
    {
        int[] ergebnis = new int[anzahl()];
        for (int i = 0; i < anzahl(); i++)
        {
            ergebnis[i] = daten.get(i);
        }
        return ergebnis;
    }

    /**
     * Bestimmt die Schnittmenge der Menge selbst und der Menge s.
     * @param s Die Menge, mit der die Schnittmenge bestimmt werden soll
     * @return Ein neues Set, das die Schnittmenge der beiden Mengen repräsentiert.
     */
    public Set schnittmenge(Set s)
    {
        Set ergebnis = new SetVarianteB();
        for (int v : daten)
        {
            if (s.enthaelt(v))
            {
                ergebnis.einfuegen(v);
            }
        }
        return ergebnis;
    }

    /**
     * Gibt zurück, ob ein bestimmter Wert in der Menge enthalten ist.
     * @param wert Der zu suchende Wert
     */
    public boolean enthaelt(int x)
    {
        return daten.contains(x);
    }

    /**
     * Entfernt einen Wert aus der Menge, falls er enthalten ist.
     * @param wert Der zu entfernende Wert
     */
    public void entfernen(int wert)
    {
        daten.remove(new Integer(wert));
    }

    /**
     * Fügt einen neuen Wert in die Menge ein, falls er nicht bereits enthalten ist.
     * @param wert Der einzufügende Wert
     */
    public void einfuegen(int wert)
    {
        if (!daten.contains(wert))
        {
            daten.add(wert);
        }
    }

}
