Keskustelu: Ohjelmointikysymykset: Java Collction ja Iterator rajapintojen toteutus

import java.util.*;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;


public class Taulukko<TYPE> implements Collection<TYPE> {


    public int alkuperainenKoko;
    public TYPE alkiot[];
    public int alkioita = 0;
    public int it = -1;



    private void kasvataTaulukko() {
        TYPE[] tmp = (TYPE[]) new Alkio[alkiot.length + 5];
        System.arraycopy(alkiot, 0, tmp, 0, alkiot.length);
        alkiot = tmp;
    }




    public int size() {
        return alkioita;
    }

    public boolean isEmpty() {
        return alkioita == 0;
    }

    public boolean contains(Object o) {
        for(Iterator<TYPE> i = iterator(); i.hasNext();)
        if(i.next() == o) return true;
        return false;
    }


    public Iterator<TYPE> iterator() {
        return new Iteraattori<TYPE>();
    }


    public Object[] toArray(TYPE elements) {
        Set set = new HashSet(Arrays.asList(elements));
        Object[] strObj = new Object[set.size()];
        strObj = (Object[]) set.toArray(strObj);
        return strObj;
    }

    public <T> T[] toArray(T[] a) {
        throw new UnsupportedOperationException("Not supported yet.");

}



    public boolean add(TYPE e) {
        for (int i = 0; i < alkiot.length; i++) {
	      if (alkiot[i] == null) {
	        alkiot[i] = e;
	        alkioita++;
	        return true;
        }
	    }
    kasvataTaulukko();
    return add(e);
    }




    public boolean remove(Object o) {
        for(Iterator<TYPE> i = this.iterator(); i.hasNext();) {
 	      if((Alkio) i.next() == o) {
 	        i.remove();
 	        return true;
 	      }
 	    }
 	    return false;

    }


    public boolean containsAll(Collection<?> c) {
        for(Iterator<TYPE> i = (Iterator<TYPE>) c.iterator(); i.hasNext();)
            if(!contains(i.next())) return false;
            return true;
    }

    public boolean addAll(Collection<? extends TYPE> c) {
        throw new UnsupportedOperationException("Not supported yet.");
    }


    public boolean removeAll(Collection<?> c) {
        boolean virheita = false;
 	    for(Iterator<TYPE> i = (Iterator<TYPE>) c.iterator(); i.hasNext();)
 	      if(!remove(i.next())) virheita = true;
 	    return !virheita;
    }


    public boolean retainAll(Collection<?> c) {
        throw new UnsupportedOperationException("Not supported yet.");
    }


    public void clear() {
        alkiot = (TYPE[]) new Alkio[alkuperainenKoko];
        alkioita = 0;
    }

    public Object[] toArray() {
        throw new UnsupportedOperationException("Not supported yet.");
    }


    public class Iteraattori<TYPE> implements Iterator<TYPE>{

    public boolean hasNext() {
          if(it < alkioita) return true;
 	      return false;
    }

    public TYPE next() {
        return (TYPE) alkiot[++it];
    }

    public void remove() {
         alkiot[it] = alkiot[--alkioita];
 	alkiot[alkioita] = null;
    }
    }
}