import java.util.List;
import java.util.Vector;
import java.util.ArrayList;
import java.util.Collections;

public class GenericMethodsExercises{

    /* Generic Methods
       2. Convert the following method to be a generic method:
    */

    /**
     * Swap the elements at two indices
     * <p>Note: Does not check if the indices are valid</p>
     * @param array The array
     * @param index1 The index of one of the elements to swap
     * @param index2 The index of other element to swap
     */
    public static void swap2Original( Integer[] array, Integer index1, Integer index2 ){
        Integer temp = array[index1];
        array[ index1 ] = array[ index2 ];
        array[ index2 ] = temp;
    }
    /**
     * Swap the elements at two indices
     * <p>Note: Does not check if the indices are valid</p>
     * @param array The array
     * @param index1 The index of one of the elements to swap
     * @param index2 The index of other element to swap
     */
    public static <E> void swap2( E[] array, int index1, int index2 ){
        E temp = array[index1];
        array[ index1 ] = array[ index2 ];
        array[ index2 ] = temp;
    }


    /* Generic Methods
       3. Does the following method compile? If not, why?
    */

    /**	    
     * Display all of the numbers (whole or real) in a list on one line
     * @param lst A list of Numbers
     */
    public <T extends Number> void printList(List<T> lst) {
        System.out.println( "printList( + "+lst+" )");
        for( Number n : lst )
            System.out.print(n + " ");
        System.out.println();
    }

    /* Generic Methods
       4. Write a generic method to match the following Javadoc. Additionally,
       add code to main() to call the method twice (each with a different type).
    */

    /**
     * Finds the minimum value in a list between two indices
     * <p>Note: Does not check if the indices are valid</p>
     * @param lst The list object
     * @param startIndex The index to start looking at
     * @param endIndex The last index to consider
     * @return The smallest value in lst between startIndex and endIndex (inclusive) 
     */
    public static <T extends Comparable<T>> T minT(List<T> lst, int startIndex, int endIndex){
        // use the first element in the specified range as the first minimum value
        T min = lst.get( startIndex );
        for(int i = startIndex; i <= endIndex; ++i){
            //min = Math.min(min, lst.get(i));
            if( min.compareTo( lst.get(i) ) > 0 ){
                // found a new minimum
                min = lst.get(i);
            }
        }
        return min;
    }

    public static void main( String[] args ){

        /* Vector
           2. Declare a Vector object that stores the vowels in the English
           alphabet ('a', 'e', 'i', 'o', 'u' and 'y'). Display each of it's
           elements on a separate line.
        */
        Vector< Character > vowels = new Vector< Character >();
        vowels.add( 'a' );
        vowels.add( 'e' );
        vowels.add( 'i' );
        vowels.add( 'o' );
        vowels.add( 'u' );
        vowels.add( 'y' );

        for( Character ch : vowels ){
            System.out.println( ch );
        }

        /* Generic Methods
           2. Convert the following method to be a generic method:
        */
        Integer[] nums = {1, 2, 3};
        Character[] hello = {'h', 'e', 'l', 'l', 'o'};

        for( int i : nums ){
            System.out.print( i );
        }
        System.out.println("\n");

        swap2( nums, 1, 2 );
        for( int i : nums ){
            System.out.print( i );
        }
        System.out.println("\n");

        for( Character c : hello ){
            System.out.print( c );
        }
        System.out.println("\n");

        swap2( hello, 4, 3 );
        for( Character c : hello ){
            System.out.print( c );
        }
        System.out.println("\n");


        /* Generic Methods
           4. Additionally, add code to main() to call the method twice (each with a different type).
         */
        System.out.println("minT( vowels, 1, 5)" );
        System.out.println( minT( vowels, 1, 5) );

        ArrayList< Integer > primesList = new ArrayList< Integer >();
        primesList.add( 2 );
        primesList.add( 3 );
        primesList.add( 5 );
        primesList.add( 7 );
        primesList.add( 11 );
        primesList.add( 13 );
        primesList.add( 17 );

        Collections.shuffle(primesList);

        System.out.println("minT( " + primesList + ", 0, primesList.size() - 1)" );
        System.out.println( minT( primesList, 0, primesList.size() - 1) );
    }
}