• Obvious Reasons to Use Arrays:
  • They make it easy to have fixed-size "collections" of homogeneous elements
  • They make it easy to perform the same operation(s) on each element
• A Less Obvious Reason to Use Arrays:
  • In some situations, they make it easy to "look up" information

• Two Systems:
  • In the old system, highway exit numbers were consecutive integers (e.g., 1, 2, ...)
  • In the new system, highway exit numbers are based on mileage markers
• The Problem:
  • Find the new exit number corresponding to an old exit number

1. Create an array in which the indexes correspond to the key that will be used to perform the look-up, and the elements correspond to the value that is to be determined.
2. Create a method that validates the key and returns the appropriate element of the array for any valid key (and an error status for any invalid key).

javaexamples/programmingpatterns/LookupArrays.java (Fragment: newExitNumberFor)

    private static final int[] NEW_NUMBERS = {-1, 1, 15, 16, 28, 35};

    /**
     * Get the new exit number that corresponds to an old exit number.
     * Old exit numbers were consecutive. New exit numbers are based
     * on mileage markers.
     *
     * @param  oldExitNumber   The old exit number
     * @return The new exit number (or -1 if there was no such old exit number)
     */
    public static int newExitNumberFor(int oldExitNumber) {
        if ((oldExitNumber < 1) || (oldExitNumber > 5)) {
            return -1;
        } else {
            return NEW_NUMBERS[oldExitNumber];
        }
    }
        

javaexamples/programmingpatterns/LookupArrays.java (Fragment: exitNameFor)

    private static final String[] NAMES = {"", "Willow Ave.",
        "Broad St.", "Downtown", "North End", "Lake Dr."};

    /**
     * Get the name for an old exit number.
     *
     * @param  oldExitNumber   The old exit number
     * @return The name of the exit (or "")
     */
    public static String exitNameFor(int oldExitNumber) {
        if ((oldExitNumber < 1) || (oldExitNumber > 5)) {
            return "";
        } else {
            return NAMES[oldExitNumber];
        }
    }
        

• A Nice Characteristic of the Previous Example:
  • The index of the lookup array corresponded exactly to the old exit number
• An Observation:
  • This won't always be the case

• Large Contiguous Keys:
  • The keys are contiguous but don't start at 0 in which case you can subtract the key from the smallest possible key (e.g., if you have annual data starting in 2015 then index = year - 2015;
• An Example:
  • javaexamples/programmingpatterns/LookupArrays.java (Fragment: sales)

        private static final double[] SALES = {
            107.2, 225.1, 189.9, 263.2};
        
        /**
         * Get the annual sales revenues for a given year.
         *
         * @param year  The year of interest
         * @return      The sales revenue in $100,000 (or 0.0)
         */
        public static double sales(int year) {
            if ((year < 2015) || (year >= 2019)) {
                return 0.0; // No sales
            } else {
                int index;
                index = year - 2015;
                return SALES[index];
            }
        }
            

• Non-Contiguous, Regular Keys:
  • More complicated calculations may be needed (sometimes using other programming patterns like divisibility and digit manipulation)
• An Example:
  • javaexamples/programmingpatterns/LookupArrays.java (Fragment: letterGrade)

        private static final char[] GRADES = {
            'F', 'F', 'F', 'F', 'F', 'F', 'D', 'C', 'B', 'A', 'A'};
    
        /**
         *  Determine the letter grade that corresponds to a number grade.
         * 
         * @param numberGrade  The numeric grade
         * @return The letter grade
         */
        public static char letterGrade(int numberGrade) {
            int index;
            
            index = numberGrade / 10;
            return GRADES[index];
        }
            

javaexamples/programmingpatterns/LookupArrays.java (Fragment: passFail)

    private static final char[] STATUS = {'F', 'P'};

    /**
     * Determine if a grade is passing or failing.
     *
     * @param grade  The grade
     * @return 'F' or 'P'
     */
    public static char passFail(double grade) {
        int index;
        
        index = (int) (grade / 60.0);
        return STATUS[index];
    }
        

• U.S. Population:
  • Population data are collected every 10 years
• The Problem:
  • Find the population for the previous census year

javaexamples/programmingpatterns/LookupArrays.java (Fragment: population)

    private static final double[] POP = {
        3.9, 5.2, 7.2, 9.6, 12.9, 17.1, 23.1, 31.4, 38.6, 49.4, 63.0, 76.2,
        92.2, 106.0, 123.2, 132.2, 151.3, 179.3, 203.2, 226.5, 248.7, 281.4, 
        308.7};
    
    /**
     * Get the US population for the previous census year.
     *
     * @param year  The year of interest
     * @return      The population for the previous census year (or -1)
     */
    public static double population(int year) {
        int index;
        
        if ((year < 1790) || (year >= 2020)) {
            return -1.0;
        } else {
            index = (year - 1790) / 10;
            return POP[index];
        }
    }