A Few Functions in a Java's Generic Class

Here are the three functions that I didn't include in my earlier post.  The constructor function is revised, and variable T[] sortedNumArray is added.  All those can be plugged into the GenericNumberStat class.

    T[] numArray;
    T[] sortedNumArray;

    GenericArrayStat (T[] numArray) {
        this.numArray = numArray;
        T[] tmpArray = numArray.clone();
        Arrays.sort (tmpArray);
        this.sortedNumArray = tmpArray;
    }
    
    Double median () {        
        int len = sortedNumArray.length;
        double med;                
        if (len % 2 == 0) {
            double sumOfMidNums = sortedNumArray[len/2].doubleValue() + sortedNumArray[len/2 - 1].doubleValue();        
            med = sumOfMidNums / 2;
        } 
        else {        
            med = sortedNumArray[len/2].doubleValue();
        }        
        return med;        
    }    
    
    T minimum () {                
        return sortedNumArray[0];
    }    
    
    T maximum () {
        int len = sortedNumArray.length;
        return sortedNumArray[len-1];
    }

The class constructor
The design of this constructor function is to take in the original unsorted array, memorize it by variable T[] numArray; also, memorize the sorted array by variable T[] sortedNumArray.  It is convenient to have both the original and sorted sequence handy.  They serve different purposes when more functions need to be added to the Class.  

The median() function
Like the mean() function provided previously, the median() function returns a Double object.  It is reasonable to return a Double object because the calculation is based on the primitive double datatype.  Returning a Double object (instead of a primitive double) is often more convenient due to the functions available in the Double class.

The minimum() and maximum() functions
Unlike the mean() and median() functions, the minimum() and maximum() functions return a generic T object.  This is because the minimum() and maximum() functions do not need to calculate; they simply return the lowest or highest element respectively.

Note that in the class constructor, there is the usage of Arrays.sort(x) function.  Before using the sort function in the Arrays class, import java.util.Arrays; otherwise, the compiler won't recognize it.  According to the official Java Doc, this sort function is implemented based on "a stable, adaptive, iterative mergesort that requires far fewer than n lg (n) comparisons when the input array is partially sorted, while offering the performance of a traditional mergesort when the input array is randomly ordered."

Comments

Post a Comment

Popular posts from this blog

Finding Median by Stream

Image
This small waterfall is one of the many intermediate operations of the stream. Photo taken in Algonquin, ON The Java's DoubleStream class provides a few methods for common statistics including min(), max(), sum(), and average().  For average(), what does it actually mean?  Here is the description in the specification: The average() method returns an OptionalDouble describing the arithmetic mean of elements of the stream, or an empty optional if the stream is empty. While the arithmetic mean method is handy, we likely want a median method for different needs as well.  The DoubleStream class doesn't provide a median() method but the sorted() method.  We can use the sorted() method to assist in finding the median value. Building the Median Function Given each of existing min(), max(), and average() will return an OptionalDouble, having a median() method to return the same type is preferable.  There are different ways to create a median method, and the goal here is ...
Read more

Factorial by Different Styles in Java

Here is a collection of methods of calculating factorial by different programming styles. class Factorial { // Iteration static long iterativeFactorial( int n) { long r = 1; for ( int i=1; i<=n; i++) r*=i; return r; } // Recursion static long recursiveFactorial( int n) { return n == 0 ? 1 : n * recursiveFactorial(n-1); } // Tail-recursion static long tailRecurFactorial( int n) { return tailRecurHelper(1L, n); } static long tailRecurHelper( long acc, int n) { return n == 0 ? acc : tailRecurHelper(acc*n, n-1); } // Lambda and Recursion static Function<Integer, Long> lambdaRecurFactorial = x -> x==0 ? 1L : x * Factorial.lambdaRecurFactorial.apply(x-1); // Stream static long streamFactorial ( int n) { return LongStream.rangeClosed(1, n) .reduce(1, (a, b) -> a*b); } /...
Read more

Reduction by Java Stream

For business analysis, it is often useful to reduce a list of numbers to a single value. "What is the sum of product A sold among all the invoices?" "What is the median price among all the houses sold in Toronto last month?" "What is the average annual inflation over the last 10 years?" This type of queries is reduction operation that can be handled by the Stream class.  Below are some examples to help memorizing how the reduce  method is used. Here are three different functions of calculating the sum of a list of integers. The first function is a typical for-loop.  The second and third produce the same result by using stream's reduce . Compare the functions for mnemonic.  List<Integer> list = Arrays.asList(2, 4, 6, 8, 10, 12, 14, 16); Function<List<Integer>, Integer> sumMethod1 = (numbers) -> { int sum = 0; for (Integer x : numbers) sum += x; return sum; }; System.out.println ( "sum = " + sumMethod1.apply(l...
Read more