Question

Lab #4 – Recursive Methods for Generic ArrayList ----- JAVA

0. The problem

   Use recursion to implement some list functionalities on an ArrrayList of generic type using type parameters in method definition

   Our goal for this lab is to continue using the divide and conquer approach of splitting a list into its head and tail and keep recursing on the tail (which happens to be smaller). However, instead of trying the approach on a string (a list of characters) we would like to use an ArrayList of an arbitrary type of list element, parameterized by E. We can still use the same design outline as the previous lab exercise (Lab 3).

   Note the following prototype declaration for the ArrayList class:

        public class ArrayList<E>
        extends AbstractList<E>
        implements List<E>, ......
   

   Perform the following tasks in a class called ListRecursive

   Task #1 Develop a recursive method to reverse a list

   Develop a method with the prototype

          public static <E> void reverse (ArrayList<E> inputList)
   

   based on selecting the first list element as the head and the remaining list as its tail. Here is

   1. 1) Base case: The problem is trivial when the list size is 0 or 1.

   2. 2) Decomposition: For lists with size > 1:

      1. a) Extract its head (element) and leave the tail (the input list with the head removed). You can look up the method that does this for the List interface.

      2. b) Make a recursive call to obtain the tail reversed.

Page 1 of 3

3) Composition: Append the extracted head element to the reversed tail obtain the original list reversed.

Task #2 Develop a recursive method to find the maximal element

Note that this is not possible unless the list elements are comparable to each other. Java provides a generic Interface for this called Comparable<T>. Based on this, develop a method with the following prototype

public static <E extends Comparable<E>> E max(List<E> inputList)

You can use the same problem decomposition technique as in Task #1. Think about how the composition of result should be made.

Task #3 Develop a recursive method to sum the list elements

Obviously, this is not possible unless the list elements are of numeric type. Develop a recursive summing method with the prototype

public static <E extends Number> double sum (List<E> inputList)

Task #4 Use command line arguments to supply the list elements

Use the following main() method:

      public static void main(String args[]) {
          ArrayList<String> argList = new ArrayList<>();
          ArrayList<Double> numericArgs = new ArrayList<>();
          for (String s : args) {

             argList.add(s);
             try {

                numericArgs.add(Double.parseDouble(s));
             }

             catch (NumberFormatException e) {
                System.out.println(e.getMessage() + "is not

   numeric...skipping");
             }

}

          System.out.print("Command line arguments before
   reversal: ");

          for (int i=0; i<argList.size(); i++)
             System.out.print(argList.get(i)+ " ");

          System.out.println();

          reverse(argList);

          System.out.print("Command line arguments after
   reversal: ");

Page 2 of 3

for (int i=0; i<argList.size(); i++)
             System.out.print(argList.get(i)+ " ");

          System.out.println();

          System.out.println("Max of argument list is \"" +
   max(argList) + "\"");

          System.out.println("Sum of numeric arguments is \"" +
   sum(numericArgs) + "\"");

}

You should test your program with different command-line inputs and observe the results of passing different combinations of numeric and non-numeric values.

Answer 1

Java program to reverse an Array List using Recursion

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

    public class recurse{

             private static List<String> l = new ArrayList<String>();

              private static List<String> reversedSet = new ArrayList<String>();

     public static void main(String[] args){

           List l=new ArrayList();

           System.out.println("Enter array values");                        //Input array values

           String a=input.nextLine();

               l.add(a);                                   //elements added to array list

               reverse( l );                         //recursive call to reverse the array list

               printList( reversedSet );            //function call to print the reversed array

        }

public static void reverse( List<String> listinp ) {  

       String firstele = null;

       if ( listinp.size() == 0 ) {                                 //If size of input array is 0 then no input

                  return;

       }

       else {

            firstele = listinp.get(0);                                         //first element of array list taken

            listinp.remove(0);                                            

        }

   reverseList( listinp );

   reversedSet.add( firstele );

   }

public static void printList( List<String> listinp ) {

    Iterator<String> listIterator = listinp.iterator();

    while( listIterator.hasNext() ) {

               String element = listIterator.next();

               System.out.println( element );                       //Reversed elements are printed

     }

}

}