# Vector.java auf generische Datentypen umschreiben



## Guadrion (9. Januar 2008)

```
/**
 * Implementation of a vector of elements based on an array buffer.
 * It provides methods for dynamically adding and removing elements,
 * and is capable of fast random access. Additionally, it provides
 * an iterator to traverse through its elements.
 *
 * @author  (Ihr Name)
 * @version (eine Versionsnummer oder ein Datum)
 */
public class Vector <T>
{
    /**
     * The array buffer into which the elements of the vector are stored.
     * The capacity of the vector is the length of this array buffer.
     */
    private T[] elements;

    /**
     * The size of the vector (the number of elements it contains).
     */
    private int size;

    /**
     * Constructs an empty vector with an initial capacity of 10.
     */
    public Vector T()
    {
        this( 10 );
    }

    /**
     * Constructs an empty vector with the specified initial capacity.
     *
     * @param   capacity the initial capacity of the vector
     * @throws  IllegalArgumentException if the specified initial capacity
     *          is negative
     */
    public Vector( int capacity )
    {
        if ( capacity >= 0 )
        {
            elements = new T[ capacity ];

            size = 0;
        }
    }

    /**
     * Appends the specified element to the end of this vector.
     * If the array has to be enlarged, then its capacity is increased by 10.
     *
     * @param   element element to be appended to this vector
     */
    public void add( int element )
    {
        ++size;

        if ( size > elements.length )
        {
            elements = java.util.Arrays.copyOf( elements, elements.length + 10 );
        }

        elements[ size - 1 ] = element;
    }

    /**
     * Inserts the specified element at the specified position in this
     * vector. Shifts the element currently at that position (if any) and
     * any subsequent elements to the right (adds one to their indices).
     * If the array has to be enlarged, then its capacity is increased by 10.
     *
     * @param   index index at which the specified element is to be inserted
     * @param   element element to be inserted
     * @throws  IllegalIndexException if the index is out of range
     *          ({@code index < 0 || index > size()})
     */
    public void add( int index, int element )
    {
        if ( index >= 0 && index <= size )
        {
            ++size;

            if ( size > elements.length )
            {
                elements = java.util.Arrays.copyOf( elements, elements.length + 10 );
            }

            for ( int i = size - 1; i > index; --i )
            {
                elements[ i ] = elements[ i - 1 ];
            }

            elements[ index ] = element;
        }
    }

    /**
     * Returns the capacity of this vector.
     *
     * @return  the capacity of this vector
     */
    public int capacity()
    {
        return elements.length;
    }

    /**
     * Removes all of the elements from this vector. The vector will
     * have a capacity of 10 elements after this method returns.
     */
    public void clear()
    {
        elements = new int[ 10 ];

        size = 0;
    }

    /**
     * Returns <tt>true</tt> if this vector contains the specified element.
     *
     * @param   element element whose presence in this vector is to be tested
     * @return  <tt>true</tt> if this vector contains the specified element
     */
    public boolean contains( int element )
    {
        return indexOf( element ) >= 0;
    }

    /**
     * Increases the capacity of this vector instance, if necessary,
     * to ensure that it can hold at least the number of elements
     * specified by the capacity argument. If the new capacity is smaller
     * than the actual length of the underlying array, then the array is
     * left unchanged.
     *
     * @param   capacity   the desired minimum capacity
     */
    public void ensureCapacity( int capacity )
    {
        if ( capacity > elements.length )
        {
            elements = java.util.Arrays.copyOf( elements, capacity );
        }
    }

    /**
     * Returns the element at the specified position in this vector.
     *
     * @param   index index of the element to return
     * @return  element at the specified index
     * @throws  IllegalIndexException if the index is out of range
     *          ({@code index < 0 || index >= size()})
     */
    public int get( int index )
    {
        if ( index >= 0 && index < size )
        {
            return elements[ index ];
        }

        return 0;
    }

    /**
     * Returns the index of the first occurrence of the specified element
     * in this vector, or throws an ElementNotFound exception if this vector
     * does not contain the element.
     *
     * @param   element element whose index is to be obtained
     * @return  the index of the first occurrence of the specified element
     *          in this vector
     * @throws  ElementNotFoundException if the vector does not contain the element
     */
    public int indexOf( int element )
    {
        for ( int i = 0; i < elements.length; ++i )
        {
            if ( element == elements[ i ] )
            {
                return i;
            }
        }

        return -1;
    }

    /**
     * Returns <tt>true</tt> if this vector contains no elements.
     *
     * @return  <tt>true</tt> if this vector contains no elements
     */
    public boolean isEmpty()
    {
        return size == 0;
    }

    /**
     * Returns an iterator to traverse this vector.
     *
     * @return  an iterator to traverse this vector
     */
    public Iterator iterator()
    {
        return new Iterator();
    }

    /**
     * Removes the element at the specified position in this vector.
     * Shifts any subsequent elements to the left (subtracts one from their
     * indices).
     *
     * @param   index the index of the element to be removed
     * @return  the element that was removed from the vector
     * @throws  IllegalIndexException if the index is out of range
     *          ({@code index < 0 || index >= size()})
     */
    public int remove( int index )
    {
        if ( index >= 0 && index < size )
        {
            int element = elements[ index ];

            for ( int i = index; i < size - 1; ++i )
            {
                elements[ i ] = elements[ i + 1 ];
            }

            --size;

            return element;
        }

        return 0;
    }

    /**
     * Replaces the element at the specified position in this vector with
     * the specified element.
     *
     * @param   index index of the element to replace
     * @param   element element to be stored at the specified position
     * @return  the element previously at the specified position
     * @throws  IllegalIndexException if the index is out of range
     *          ({@code index < 0 || index >= size()})
     */
    public int set( int index, int element )
    {
        if ( index >= 0 && index < size )
        {
            int previousElement = elements[ index ];

            elements[ index ] = element;

            return previousElement;
        }

        return 0;
    }

    /**
     * Returns the number of elements in this vector.
     *
     * @return  the number of elements in this vector
     */
    public int size()
    {
        return size;
    }

    /**
     * Returns a string representation of this vector. The string
     * representation consists of a list of the vector's elements
     * in the order they are returned by its iterator, enclosed in
     * square brackets (<tt>"Vector[]"</tt>). Adjacent elements
     * are separated by comma. Elements are converted to strings
     * as by {@link String#valueOf(Object)}.
     *
     * @return a string representation of this vector
     */
    public String toString()
    {
        Iterator i = iterator();

        StringBuilder sb = new StringBuilder();

        sb.append( "Vector[" );

        while ( i.hasNext() )
        {
            sb.append( i.next() );

            if ( i.hasNext() )
            {
                sb.append( ',' );
            }
        }

        return sb.append(']').toString();
    }

    /**
     * Trims the capacity of this vector instance to be the vector's
     * current size. An application can use this operation to minimize
     * the storage of an vector instance.
     */
    public void trimToSize()
    {
        if ( size < elements.length )
        {
            elements = java.util.Arrays.copyOf( elements, size );
        }
    }

    /**
     * An iterator to traverse this vector.
     *
     * @author  (Ihr Name)
     * @version (eine Versionsnummer oder ein Datum)
     */
    public class Iterator
    {
        /**
         * The index of the iterator in the vector.
         */
        private int index;

        /**
         * Constructs an iterator positioned before the first element.
         */
        public Iterator()
        {
            index = -1;
        }

        /**
         * Checks, whether this iterator has a further element or not.
         *
         * @return true, if there is another element retrievable by <tt>next()</tt>
         */
        public boolean hasNext()
        {
            return index < size - 1;
        }

        /**
         * Returns the next element of this vector.
         *
         * @return the next element of this vector
         */
        public int next()
        {
            ++index;

            return elements[ index ];
        }
    }
}
```

Hi und zwar sollen wir dies so umschreiben, dass die Klasse generische Datentypen verarbeiten kann!
Irgendwie kommt bei mir aber immer der Fehler generic array creation


----------



## zeja (9. Januar 2008)

Ja, da in Java der Generische Typ zur Laufzeit nicht bekannt ist kann man damit auch kein Array anlegen.

Abgesehen davon müsste es aber auch:

```
private T[] elements;
```
heissen.

Du musst dann wohl ein Array von Object nehmen.


----------



## Guadrion (10. Januar 2008)

und wie? sry aber bin neuling!


----------



## zerix (10. Januar 2008)

Hallo,

wenn ich dir einen Rat geben darf, wenn du mit dem Anlegen von einem Object-Array überfordert bist, dann solltest du nicht versuchen den Vector generisch zu machen, sondern erstemal dir die Grundlagen anschauen.

MFG

zEriX


----------



## Guadrion (10. Januar 2008)

ist leider hausaufgabe


----------



## Guadrion (10. Januar 2008)

sollen das halt auf generische Typen umschreiben! also muss es ja irgendwie möglich sein oder?


----------



## zerix (10. Januar 2008)

Hast du die Aufgabe irgendwie schriftlich? Falls ja, kannst du sie bitte mal posten?

MFG

zEriX


----------



## Anime-Otaku (10. Januar 2008)

Was meinst du mit generischen Typen? Generics benutzen?...also so wie es schon ist (ab Java 5) oder wie man es aus Java 1.4 kennt mit dem generischen Object Datentyp?


----------



## Guadrion (10. Januar 2008)

Reimplementiert die Klasse Vector mittels generischer Typparameter für die Speicherung
beliebiger Datentypen. Verwendet als Ausgangspunkt die gegebene Datei Vector.java.


----------



## zerix (10. Januar 2008)

Also für mich klingt das wie die Änderung von Java 1.4 auf Java 5.0. Also das was die Klasse Vector schon von Haus aus kann seit Java 5.0.

MFG

zEriX


----------

