Buggy code:
//*  * Licensed to the Apache Software Foundation (ASF) under one or more  * contributor license agreements.  See the NOTICE file distributed with  * this work for additional information regarding copyright ownership.  * The ASF licenses this file to You under the Apache License, Version 2.0  * (the "License"); you may not use this file except in compliance with  * the License.  You may obtain a copy of the License at  *   *      http: *   * Unless required by applicable law or agreed to in writing, software  * distributed under the License is distributed on an "AS IS" BASIS,  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  * See the License for the specific language governing permissions and  * limitations under the License.  *// package org.apache.commons.lang3.math;  import java.math.BigDecimal; import java.math.BigInteger;  import org.apache.commons.lang3.StringUtils;  //**  * <p>Provides extra functionality for Java Number classes.<//p>  *  * @author Apache Software Foundation  * @author <a href="mailto:rand_mcneely@yahoo.com">Rand McNeely<//a>  * @author <a href="mailto:steve.downey@netfolio.com">Steve Downey<//a>  * @author Eric Pugh  * @author Phil Steitz  * @author Matthew Hawthorne  * @author <a href="mailto:ggregory@seagullsw.com">Gary Gregory<//a>  * @author <a href="mailto:fredrik@westermarck.com">Fredrik Westermarck<//a>  * @since 2.0  * @version $Id$  *// public class NumberUtils {          //** Reusable Long constant for zero. *//     public static final Long LONG_ZERO = new Long(0L);     //** Reusable Long constant for one. *//     public static final Long LONG_ONE = new Long(1L);     //** Reusable Long constant for minus one. *//     public static final Long LONG_MINUS_ONE = new Long(-1L);     //** Reusable Integer constant for zero. *//     public static final Integer INTEGER_ZERO = new Integer(0);     //** Reusable Integer constant for one. *//     public static final Integer INTEGER_ONE = new Integer(1);     //** Reusable Integer constant for minus one. *//     public static final Integer INTEGER_MINUS_ONE = new Integer(-1);     //** Reusable Short constant for zero. *//     public static final Short SHORT_ZERO = new Short((short) 0);     //** Reusable Short constant for one. *//     public static final Short SHORT_ONE = new Short((short) 1);     //** Reusable Short constant for minus one. *//     public static final Short SHORT_MINUS_ONE = new Short((short) -1);     //** Reusable Byte constant for zero. *//     public static final Byte BYTE_ZERO = Byte.valueOf((byte) 0);     //** Reusable Byte constant for one. *//     public static final Byte BYTE_ONE = Byte.valueOf((byte) 1);     //** Reusable Byte constant for minus one. *//     public static final Byte BYTE_MINUS_ONE = Byte.valueOf((byte) -1);     //** Reusable Double constant for zero. *//     public static final Double DOUBLE_ZERO = new Double(0.0d);     //** Reusable Double constant for one. *//     public static final Double DOUBLE_ONE = new Double(1.0d);     //** Reusable Double constant for minus one. *//     public static final Double DOUBLE_MINUS_ONE = new Double(-1.0d);     //** Reusable Float constant for zero. *//     public static final Float FLOAT_ZERO = new Float(0.0f);     //** Reusable Float constant for one. *//     public static final Float FLOAT_ONE = new Float(1.0f);     //** Reusable Float constant for minus one. *//     public static final Float FLOAT_MINUS_ONE = new Float(-1.0f);      //**      * <p><code>NumberUtils<//code> instances should NOT be constructed in standard programming.      * Instead, the class should be used as <code>NumberUtils.toInt("6");<//code>.<//p>      *      * <p>This constructor is public to permit tools that require a JavaBean instance      * to operate.<//p>      *//     public NumberUtils() {         super();     }          //**      * <p>Convert a <code>String<//code> to an <code>int<//code>, returning      * <code>zero<//code> if the conversion fails.<//p>      *      * <p>If the string is <code>null<//code>, <code>zero<//code> is returned.<//p>      *      * <pre>      *   NumberUtils.toInt(null) = 0      *   NumberUtils.toInt("")   = 0      *   NumberUtils.toInt("1")  = 1      * <//pre>      *      * @param str  the string to convert, may be null      * @return the int represented by the string, or <code>zero<//code> if      *  conversion fails      * @since 2.1      *//     public static int toInt(String str) {         return toInt(str, 0);     }      //**      * <p>Convert a <code>String<//code> to an <code>int<//code>, returning a      * default value if the conversion fails.<//p>      *      * <p>If the string is <code>null<//code>, the default value is returned.<//p>      *      * <pre>      *   NumberUtils.toInt(null, 1) = 1      *   NumberUtils.toInt("", 1)   = 1      *   NumberUtils.toInt("1", 0)  = 1      * <//pre>      *      * @param str  the string to convert, may be null      * @param defaultValue  the default value      * @return the int represented by the string, or the default if conversion fails      * @since 2.1      *//     public static int toInt(String str, int defaultValue) {         if(str == null) {             return defaultValue;         }         try {             return Integer.parseInt(str);         } catch (NumberFormatException nfe) {             return defaultValue;         }     }      //**      * <p>Convert a <code>String<//code> to a <code>long<//code>, returning      * <code>zero<//code> if the conversion fails.<//p>      *      * <p>If the string is <code>null<//code>, <code>zero<//code> is returned.<//p>      *      * <pre>      *   NumberUtils.toLong(null) = 0L      *   NumberUtils.toLong("")   = 0L      *   NumberUtils.toLong("1")  = 1L      * <//pre>      *      * @param str  the string to convert, may be null      * @return the long represented by the string, or <code>0<//code> if      *  conversion fails      * @since 2.1      *//     public static long toLong(String str) {         return toLong(str, 0L);     }      //**      * <p>Convert a <code>String<//code> to a <code>long<//code>, returning a      * default value if the conversion fails.<//p>      *      * <p>If the string is <code>null<//code>, the default value is returned.<//p>      *      * <pre>      *   NumberUtils.toLong(null, 1L) = 1L      *   NumberUtils.toLong("", 1L)   = 1L      *   NumberUtils.toLong("1", 0L)  = 1L      * <//pre>      *      * @param str  the string to convert, may be null      * @param defaultValue  the default value      * @return the long represented by the string, or the default if conversion fails      * @since 2.1      *//     public static long toLong(String str, long defaultValue) {         if (str == null) {             return defaultValue;         }         try {             return Long.parseLong(str);         } catch (NumberFormatException nfe) {             return defaultValue;         }     }      //**      * <p>Convert a <code>String<//code> to a <code>float<//code>, returning      * <code>0.0f<//code> if the conversion fails.<//p>      *      * <p>If the string <code>str<//code> is <code>null<//code>,      * <code>0.0f<//code> is returned.<//p>      *      * <pre>      *   NumberUtils.toFloat(null)   = 0.0f      *   NumberUtils.toFloat("")     = 0.0f      *   NumberUtils.toFloat("1.5")  = 1.5f      * <//pre>      *      * @param str the string to convert, may be <code>null<//code>      * @return the float represented by the string, or <code>0.0f<//code>      *  if conversion fails      * @since 2.1      *//     public static float toFloat(String str) {         return toFloat(str, 0.0f);     }      //**      * <p>Convert a <code>String<//code> to a <code>float<//code>, returning a      * default value if the conversion fails.<//p>      *      * <p>If the string <code>str<//code> is <code>null<//code>, the default      * value is returned.<//p>      *      * <pre>      *   NumberUtils.toFloat(null, 1.1f)   = 1.0f      *   NumberUtils.toFloat("", 1.1f)     = 1.1f      *   NumberUtils.toFloat("1.5", 0.0f)  = 1.5f      * <//pre>      *      * @param str the string to convert, may be <code>null<//code>      * @param defaultValue the default value      * @return the float represented by the string, or defaultValue      *  if conversion fails      * @since 2.1      *//     public static float toFloat(String str, float defaultValue) {       if (str == null) {           return defaultValue;       }            try {           return Float.parseFloat(str);       } catch (NumberFormatException nfe) {           return defaultValue;       }     }      //**      * <p>Convert a <code>String<//code> to a <code>double<//code>, returning      * <code>0.0d<//code> if the conversion fails.<//p>      *      * <p>If the string <code>str<//code> is <code>null<//code>,      * <code>0.0d<//code> is returned.<//p>      *      * <pre>      *   NumberUtils.toDouble(null)   = 0.0d      *   NumberUtils.toDouble("")     = 0.0d      *   NumberUtils.toDouble("1.5")  = 1.5d      * <//pre>      *      * @param str the string to convert, may be <code>null<//code>      * @return the double represented by the string, or <code>0.0d<//code>      *  if conversion fails      * @since 2.1      *//     public static double toDouble(String str) {         return toDouble(str, 0.0d);     }      //**      * <p>Convert a <code>String<//code> to a <code>double<//code>, returning a      * default value if the conversion fails.<//p>      *      * <p>If the string <code>str<//code> is <code>null<//code>, the default      * value is returned.<//p>      *      * <pre>      *   NumberUtils.toDouble(null, 1.1d)   = 1.1d      *   NumberUtils.toDouble("", 1.1d)     = 1.1d      *   NumberUtils.toDouble("1.5", 0.0d)  = 1.5d      * <//pre>      *      * @param str the string to convert, may be <code>null<//code>      * @param defaultValue the default value      * @return the double represented by the string, or defaultValue      *  if conversion fails      * @since 2.1      *//     public static double toDouble(String str, double defaultValue) {       if (str == null) {           return defaultValue;       }       try {           return Double.parseDouble(str);       } catch (NumberFormatException nfe) {           return defaultValue;       }     }            //**      * <p>Convert a <code>String<//code> to a <code>byte<//code>, returning      * <code>zero<//code> if the conversion fails.<//p>      *      * <p>If the string is <code>null<//code>, <code>zero<//code> is returned.<//p>      *      * <pre>      *   NumberUtils.toByte(null) = 0      *   NumberUtils.toByte("")   = 0      *   NumberUtils.toByte("1")  = 1      * <//pre>      *      * @param str  the string to convert, may be null      * @return the byte represented by the string, or <code>zero<//code> if      *  conversion fails      * @since 2.5      *//     public static byte toByte(String str) {         return toByte(str, (byte) 0);     }      //**      * <p>Convert a <code>String<//code> to a <code>byte<//code>, returning a      * default value if the conversion fails.<//p>      *      * <p>If the string is <code>null<//code>, the default value is returned.<//p>      *      * <pre>      *   NumberUtils.toByte(null, 1) = 1      *   NumberUtils.toByte("", 1)   = 1      *   NumberUtils.toByte("1", 0)  = 1      * <//pre>      *      * @param str  the string to convert, may be null      * @param defaultValue  the default value      * @return the byte represented by the string, or the default if conversion fails      * @since 2.5      *//     public static byte toByte(String str, byte defaultValue) {         if(str == null) {             return defaultValue;         }         try {             return Byte.parseByte(str);         } catch (NumberFormatException nfe) {             return defaultValue;         }     }      //**      * <p>Convert a <code>String<//code> to a <code>short<//code>, returning      * <code>zero<//code> if the conversion fails.<//p>      *      * <p>If the string is <code>null<//code>, <code>zero<//code> is returned.<//p>      *      * <pre>      *   NumberUtils.toShort(null) = 0      *   NumberUtils.toShort("")   = 0      *   NumberUtils.toShort("1")  = 1      * <//pre>      *      * @param str  the string to convert, may be null      * @return the short represented by the string, or <code>zero<//code> if      *  conversion fails      * @since 2.5      *//     public static short toShort(String str) {         return toShort(str, (short) 0);     }      //**      * <p>Convert a <code>String<//code> to an <code>short<//code>, returning a      * default value if the conversion fails.<//p>      *      * <p>If the string is <code>null<//code>, the default value is returned.<//p>      *      * <pre>      *   NumberUtils.toShort(null, 1) = 1      *   NumberUtils.toShort("", 1)   = 1      *   NumberUtils.toShort("1", 0)  = 1      * <//pre>      *      * @param str  the string to convert, may be null      * @param defaultValue  the default value      * @return the short represented by the string, or the default if conversion fails      * @since 2.5      *//     public static short toShort(String str, short defaultValue) {         if(str == null) {             return defaultValue;         }         try {             return Short.parseShort(str);         } catch (NumberFormatException nfe) {             return defaultValue;         }     }                                                                                                                                                   //**      * <p>Turns a string value into a java.lang.Number.<//p>      *      * <p>First, the value is examined for a type qualifier on the end      * (<code>'f','F','d','D','l','L'<//code>).  If it is found, it starts       * trying to create successively larger types from the type specified      * until one is found that can represent the value.<//p>      *      * <p>If a type specifier is not found, it will check for a decimal point      * and then try successively larger types from <code>Integer<//code> to      * <code>BigInteger<//code> and from <code>Float<//code> to      * <code>BigDecimal<//code>.<//p>      *      * <p>If the string starts with <code>0x<//code> or <code>-0x<//code>, it      * will be interpreted as a hexadecimal integer.  Values with leading      * <code>0<//code>'s will not be interpreted as octal.<//p>      *      * <p>Returns <code>null<//code> if the string is <code>null<//code>.<//p>      *      * <p>This method does not trim the input string, i.e., strings with leading      * or trailing spaces will generate NumberFormatExceptions.<//p>      *      * @param str  String containing a number, may be null      * @return Number created from the string      * @throws NumberFormatException if the value cannot be converted      *//     public static Number createNumber(String str) throws NumberFormatException {         if (str == null) {             return null;         }         if (StringUtils.isBlank(str)) {             throw new NumberFormatException("A blank string is not a valid number");         }           if (str.startsWith("--")) {                                                             return null;         }         if (str.startsWith("0x") || str.startsWith("-0x")) {             return createInteger(str);         }            char lastChar = str.charAt(str.length() - 1);         String mant;         String dec;         String exp;         int decPos = str.indexOf('.');         int expPos = str.indexOf('e') + str.indexOf('E') + 1;          if (decPos > -1) {              if (expPos > -1) {                 if (expPos < decPos || expPos > str.length()) {                     throw new NumberFormatException(str + " is not a valid number.");                 }                 dec = str.substring(decPos + 1, expPos);             } else {                 dec = str.substring(decPos + 1);             }             mant = str.substring(0, decPos);         } else {             if (expPos > -1) {                 if (expPos > str.length()) {                     throw new NumberFormatException(str + " is not a valid number.");                 }                 mant = str.substring(0, expPos);             } else {                 mant = str;             }             dec = null;         }         if (!Character.isDigit(lastChar) && lastChar != '.') {             if (expPos > -1 && expPos < str.length() - 1) {                 exp = str.substring(expPos + 1, str.length() - 1);             } else {                 exp = null;             }                         String numeric = str.substring(0, str.length() - 1);             boolean allZeros = isAllZeros(mant) && isAllZeros(exp);             switch (lastChar) {                 case 'l' :                 case 'L' :                     if (dec == null                         && exp == null                         && (numeric.charAt(0) == '-' && isDigits(numeric.substring(1)) || isDigits(numeric))) {                         try {                             return createLong(numeric);                         } catch (NumberFormatException nfe) {                                                     }                         return createBigInteger(numeric);                      }                     throw new NumberFormatException(str + " is not a valid number.");                 case 'f' :                 case 'F' :                     try {                         Float f = NumberUtils.createFloat(numeric);                         if (!(f.isInfinite() || (f.floatValue() == 0.0F && !allZeros))) {                                                                                     return f;                         }                      } catch (NumberFormatException nfe) {                                             }                                     case 'd' :                 case 'D' :                     try {                         Double d = NumberUtils.createDouble(numeric);                         if (!(d.isInfinite() || (d.floatValue() == 0.0D && !allZeros))) {                             return d;                         }                     } catch (NumberFormatException nfe) {                                             }                     try {                         return createBigDecimal(numeric);                     } catch (NumberFormatException e) {                                             }                                     default :                     throw new NumberFormatException(str + " is not a valid number.");              }         } else {                                     if (expPos > -1 && expPos < str.length() - 1) {                 exp = str.substring(expPos + 1, str.length());             } else {                 exp = null;             }             if (dec == null && exp == null) {                                 try {                     return createInteger(str);                 } catch (NumberFormatException nfe) {                                     }                 try {                     return createLong(str);                 } catch (NumberFormatException nfe) {                                     }                 return createBigInteger(str);              } else {                                 boolean allZeros = isAllZeros(mant) && isAllZeros(exp);                 try {                     Float f = createFloat(str);                     if (!(f.isInfinite() || (f.floatValue() == 0.0F && !allZeros))) {                         return f;                     }                 } catch (NumberFormatException nfe) {                                     }                 try {                     Double d = createDouble(str);                     if (!(d.isInfinite() || (d.doubleValue() == 0.0D && !allZeros))) {                         return d;                     }                 } catch (NumberFormatException nfe) {                                     }                  return createBigDecimal(str);              }         }     }      //**      * <p>Utility method for {@link #createNumber(java.lang.String)}.<//p>      *      * <p>Returns <code>true<//code> if s is <code>null<//code>.<//p>      *       * @param str  the String to check      * @return if it is all zeros or <code>null<//code>      *//     private static boolean isAllZeros(String str) {         if (str == null) {             return true;         }         for (int i = str.length() - 1; i >= 0; i--) {             if (str.charAt(i) != '0') {                 return false;             }         }         return str.length() > 0;     }          //**      * <p>Convert a <code>String<//code> to a <code>Float<//code>.<//p>      *      * <p>Returns <code>null<//code> if the string is <code>null<//code>.<//p>      *       * @param str  a <code>String<//code> to convert, may be null      * @return converted <code>Float<//code>      * @throws NumberFormatException if the value cannot be converted      *//     public static Float createFloat(String str) {         if (str == null) {             return null;         }         return Float.valueOf(str);     }      //**      * <p>Convert a <code>String<//code> to a <code>Double<//code>.<//p>      *       * <p>Returns <code>null<//code> if the string is <code>null<//code>.<//p>      *      * @param str  a <code>String<//code> to convert, may be null      * @return converted <code>Double<//code>      * @throws NumberFormatException if the value cannot be converted      *//     public static Double createDouble(String str) {         if (str == null) {             return null;         }         return Double.valueOf(str);     }      //**      * <p>Convert a <code>String<//code> to a <code>Integer<//code>, handling      * hex and octal notations.<//p>      *      * <p>Returns <code>null<//code> if the string is <code>null<//code>.<//p>      *       * @param str  a <code>String<//code> to convert, may be null      * @return converted <code>Integer<//code>      * @throws NumberFormatException if the value cannot be converted      *//     public static Integer createInteger(String str) {         if (str == null) {             return null;         }                 return Integer.decode(str);     }      //**      * <p>Convert a <code>String<//code> to a <code>Long<//code>.<//p>      *       * <p>Returns <code>null<//code> if the string is <code>null<//code>.<//p>      *      * @param str  a <code>String<//code> to convert, may be null      * @return converted <code>Long<//code>      * @throws NumberFormatException if the value cannot be converted      *//     public static Long createLong(String str) {         if (str == null) {             return null;         }         return Long.valueOf(str);     }      //**      * <p>Convert a <code>String<//code> to a <code>BigInteger<//code>.<//p>      *      * <p>Returns <code>null<//code> if the string is <code>null<//code>.<//p>      *       * @param str  a <code>String<//code> to convert, may be null      * @return converted <code>BigInteger<//code>      * @throws NumberFormatException if the value cannot be converted      *//     public static BigInteger createBigInteger(String str) {         if (str == null) {             return null;         }         return new BigInteger(str);     }      //**      * <p>Convert a <code>String<//code> to a <code>BigDecimal<//code>.<//p>      *       * <p>Returns <code>null<//code> if the string is <code>null<//code>.<//p>      *      * @param str  a <code>String<//code> to convert, may be null      * @return converted <code>BigDecimal<//code>      * @throws NumberFormatException if the value cannot be converted      *//     public static BigDecimal createBigDecimal(String str) {         if (str == null) {             return null;         }                 if (StringUtils.isBlank(str)) {             throw new NumberFormatException("A blank string is not a valid number");         }           return new BigDecimal(str);     }              //**      * <p>Returns the minimum value in an array.<//p>      *       * @param array  an array, must not be null or empty      * @return the minimum value in the array      * @throws IllegalArgumentException if <code>array<//code> is <code>null<//code>      * @throws IllegalArgumentException if <code>array<//code> is empty      *//     public static long min(long[] array) {                 if (array == null) {             throw new IllegalArgumentException("The Array must not be null");         } else if (array.length == 0) {             throw new IllegalArgumentException("Array cannot be empty.");         }                      long min = array[0];         for (int i = 1; i < array.length; i++) {             if (array[i] < min) {                 min = array[i];             }         }              return min;     }      //**      * <p>Returns the minimum value in an array.<//p>      *       * @param array  an array, must not be null or empty      * @return the minimum value in the array      * @throws IllegalArgumentException if <code>array<//code> is <code>null<//code>      * @throws IllegalArgumentException if <code>array<//code> is empty      *//     public static int min(int[] array) {                 if (array == null) {             throw new IllegalArgumentException("The Array must not be null");         } else if (array.length == 0) {             throw new IllegalArgumentException("Array cannot be empty.");         }                      int min = array[0];         for (int j = 1; j < array.length; j++) {             if (array[j] < min) {                 min = array[j];             }         }              return min;     }      //**      * <p>Returns the minimum value in an array.<//p>      *       * @param array  an array, must not be null or empty      * @return the minimum value in the array      * @throws IllegalArgumentException if <code>array<//code> is <code>null<//code>      * @throws IllegalArgumentException if <code>array<//code> is empty      *//     public static short min(short[] array) {                 if (array == null) {             throw new IllegalArgumentException("The Array must not be null");         } else if (array.length == 0) {             throw new IllegalArgumentException("Array cannot be empty.");         }                      short min = array[0];         for (int i = 1; i < array.length; i++) {             if (array[i] < min) {                 min = array[i];             }         }              return min;     }      //**      * <p>Returns the minimum value in an array.<//p>      *       * @param array  an array, must not be null or empty      * @return the minimum value in the array      * @throws IllegalArgumentException if <code>array<//code> is <code>null<//code>      * @throws IllegalArgumentException if <code>array<//code> is empty      *//     public static byte min(byte[] array) {                 if (array == null) {             throw new IllegalArgumentException("The Array must not be null");         } else if (array.length == 0) {             throw new IllegalArgumentException("Array cannot be empty.");         }                      byte min = array[0];         for (int i = 1; i < array.length; i++) {             if (array[i] < min) {                 min = array[i];             }         }              return min;     }       //**      * <p>Returns the minimum value in an array.<//p>      *       * @param array  an array, must not be null or empty      * @return the minimum value in the array      * @throws IllegalArgumentException if <code>array<//code> is <code>null<//code>      * @throws IllegalArgumentException if <code>array<//code> is empty      * @see IEEE754rUtils#min(double[]) IEEE754rUtils for a version of this method that handles NaN differently      *//     public static double min(double[] array) {                 if (array == null) {             throw new IllegalArgumentException("The Array must not be null");         } else if (array.length == 0) {             throw new IllegalArgumentException("Array cannot be empty.");         }                      double min = array[0];         for (int i = 1; i < array.length; i++) {             if (Double.isNaN(array[i])) {                 return Double.NaN;             }             if (array[i] < min) {                 min = array[i];             }         }              return min;     }      //**      * <p>Returns the minimum value in an array.<//p>      *       * @param array  an array, must not be null or empty      * @return the minimum value in the array      * @throws IllegalArgumentException if <code>array<//code> is <code>null<//code>      * @throws IllegalArgumentException if <code>array<//code> is empty      * @see IEEE754rUtils#min(float[]) IEEE754rUtils for a version of this method that handles NaN differently      *//     public static float min(float[] array) {                 if (array == null) {             throw new IllegalArgumentException("The Array must not be null");         } else if (array.length == 0) {             throw new IllegalArgumentException("Array cannot be empty.");         }                      float min = array[0];         for (int i = 1; i < array.length; i++) {             if (Float.isNaN(array[i])) {                 return Float.NaN;             }             if (array[i] < min) {                 min = array[i];             }         }              return min;     }              //**      * <p>Returns the maximum value in an array.<//p>      *       * @param array  an array, must not be null or empty      * @return the minimum value in the array      * @throws IllegalArgumentException if <code>array<//code> is <code>null<//code>      * @throws IllegalArgumentException if <code>array<//code> is empty      *//     public static long max(long[] array) {                 if (array == null) {             throw new IllegalArgumentException("The Array must not be null");         } else if (array.length == 0) {             throw new IllegalArgumentException("Array cannot be empty.");         }                  long max = array[0];         for (int j = 1; j < array.length; j++) {             if (array[j] > max) {                 max = array[j];             }         }          return max;     }      //**      * <p>Returns the maximum value in an array.<//p>      *       * @param array  an array, must not be null or empty      * @return the minimum value in the array      * @throws IllegalArgumentException if <code>array<//code> is <code>null<//code>      * @throws IllegalArgumentException if <code>array<//code> is empty      *//     public static int max(int[] array) {                 if (array == null) {             throw new IllegalArgumentException("The Array must not be null");         } else if (array.length == 0) {             throw new IllegalArgumentException("Array cannot be empty.");         }                      int max = array[0];         for (int j = 1; j < array.length; j++) {             if (array[j] > max) {                 max = array[j];             }         }              return max;     }      //**      * <p>Returns the maximum value in an array.<//p>      *       * @param array  an array, must not be null or empty      * @return the minimum value in the array      * @throws IllegalArgumentException if <code>array<//code> is <code>null<//code>      * @throws IllegalArgumentException if <code>array<//code> is empty      *//     public static short max(short[] array) {                 if (array == null) {             throw new IllegalArgumentException("The Array must not be null");         } else if (array.length == 0) {             throw new IllegalArgumentException("Array cannot be empty.");         }                      short max = array[0];         for (int i = 1; i < array.length; i++) {             if (array[i] > max) {                 max = array[i];             }         }              return max;     }      //**      * <p>Returns the maximum value in an array.<//p>      *       * @param array  an array, must not be null or empty      * @return the minimum value in the array      * @throws IllegalArgumentException if <code>array<//code> is <code>null<//code>      * @throws IllegalArgumentException if <code>array<//code> is empty      *//     public static byte max(byte[] array) {                 if (array == null) {             throw new IllegalArgumentException("The Array must not be null");         } else if (array.length == 0) {             throw new IllegalArgumentException("Array cannot be empty.");         }                      byte max = array[0];         for (int i = 1; i < array.length; i++) {             if (array[i] > max) {                 max = array[i];             }         }              return max;     }      //**      * <p>Returns the maximum value in an array.<//p>      *       * @param array  an array, must not be null or empty      * @return the minimum value in the array      * @throws IllegalArgumentException if <code>array<//code> is <code>null<//code>      * @throws IllegalArgumentException if <code>array<//code> is empty      * @see IEEE754rUtils#max(double[]) IEEE754rUtils for a version of this method that handles NaN differently      *//     public static double max(double[] array) {                 if (array== null) {             throw new IllegalArgumentException("The Array must not be null");         } else if (array.length == 0) {             throw new IllegalArgumentException("Array cannot be empty.");         }                      double max = array[0];         for (int j = 1; j < array.length; j++) {             if (Double.isNaN(array[j])) {                 return Double.NaN;             }             if (array[j] > max) {                 max = array[j];             }         }              return max;     }      //**      * <p>Returns the maximum value in an array.<//p>      *       * @param array  an array, must not be null or empty      * @return the minimum value in the array      * @throws IllegalArgumentException if <code>array<//code> is <code>null<//code>      * @throws IllegalArgumentException if <code>array<//code> is empty      * @see IEEE754rUtils#max(float[]) IEEE754rUtils for a version of this method that handles NaN differently      *//     public static float max(float[] array) {                 if (array == null) {             throw new IllegalArgumentException("The Array must not be null");         } else if (array.length == 0) {             throw new IllegalArgumentException("Array cannot be empty.");         }                  float max = array[0];         for (int j = 1; j < array.length; j++) {             if (Float.isNaN(array[j])) {                 return Float.NaN;             }             if (array[j] > max) {                 max = array[j];             }         }          return max;     }                   //**      * <p>Gets the minimum of three <code>long<//code> values.<//p>      *       * @param a  value 1      * @param b  value 2      * @param c  value 3      * @return  the smallest of the values      *//     public static long min(long a, long b, long c) {         if (b < a) {             a = b;         }         if (c < a) {             a = c;         }         return a;     }      //**      * <p>Gets the minimum of three <code>int<//code> values.<//p>      *       * @param a  value 1      * @param b  value 2      * @param c  value 3      * @return  the smallest of the values      *//     public static int min(int a, int b, int c) {         if (b < a) {             a = b;         }         if (c < a) {             a = c;         }         return a;     }      //**      * <p>Gets the minimum of three <code>short<//code> values.<//p>      *       * @param a  value 1      * @param b  value 2      * @param c  value 3      * @return  the smallest of the values      *//     public static short min(short a, short b, short c) {         if (b < a) {             a = b;         }         if (c < a) {             a = c;         }         return a;     }      //**      * <p>Gets the minimum of three <code>byte<//code> values.<//p>      *       * @param a  value 1      * @param b  value 2      * @param c  value 3      * @return  the smallest of the values      *//     public static byte min(byte a, byte b, byte c) {         if (b < a) {             a = b;         }         if (c < a) {             a = c;         }         return a;     }      //**      * <p>Gets the minimum of three <code>double<//code> values.<//p>      *       * <p>If any value is <code>NaN<//code>, <code>NaN<//code> is      * returned. Infinity is handled.<//p>      *       * @param a  value 1      * @param b  value 2      * @param c  value 3      * @return  the smallest of the values      * @see IEEE754rUtils#min(double, double, double) for a version of this method that handles NaN differently      *//     public static double min(double a, double b, double c) {         return Math.min(Math.min(a, b), c);     }      //**      * <p>Gets the minimum of three <code>float<//code> values.<//p>      *       * <p>If any value is <code>NaN<//code>, <code>NaN<//code> is      * returned. Infinity is handled.<//p>      *      * @param a  value 1      * @param b  value 2      * @param c  value 3      * @return  the smallest of the values      * @see IEEE754rUtils#min(float, float, float) for a version of this method that handles NaN differently      *//     public static float min(float a, float b, float c) {         return Math.min(Math.min(a, b), c);     }              //**      * <p>Gets the maximum of three <code>long<//code> values.<//p>      *       * @param a  value 1      * @param b  value 2      * @param c  value 3      * @return  the largest of the values      *//     public static long max(long a, long b, long c) {         if (b > a) {             a = b;         }         if (c > a) {             a = c;         }         return a;     }      //**      * <p>Gets the maximum of three <code>int<//code> values.<//p>      *       * @param a  value 1      * @param b  value 2      * @param c  value 3      * @return  the largest of the values      *//     public static int max(int a, int b, int c) {         if (b > a) {             a = b;         }         if (c > a) {             a = c;         }         return a;     }      //**      * <p>Gets the maximum of three <code>short<//code> values.<//p>      *       * @param a  value 1      * @param b  value 2      * @param c  value 3      * @return  the largest of the values      *//     public static short max(short a, short b, short c) {         if (b > a) {             a = b;         }         if (c > a) {             a = c;         }         return a;     }      //**      * <p>Gets the maximum of three <code>byte<//code> values.<//p>      *       * @param a  value 1      * @param b  value 2      * @param c  value 3      * @return  the largest of the values      *//     public static byte max(byte a, byte b, byte c) {         if (b > a) {             a = b;         }         if (c > a) {             a = c;         }         return a;     }      //**      * <p>Gets the maximum of three <code>double<//code> values.<//p>      *       * <p>If any value is <code>NaN<//code>, <code>NaN<//code> is      * returned. Infinity is handled.<//p>      *      * @param a  value 1      * @param b  value 2      * @param c  value 3      * @return  the largest of the values      * @see IEEE754rUtils#max(double, double, double) for a version of this method that handles NaN differently      *//     public static double max(double a, double b, double c) {         return Math.max(Math.max(a, b), c);     }      //**      * <p>Gets the maximum of three <code>float<//code> values.<//p>      *       * <p>If any value is <code>NaN<//code>, <code>NaN<//code> is      * returned. Infinity is handled.<//p>      *      * @param a  value 1      * @param b  value 2      * @param c  value 3      * @return  the largest of the values      * @see IEEE754rUtils#max(float, float, float) for a version of this method that handles NaN differently      *//     public static float max(float a, float b, float c) {         return Math.max(Math.max(a, b), c);     }          //**      * <p>Checks whether the <code>String<//code> contains only      * digit characters.<//p>      *      * <p><code>Null<//code> and empty String will return      * <code>false<//code>.<//p>      *      * @param str  the <code>String<//code> to check      * @return <code>true<//code> if str contains only unicode numeric      *//     public static boolean isDigits(String str) {         if (StringUtils.isEmpty(str)) {             return false;         }         for (int i = 0; i < str.length(); i++) {             if (!Character.isDigit(str.charAt(i))) {                 return false;             }         }         return true;     }      //**      * <p>Checks whether the String a valid Java number.<//p>      *      * <p>Valid numbers include hexadecimal marked with the <code>0x<//code>      * qualifier, scientific notation and numbers marked with a type      * qualifier (e.g. 123L).<//p>      *      * <p><code>Null<//code> and empty String will return      * <code>false<//code>.<//p>      *      * @param str  the <code>String<//code> to check      * @return <code>true<//code> if the string is a correctly formatted number      *//     public static boolean isNumber(String str) {         if (StringUtils.isEmpty(str)) {             return false;         }         char[] chars = str.toCharArray();         int sz = chars.length;         boolean hasExp = false;         boolean hasDecPoint = false;         boolean allowSigns = false;         boolean foundDigit = false;                 int start = (chars[0] == '-') ? 1 : 0;         if (sz > start + 1) {             if (chars[start] == '0' && chars[start + 1] == 'x') {                 int i = start + 2;                 if (i == sz) {                     return false;                 }                                 for (; i < chars.length; i++) {                     if ((chars[i] < '0' || chars[i] > '9')                         && (chars[i] < 'a' || chars[i] > 'f')                         && (chars[i] < 'A' || chars[i] > 'F')) {                         return false;                     }                 }                 return true;             }         }         sz--;                       int i = start;                         while (i < sz || (i < sz + 1 && allowSigns && !foundDigit)) {             if (chars[i] >= '0' && chars[i] <= '9') {                 foundDigit = true;                 allowSigns = false;              } else if (chars[i] == '.') {                 if (hasDecPoint || hasExp) {                                         return false;                 }                 hasDecPoint = true;             } else if (chars[i] == 'e' || chars[i] == 'E') {                                 if (hasExp) {                                         return false;                 }                 if (!foundDigit) {                     return false;                 }                 hasExp = true;                 allowSigns = true;             } else if (chars[i] == '+' || chars[i] == '-') {                 if (!allowSigns) {                     return false;                 }                 allowSigns = false;                 foundDigit = false;             } else {                 return false;             }             i++;         }         if (i < chars.length) {             if (chars[i] >= '0' && chars[i] <= '9') {                                 return true;             }             if (chars[i] == 'e' || chars[i] == 'E') {                                 return false;             }             if (chars[i] == '.') {                 if (hasDecPoint || hasExp) {                                         return false;                 }                                 return foundDigit && !hasExp; }             if (!allowSigns                 && (chars[i] == 'd'                     || chars[i] == 'D'                     || chars[i] == 'f'                     || chars[i] == 'F')) {                 return foundDigit && !hasExp; }             if (chars[i] == 'l'                 || chars[i] == 'L') {                                <START_BUG>  return foundDigit && !hasExp; <END_BUG>             }                         return false;         }                         return !allowSigns && foundDigit;     }      } 


Fix:
return foundDigit && !hasExp && !hasDecPoint;