Question

TrackMinMax

i want the generic version based on java

For this lab, you will create a generic version of the IntTrackMinMax class you wrote in a previous lab, called TrackMinMax. The API is:

Function Signature Description

constructor TrackMinMax() constructor

check void check(T i) compares i to the current minimum and maximum values and updates them accordingly

getMin T getMin() returns the minimum value provided to check() so far

getMax T getMax() returns the maximum value provided to check() so far

toString String toString() returns the string "[min,max]"

As before, your getMax() and getMin() functions may assume that check() has been called at least once. If getMin() or getMax() is called before the first call to check(), the results are undefined.

Your code will need to use the compareTo() function, so you need to be sure to limit your type parameter to only types that implement the Comparable<T> interface.

Hints

You can look at my test code by clicking "Current File" above the editing window, and selecting "TestTrackMinMax". All the test program does is read integers from standard input, and calls check() with each one. It then prints out the minimum and maximum integer that was read, and then prints the object itself (which tests toString()). For example, enter this data as the input:

0 5 -5 3 -8

When you run it with that data, it should print

Minimum: -8

Maximum: 5

[-8,5]

For grading, tour code will be tested with both Integer and String as the type parameters. If you want to test with strings in develop mode, you will need to provide the word "String" (without the quotes) as a command line parameter.

Note that because you don't know what the min/max values might be for the generic type parameter, you'll need to find some other way to initialize the min/max variables. Think about the fact that the type parameter must be a reference type, and that reference types are automatically initialized to a certain default value. You can check for that default value in your check() function to determine whether it is the first call to check(), and act accordingly.

Answer 1

TrackMinMax.java (code to copy)

//declare generic classs whose elements are of comparable type
class TrackMinMax<T extends Comparable<T>>{
    //declare member variables to store current min and max
    private T cur_min;
    private T cur_max;
    //this variable tells if the check function has been called once or not
    private static boolean is_checked = false;
    //constructor
    public TrackMinMax(){}
    //this method updates cur_min and cur_max
    public void check(T i){
        //if the method has never been called, directly update min and max values
        if(!is_checked){
            is_checked=true;
            cur_min=i;
            cur_max=i;
        }else{
            //update cur_min
            if(cur_min.compareTo(i)>0){
                cur_min=i;
            }
            //update cur_max
            if(cur_max.compareTo(i)<0){
                cur_max=i;
            }
        }
    }
    //member variable to get cur_min
    public T getMin(){
        return cur_min;
    }
    //member variable to get cur_max
    public T getMax(){
        return cur_max;
    }
    //member variable to print the object
    public String toString(){
        return "["+cur_min+","+cur_max+"]";
    }
}

TrackMinMax.java (code screenshot)

Test.java (code to copy)

import java.util.*;
import java.text.*; 
class Test{
    public static void main(String[] args) throws Exception{
        //create Scanner object to read from the user
        Scanner sc = new Scanner(System.in);
        //read a line
        String input = sc.nextLine();
        //store this line in the scanner so that we can read numbers/string separated by spaces
        sc = new Scanner(input);
        //check if command line argument was provided and the value was String
        if(args.length==1 && args[0].equals("String")){
            //we have to implement string version of the program
            TrackMinMax<String> tmm = new TrackMinMax<String>();
            //variable to store each word
            String val;
            //read until line ends
            while(sc.hasNext()){
                //read next words
                val=sc.next();
                //call check method
                tmm.check(val);
            }
            //print the result in the format given in the problem statement
            System.out.println("Minimum: "+tmm.getMin());
            System.out.println("Maximum: "+tmm.getMax());
            System.out.println(tmm);
        }else{
            //we have to implement integer version of the program
            TrackMinMax<Integer> tmm = new TrackMinMax<Integer>();
            //variable to store each integer
            Integer val;
            //read until line ends
            while(sc.hasNextInt()){
                //read next integer
                val=sc.nextInt();
                //call check method
                tmm.check(val);
            }
            //print the result in the format given in the problem statement
            System.out.println("Minimum: "+tmm.getMin());
            System.out.println("Maximum: "+tmm.getMax());
            System.out.println(tmm);
        }
    }   
}

Test.java (code screenshot)

Sample Input/Output Screenshot 1 when called like - java Test

Sample Input/Output Screenshot 2 when called like - java Test String

Let me know in the comments if you have any doubts.
Do leave a thumbs up if this was helpful.