• Recall:
  • A Java array has a length attribute so it is not necessary to store the length in another variable (as it is in some other languages)
• An Implication:
  • In Java it is common to pass an array and operate on all of its elements
• A Shortcoming:
  • We often want to operate only on some of the elements

• A Common Problem:
  • Write a method that is passed an array and must calculate the sum of the elements
• A Solution You're Familiar With:
  • Use a for loop (because it's determinate)
  • Use the length attribute

javaexamples/programmingpatterns/subarrays/SubarraysMotivation.java (Fragment: 0)

    /**
     * A "traditional" total() method that is passed an array.
     *
     * @param  data  The data array
     * @return The sum of the elements in the array
     */
    public static int total(int[] data) {
        int result;
        result = 0;

        for (int i = 0; i < data.length; ++i) {
            result += data[i];
        }
        return result;
    }
        

• A Shortcoming of this Solution:
  • It does not allow you to find the sum of a subset of the elements
• For Example:
  • A quarterly sales report generated from monthly data for the entire year

• What's Needed:
  • Method parameters that describe the subset of interest
• Possible Approaches:
  • An int[] containing the indexes to use
  • A conformal boolean[]
  • A conformal indicator (i.e., 0-1) array
• The Most Common Problems:
  • The subset is contiguous so both of these approaches are more complicated than necessary

javaexamples/programmingpatterns/subarrays/Subarrays_IndexArray.java (Fragment: 1)

    /**
     * A more flexible total() method that potentially operates
     * on only a part of the array.
     *
     * @param  data    The data array
     * @param  indexes The indexes to operate on
     * @return The sum of the specified elements in the array
     */
    public static double total(double[] data, int[] indexes) {
        double result;

        result = 0;        
        for (int i = 0; i < indexes.length; ++i) {
            result += data[indexes[i]];
        }
        return result;
    }
        

javaexamples/programmingpatterns/subarrays/Subarrays_IndexArray.java (Fragment: 0)

    /**
     * An overloaded total() method that is passed an array.
     *
     * @param  data  The data array
     * @return The sum of the elements in the array
     */
    public static double total(double[] data) {
        int[] indexes = new int[data.length];
        for (int i=0; i<indexes.length; ++i) indexes[i] = i;
        return total(data, indexes);
    }
        

javaexamples/programmingpatterns/subarrays/Subarrays_BooleanArray.java (Fragment: 1)

    /**
     * A more flexible total() method that potentially operates
     * on only a part of the array.
     *
     * @param  data The data array
     * @param  use  A conformal array of boolean value
     * @return The sum of the specified elements in the array
     */
    public static double total(double[] data, boolean[] use) {
        double result;

        result = 0;        
        for (int i = 0; i < data.length; ++i) {
            if (use[i]) result += data[i];
        }
        return result;
    }
        

javaexamples/programmingpatterns/subarrays/Subarrays_BooleanArray.java (Fragment: 0)

    /**
     * An overloaded total() method that is passed an array.
     *
     * @param  data  The data array
     * @return The sum of the elements in the array
     */
    public static double total(double[] data) {
        boolean[] use = new boolean[data.length];
        Arrays.fill(use, true);
        return total(data, use);
    }
        

javaexamples/programmingpatterns/subarrays/Subarrays_IndicatorArray.java (Fragment: 1)

    /**
     * A more flexible total() method that potentially operates
     * on only a part of the array.
     *
     * @param  data The   data array
     * @param  indicator  A conformal indicator array of 0-1 values
     * @return The sum of the specified elements in the array
     */
    public static double total(double[] data, int[] indicator) {
        double result;

        result = 0;        
        for (int i = 0; i < data.length; ++i) {
            result += indicator[i] * data[i];
        }
        return result;
    }
        

javaexamples/programmingpatterns/subarrays/Subarrays_IndicatorArray.java (Fragment: 0)

    /**
     * An overloaded total() method that is passed an array.
     *
     * @param  data  The data array
     * @return The sum of the elements in the array
     */
    public static double total(double[] data) {
        int[] indicator = new int[data.length];
        Arrays.fill(indicator, 1);
        return total(data, indicator);
    }
        

• The Idea:
  • Add two int parameters, the index to start with and the size of the subset
  • Include an overloaded convenience method with the original parameters
• Terminology:
  • The index to start with is called the offset (from 0)
  • The size of the subset is called the length

javaexamples/programmingpatterns/subarrays/Subarrays.java (Fragment: 1)

    /**
     * A more flexible total() method that potentially operates
     * on only a part of the array.
     *
     * @param  data    The data array
     * @param  offset  The first element to operate on
     * @param  length  The number of elements to operate on
     * @return The sum of the elements in the array
     */
    public static double total(double[] data, int offset, int length) {
        double result;

        result = 0;        
        for (int i = offset; i < offset + length; ++i) {
            result += data[i];
        }
        return result;
    }
        

javaexamples/programmingpatterns/subarrays/Subarrays.java (Fragment: 0)

    /**
     * An overloaded total() method that is passed an array.
     *
     * @param  data  The data array
     * @return The sum of the elements in the array
     */
    public static double total(double[] data) {
        return total(data, 0, data.length);
    }
        

• Recall:
  • Arrays are reference types in Java so a method can change the elements of an array it is passed
• Using the Subarray Pattern:
  • A method can change some or all of the elements of an array
• A Related Programming Pattern:
  • Outbound Parameters

• The Arrays Class:
  • The sorting and searching methods
  • the fill() methods
  • The copyOfRange() method
• The System Class:
  • The arraycopy() method

• Recall:
  • Java doesn't really have multi-dimensional arrays (as some languages do) it has arrays of arrays
• A Special Case:
  • When the arrays that are elements are all the same size (i.e., the array of arrays is rectangular)

javaexamples/programmingpatterns/subarrays/Subarrays.java (Fragment: 3)

    /**
     * A more flexible total() method that is passed a
     * rectangular array of arrays.
     *
     * @param  data  The data array
     * @param  roffset   The first row to operate on
     * @param  coffset   The first column to operate on
     * @param  rlength   The number of rows to operate on
     * @param  clength   The number of columns to operate on
     * @return The sum of the elements in the array
     */
    public static double total(double[][] data, 
                               int roffset, int coffset, 
                               int rlength, int clength) {
        double result;
        
        result = 0;        
        for (int r = roffset; r < roffset + rlength; ++r) {
            for (int c = coffset; c < coffset + clength; ++c) {
                result += data[r][c];
            }
        }
        return result;
    }
        

javaexamples/programmingpatterns/subarrays/Subarrays.java (Fragment: 2)

    /**
     * An overloaded total() method that is passed a rectangular 
     * array of arrays.
     *
     * @param  data  The data array
     * @return The sum of the elements in the array
     */
    public static double total(double[][] data) {
        return total(data, 0, 0, data.length, data[0].length);
    }