Tibinek

DuplazoSor.java

package adatszerk.duplazo;

import java.util.*;
//import adatszerk.duplazo.exception.*;˚
/**
 * Az adatszerkezet egy sort abrazol
 * ...
 * (lasd setMaxDupla metodus) ... A DuplazoSor innentől csak összehasonlító művelettel rendelkező típusokra működjön,
 * azaz a paraméterezése legyen DuplazoSor<T extends Comparable<T>>.
 * ...
 * Az adatszerkezet valósítsa meg a Queue<T> interfészt. Ehhez 18 műveletet kell implementálni, amelyek többsége egyszerű;
 * a legbonyolultabb az iterator(), mert annak a visszatérési értéke egy olyan iterátor példány, amelynek a prioritásos
 * elemet (ha van) első elemként kell érintenie.
 * @param <T>
 */
public class DuplazoSor<T extends Comparable<T>> implements Queue<T> {
    private List<T> lista;
    private T duplaElem;

    /**
     * Az adatszerkezetnek legyen egy paraméter nélküli konstruktora (ekkor a lista mező kezdetben legyen üres),
     */
    public DuplazoSor(){
        lista = new ArrayList<T>();
        duplaElem = null;
    }

    /**
     * valamint egy olyan konstruktora, amely egy listát vesz át (ekkor a lista mező ezekkel az értékekkel töltődjön fel,
     * az enkapszuláció megtartásával).
     * @param kezdoLista
     */
    public DuplazoSor(List<T> kezdoLista) {
        this();
        lista.addAll(kezdoLista);
    }

    @Override
    public int size() {
        return 0;
    }

    @Override
    public boolean isEmpty() {
        return false;
    }

    @Override
    public boolean contains(Object o) {
        return false;
    }

    @Override
    public Iterator<T> iterator() {
        return null;
    }

    @Override
    public Object[] toArray() {
        return new Object[0];
    }

    @Override
    public <T1> T1[] toArray(T1[] a) {
        return null;
    }

    /**
     * Egy T tipusu elemet tesz a lista vegere
     * @param elem
     */
    public boolean add(T elem) {

    }

    @Override
    public boolean remove(Object o) {
        return false;
    }

    @Override
    public boolean containsAll(Collection<?> c) {
        return false;
    }

    @Override
    public boolean addAll(Collection<? extends T> c) {
        return false;
    }

    @Override
    public boolean removeAll(Collection<?> c) {
        return false;
    }

    @Override
    public boolean retainAll(Collection<?> c) {
        return false;
    }

    @Override
    public void clear() {

    }

    @Override
    public boolean offer(T t) {
        return false;
    }

    /**
     * Leveszi a legelso lista elemet es visszaadja
     * @return a lista legelso eleme
     */
    public T remove() {
        T ret;
        /// Azonban, ha a duplaElem mező nem null,
        if (duplaElem != null) {
            /// akkor a remove ezt az elemet adja vissza,
            ret = duplaElem;
            /// és null-ra állítja a mező értékét.
            duplaElem = null;
        }
        if (lista.size() == 0) {
            // throws UresSorException; /// Ezt az adatszerk.duplazo.exception package-be kell rakni!
        }
    }

    @Override
    public T poll() {
        return null;
    }

    @Override
    public T element() {
        return null;
    }

    @Override
    public T peek() {
        return null;
    }

    /**
     * Az adatszerkezetnek legyen egy setDuplaElem művelete, amely egy egész számot vár. Ha ez érvényes indexe a lista
     * mezőnek, akkor a duplaElem legyen a lista megfelelő eleme, különben a művelet váltson ki ErvenytelenIndexException
     * kivételt. Ez tartalmazza az indexet az idx adattagjában.
     *
     * @param idx
     */
    public void setDuplaElem(int idx) {

    }

    /**
     * Legyen egysetMaxDupla művelet, amely a duplaElem mezőt a lista-ban található legnagyobb elemmel tölti ki.
     */
    public void setMaxDupla() {}
}