Java Array Sum sum(Number[] numbers)

Description

Sums an array of numbers together while using the correct class type.

License

Open Source License

Parameter

Parameter	Description
numbers	a parameter

Return

the sum contained in the most appropriate number class

Declaration

static Number sum(Number[] numbers) 

Method Source Code

//package com.java2s;
/*/*ww w  . ja  v a2  s . c  o  m*/
 *    GeoTools - The Open Source Java GIS Toolkit
 *    http://geotools.org
 * 
 *    (C) 2005-2008, Open Source Geospatial Foundation (OSGeo)
 *    
 *    This library is free software; you can redistribute it and/or
 *    modify it under the terms of the GNU Lesser General Public
 *    License as published by the Free Software Foundation;
 *    version 2.1 of the License.
 *
 *    This library is distributed in the hope that it will be useful,
 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *    Lesser General Public License for more details.
 */

public class Main {
    /**
      * Sums an array of numbers together while using the correct class type.
      *
      * @param numbers
      *
      * @return the sum contained in the most appropriate number class
      */
    static Number sum(Number[] numbers) {
        Number newSum = (Number) getObject(numbers);

        if (newSum == null) {
            return null;
        }

        //Integer, Long, Float, Double
        if (newSum instanceof Integer) {
            int sum = 0;
            int nextValue;

            for (int i = 0; i < numbers.length; i++) {
                nextValue = numbers[i].intValue();
                sum += nextValue;
            }

            newSum = new Integer(sum);
        } else if (newSum instanceof Long) {
            long sum = 0;
            long nextValue;

            for (int i = 0; i < numbers.length; i++) {
                nextValue = numbers[i].longValue();
                sum += nextValue;
            }

            newSum = new Long(sum);
        } else if (newSum instanceof Float) {
            float sum = 0;
            float nextValue;

            for (int i = 0; i < numbers.length; i++) {
                nextValue = numbers[i].floatValue();
                sum += nextValue;
            }

            newSum = new Float(sum);
        } else if (newSum instanceof Double) {
            double sum = 0;
            double nextValue;

            for (int i = 0; i < numbers.length; i++) {
                nextValue = numbers[i].doubleValue();
                sum += nextValue;
            }

            newSum = new Double(sum);
        } else {
            return null;
        }

        return newSum;
    }

    /**
     * Given an array of objects, traverses the array and determines the most
     * suitable data type to perform the calculation in. An empty object of
     * the correct class is returned;
     *
     * @param objects
     *
     */
    static Object getObject(Object[] objects) {
        Class bestClass = bestClass(objects);

        if (bestClass == String.class) {
            return new String(""); //$NON-NLS-1$
        } else if (bestClass == Double.class) {
            return new Double(0);
        } else if (bestClass == Float.class) {
            return new Float(0);
        } else if (bestClass == Long.class) {
            return new Long(0);
        } else if (bestClass == Integer.class) {
            return new Integer(0);
        } else { //it's a type we don't have here yet
            return null;
        }
    }

    /**
     * Determines the most appropriate class to use for a multiclass calculation.
     * 
     * @param objects
     * @return the most
     */
    static Class bestClass(Object[] objects) {
        boolean hasInt = false;
        boolean hasFloat = false;
        boolean hasLong = false;
        boolean hasDouble = false;
        boolean hasString = false;

        for (int i = 0; i < objects.length; i++) {
            if (objects[i] instanceof Double) {
                hasDouble = true;
            } else if (objects[i] instanceof Float) {
                hasFloat = true;
            } else if (objects[i] instanceof Long) {
                hasLong = true;
            } else if (objects[i] instanceof Integer) {
                hasInt = true;
            } else if (objects[i] instanceof String) {
                hasString = true;
            }
        }

        if (hasString) {
            return String.class;
        } else if (hasDouble) {
            return Double.class;
        } else if (hasFloat) {
            return Float.class;
        } else if (hasLong) {
            return Long.class;
        } else if (hasInt) {
            return Integer.class;
        } else { //it's a type we don't have here yet

            return null;
        }
    }
}

Related

1. sum(long[] array)
2. sum(long[] array)
3. sum(long[] counts)
4. sum(Number... numbers)
5. sum(Number[] array)
6. sum(Object[] srcOne, Object[] srcTwo)
7. sum(short tab[], int a, int b)
8. sum(short[] ary)
9. sum(String[] tokens, int start, int length, String separator)