001/* 002 * Licensed to the Apache Software Foundation (ASF) under one or more 003 * contributor license agreements. See the NOTICE file distributed with 004 * this work for additional information regarding copyright ownership. 005 * The ASF licenses this file to You under the Apache License, Version 2.0 006 * (the "License"); you may not use this file except in compliance with 007 * the License. You may obtain a copy of the License at 008 * 009 * http://www.apache.org/licenses/LICENSE-2.0 010 * 011 * Unless required by applicable law or agreed to in writing, software 012 * distributed under the License is distributed on an "AS IS" BASIS, 013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 014 * See the License for the specific language governing permissions and 015 * limitations under the License. 016 */ 017package org.apache.commons.lang3.math; 018 019import java.lang.reflect.Array; 020import java.math.BigDecimal; 021import java.math.BigInteger; 022 023import org.apache.commons.lang3.StringUtils; 024 025/** 026 * <p>Provides extra functionality for Java Number classes.</p> 027 * 028 * @since 2.0 029 * @version $Id: NumberUtils.java 1566972 2014-02-11 02:57:40Z sebb $ 030 */ 031public class NumberUtils { 032 033 /** Reusable Long constant for zero. */ 034 public static final Long LONG_ZERO = Long.valueOf(0L); 035 /** Reusable Long constant for one. */ 036 public static final Long LONG_ONE = Long.valueOf(1L); 037 /** Reusable Long constant for minus one. */ 038 public static final Long LONG_MINUS_ONE = Long.valueOf(-1L); 039 /** Reusable Integer constant for zero. */ 040 public static final Integer INTEGER_ZERO = Integer.valueOf(0); 041 /** Reusable Integer constant for one. */ 042 public static final Integer INTEGER_ONE = Integer.valueOf(1); 043 /** Reusable Integer constant for minus one. */ 044 public static final Integer INTEGER_MINUS_ONE = Integer.valueOf(-1); 045 /** Reusable Short constant for zero. */ 046 public static final Short SHORT_ZERO = Short.valueOf((short) 0); 047 /** Reusable Short constant for one. */ 048 public static final Short SHORT_ONE = Short.valueOf((short) 1); 049 /** Reusable Short constant for minus one. */ 050 public static final Short SHORT_MINUS_ONE = Short.valueOf((short) -1); 051 /** Reusable Byte constant for zero. */ 052 public static final Byte BYTE_ZERO = Byte.valueOf((byte) 0); 053 /** Reusable Byte constant for one. */ 054 public static final Byte BYTE_ONE = Byte.valueOf((byte) 1); 055 /** Reusable Byte constant for minus one. */ 056 public static final Byte BYTE_MINUS_ONE = Byte.valueOf((byte) -1); 057 /** Reusable Double constant for zero. */ 058 public static final Double DOUBLE_ZERO = Double.valueOf(0.0d); 059 /** Reusable Double constant for one. */ 060 public static final Double DOUBLE_ONE = Double.valueOf(1.0d); 061 /** Reusable Double constant for minus one. */ 062 public static final Double DOUBLE_MINUS_ONE = Double.valueOf(-1.0d); 063 /** Reusable Float constant for zero. */ 064 public static final Float FLOAT_ZERO = Float.valueOf(0.0f); 065 /** Reusable Float constant for one. */ 066 public static final Float FLOAT_ONE = Float.valueOf(1.0f); 067 /** Reusable Float constant for minus one. */ 068 public static final Float FLOAT_MINUS_ONE = Float.valueOf(-1.0f); 069 070 /** 071 * <p><code>NumberUtils</code> instances should NOT be constructed in standard programming. 072 * Instead, the class should be used as <code>NumberUtils.toInt("6");</code>.</p> 073 * 074 * <p>This constructor is public to permit tools that require a JavaBean instance 075 * to operate.</p> 076 */ 077 public NumberUtils() { 078 super(); 079 } 080 081 //----------------------------------------------------------------------- 082 /** 083 * <p>Convert a <code>String</code> to an <code>int</code>, returning 084 * <code>zero</code> if the conversion fails.</p> 085 * 086 * <p>If the string is <code>null</code>, <code>zero</code> is returned.</p> 087 * 088 * <pre> 089 * NumberUtils.toInt(null) = 0 090 * NumberUtils.toInt("") = 0 091 * NumberUtils.toInt("1") = 1 092 * </pre> 093 * 094 * @param str the string to convert, may be null 095 * @return the int represented by the string, or <code>zero</code> if 096 * conversion fails 097 * @since 2.1 098 */ 099 public static int toInt(final String str) { 100 return toInt(str, 0); 101 } 102 103 /** 104 * <p>Convert a <code>String</code> to an <code>int</code>, returning a 105 * default value if the conversion fails.</p> 106 * 107 * <p>If the string is <code>null</code>, the default value is returned.</p> 108 * 109 * <pre> 110 * NumberUtils.toInt(null, 1) = 1 111 * NumberUtils.toInt("", 1) = 1 112 * NumberUtils.toInt("1", 0) = 1 113 * </pre> 114 * 115 * @param str the string to convert, may be null 116 * @param defaultValue the default value 117 * @return the int represented by the string, or the default if conversion fails 118 * @since 2.1 119 */ 120 public static int toInt(final String str, final int defaultValue) { 121 if(str == null) { 122 return defaultValue; 123 } 124 try { 125 return Integer.parseInt(str); 126 } catch (final NumberFormatException nfe) { 127 return defaultValue; 128 } 129 } 130 131 /** 132 * <p>Convert a <code>String</code> to a <code>long</code>, returning 133 * <code>zero</code> if the conversion fails.</p> 134 * 135 * <p>If the string is <code>null</code>, <code>zero</code> is returned.</p> 136 * 137 * <pre> 138 * NumberUtils.toLong(null) = 0L 139 * NumberUtils.toLong("") = 0L 140 * NumberUtils.toLong("1") = 1L 141 * </pre> 142 * 143 * @param str the string to convert, may be null 144 * @return the long represented by the string, or <code>0</code> if 145 * conversion fails 146 * @since 2.1 147 */ 148 public static long toLong(final String str) { 149 return toLong(str, 0L); 150 } 151 152 /** 153 * <p>Convert a <code>String</code> to a <code>long</code>, returning a 154 * default value if the conversion fails.</p> 155 * 156 * <p>If the string is <code>null</code>, the default value is returned.</p> 157 * 158 * <pre> 159 * NumberUtils.toLong(null, 1L) = 1L 160 * NumberUtils.toLong("", 1L) = 1L 161 * NumberUtils.toLong("1", 0L) = 1L 162 * </pre> 163 * 164 * @param str the string to convert, may be null 165 * @param defaultValue the default value 166 * @return the long represented by the string, or the default if conversion fails 167 * @since 2.1 168 */ 169 public static long toLong(final String str, final long defaultValue) { 170 if (str == null) { 171 return defaultValue; 172 } 173 try { 174 return Long.parseLong(str); 175 } catch (final NumberFormatException nfe) { 176 return defaultValue; 177 } 178 } 179 180 /** 181 * <p>Convert a <code>String</code> to a <code>float</code>, returning 182 * <code>0.0f</code> if the conversion fails.</p> 183 * 184 * <p>If the string <code>str</code> is <code>null</code>, 185 * <code>0.0f</code> is returned.</p> 186 * 187 * <pre> 188 * NumberUtils.toFloat(null) = 0.0f 189 * NumberUtils.toFloat("") = 0.0f 190 * NumberUtils.toFloat("1.5") = 1.5f 191 * </pre> 192 * 193 * @param str the string to convert, may be <code>null</code> 194 * @return the float represented by the string, or <code>0.0f</code> 195 * if conversion fails 196 * @since 2.1 197 */ 198 public static float toFloat(final String str) { 199 return toFloat(str, 0.0f); 200 } 201 202 /** 203 * <p>Convert a <code>String</code> to a <code>float</code>, returning a 204 * default value if the conversion fails.</p> 205 * 206 * <p>If the string <code>str</code> is <code>null</code>, the default 207 * value is returned.</p> 208 * 209 * <pre> 210 * NumberUtils.toFloat(null, 1.1f) = 1.0f 211 * NumberUtils.toFloat("", 1.1f) = 1.1f 212 * NumberUtils.toFloat("1.5", 0.0f) = 1.5f 213 * </pre> 214 * 215 * @param str the string to convert, may be <code>null</code> 216 * @param defaultValue the default value 217 * @return the float represented by the string, or defaultValue 218 * if conversion fails 219 * @since 2.1 220 */ 221 public static float toFloat(final String str, final float defaultValue) { 222 if (str == null) { 223 return defaultValue; 224 } 225 try { 226 return Float.parseFloat(str); 227 } catch (final NumberFormatException nfe) { 228 return defaultValue; 229 } 230 } 231 232 /** 233 * <p>Convert a <code>String</code> to a <code>double</code>, returning 234 * <code>0.0d</code> if the conversion fails.</p> 235 * 236 * <p>If the string <code>str</code> is <code>null</code>, 237 * <code>0.0d</code> is returned.</p> 238 * 239 * <pre> 240 * NumberUtils.toDouble(null) = 0.0d 241 * NumberUtils.toDouble("") = 0.0d 242 * NumberUtils.toDouble("1.5") = 1.5d 243 * </pre> 244 * 245 * @param str the string to convert, may be <code>null</code> 246 * @return the double represented by the string, or <code>0.0d</code> 247 * if conversion fails 248 * @since 2.1 249 */ 250 public static double toDouble(final String str) { 251 return toDouble(str, 0.0d); 252 } 253 254 /** 255 * <p>Convert a <code>String</code> to a <code>double</code>, returning a 256 * default value if the conversion fails.</p> 257 * 258 * <p>If the string <code>str</code> is <code>null</code>, the default 259 * value is returned.</p> 260 * 261 * <pre> 262 * NumberUtils.toDouble(null, 1.1d) = 1.1d 263 * NumberUtils.toDouble("", 1.1d) = 1.1d 264 * NumberUtils.toDouble("1.5", 0.0d) = 1.5d 265 * </pre> 266 * 267 * @param str the string to convert, may be <code>null</code> 268 * @param defaultValue the default value 269 * @return the double represented by the string, or defaultValue 270 * if conversion fails 271 * @since 2.1 272 */ 273 public static double toDouble(final String str, final double defaultValue) { 274 if (str == null) { 275 return defaultValue; 276 } 277 try { 278 return Double.parseDouble(str); 279 } catch (final NumberFormatException nfe) { 280 return defaultValue; 281 } 282 } 283 284 //----------------------------------------------------------------------- 285 /** 286 * <p>Convert a <code>String</code> to a <code>byte</code>, returning 287 * <code>zero</code> if the conversion fails.</p> 288 * 289 * <p>If the string is <code>null</code>, <code>zero</code> is returned.</p> 290 * 291 * <pre> 292 * NumberUtils.toByte(null) = 0 293 * NumberUtils.toByte("") = 0 294 * NumberUtils.toByte("1") = 1 295 * </pre> 296 * 297 * @param str the string to convert, may be null 298 * @return the byte represented by the string, or <code>zero</code> if 299 * conversion fails 300 * @since 2.5 301 */ 302 public static byte toByte(final String str) { 303 return toByte(str, (byte) 0); 304 } 305 306 /** 307 * <p>Convert a <code>String</code> to a <code>byte</code>, returning a 308 * default value if the conversion fails.</p> 309 * 310 * <p>If the string is <code>null</code>, the default value is returned.</p> 311 * 312 * <pre> 313 * NumberUtils.toByte(null, 1) = 1 314 * NumberUtils.toByte("", 1) = 1 315 * NumberUtils.toByte("1", 0) = 1 316 * </pre> 317 * 318 * @param str the string to convert, may be null 319 * @param defaultValue the default value 320 * @return the byte represented by the string, or the default if conversion fails 321 * @since 2.5 322 */ 323 public static byte toByte(final String str, final byte defaultValue) { 324 if(str == null) { 325 return defaultValue; 326 } 327 try { 328 return Byte.parseByte(str); 329 } catch (final NumberFormatException nfe) { 330 return defaultValue; 331 } 332 } 333 334 /** 335 * <p>Convert a <code>String</code> to a <code>short</code>, returning 336 * <code>zero</code> if the conversion fails.</p> 337 * 338 * <p>If the string is <code>null</code>, <code>zero</code> is returned.</p> 339 * 340 * <pre> 341 * NumberUtils.toShort(null) = 0 342 * NumberUtils.toShort("") = 0 343 * NumberUtils.toShort("1") = 1 344 * </pre> 345 * 346 * @param str the string to convert, may be null 347 * @return the short represented by the string, or <code>zero</code> if 348 * conversion fails 349 * @since 2.5 350 */ 351 public static short toShort(final String str) { 352 return toShort(str, (short) 0); 353 } 354 355 /** 356 * <p>Convert a <code>String</code> to an <code>short</code>, returning a 357 * default value if the conversion fails.</p> 358 * 359 * <p>If the string is <code>null</code>, the default value is returned.</p> 360 * 361 * <pre> 362 * NumberUtils.toShort(null, 1) = 1 363 * NumberUtils.toShort("", 1) = 1 364 * NumberUtils.toShort("1", 0) = 1 365 * </pre> 366 * 367 * @param str the string to convert, may be null 368 * @param defaultValue the default value 369 * @return the short represented by the string, or the default if conversion fails 370 * @since 2.5 371 */ 372 public static short toShort(final String str, final short defaultValue) { 373 if(str == null) { 374 return defaultValue; 375 } 376 try { 377 return Short.parseShort(str); 378 } catch (final NumberFormatException nfe) { 379 return defaultValue; 380 } 381 } 382 383 //----------------------------------------------------------------------- 384 // must handle Long, Float, Integer, Float, Short, 385 // BigDecimal, BigInteger and Byte 386 // useful methods: 387 // Byte.decode(String) 388 // Byte.valueOf(String,int radix) 389 // Byte.valueOf(String) 390 // Double.valueOf(String) 391 // Float.valueOf(String) 392 // Float.valueOf(String) 393 // Integer.valueOf(String,int radix) 394 // Integer.valueOf(String) 395 // Integer.decode(String) 396 // Integer.getInteger(String) 397 // Integer.getInteger(String,int val) 398 // Integer.getInteger(String,Integer val) 399 // Integer.valueOf(String) 400 // Double.valueOf(String) 401 // new Byte(String) 402 // Long.valueOf(String) 403 // Long.getLong(String) 404 // Long.getLong(String,int) 405 // Long.getLong(String,Integer) 406 // Long.valueOf(String,int) 407 // Long.valueOf(String) 408 // Short.valueOf(String) 409 // Short.decode(String) 410 // Short.valueOf(String,int) 411 // Short.valueOf(String) 412 // new BigDecimal(String) 413 // new BigInteger(String) 414 // new BigInteger(String,int radix) 415 // Possible inputs: 416 // 45 45.5 45E7 4.5E7 Hex Oct Binary xxxF xxxD xxxf xxxd 417 // plus minus everything. Prolly more. A lot are not separable. 418 419 /** 420 * <p>Turns a string value into a java.lang.Number.</p> 421 * 422 * <p>If the string starts with {@code 0x} or {@code -0x} (lower or upper case) or {@code #} or {@code -#}, it 423 * will be interpreted as a hexadecimal Integer - or Long, if the number of digits after the 424 * prefix is more than 8 - or BigInteger if there are more than 16 digits. 425 * </p> 426 * <p>Then, the value is examined for a type qualifier on the end, i.e. one of 427 * <code>'f','F','d','D','l','L'</code>. If it is found, it starts 428 * trying to create successively larger types from the type specified 429 * until one is found that can represent the value.</p> 430 * 431 * <p>If a type specifier is not found, it will check for a decimal point 432 * and then try successively larger types from <code>Integer</code> to 433 * <code>BigInteger</code> and from <code>Float</code> to 434 * <code>BigDecimal</code>.</p> 435 * 436 * <p> 437 * Integral values with a leading {@code 0} will be interpreted as octal; the returned number will 438 * be Integer, Long or BigDecimal as appropriate. 439 * </p> 440 * 441 * <p>Returns <code>null</code> if the string is <code>null</code>.</p> 442 * 443 * <p>This method does not trim the input string, i.e., strings with leading 444 * or trailing spaces will generate NumberFormatExceptions.</p> 445 * 446 * @param str String containing a number, may be null 447 * @return Number created from the string (or null if the input is null) 448 * @throws NumberFormatException if the value cannot be converted 449 */ 450 public static Number createNumber(final String str) throws NumberFormatException { 451 if (str == null) { 452 return null; 453 } 454 if (StringUtils.isBlank(str)) { 455 throw new NumberFormatException("A blank string is not a valid number"); 456 } 457 // Need to deal with all possible hex prefixes here 458 final String[] hex_prefixes = {"0x", "0X", "-0x", "-0X", "#", "-#"}; 459 int pfxLen = 0; 460 for(final String pfx : hex_prefixes) { 461 if (str.startsWith(pfx)) { 462 pfxLen += pfx.length(); 463 break; 464 } 465 } 466 if (pfxLen > 0) { // we have a hex number 467 char firstSigDigit = 0; // strip leading zeroes 468 for(int i = pfxLen; i < str.length(); i++) { 469 firstSigDigit = str.charAt(i); 470 if (firstSigDigit == '0') { // count leading zeroes 471 pfxLen++; 472 } else { 473 break; 474 } 475 } 476 final int hexDigits = str.length() - pfxLen; 477 if (hexDigits > 16 || (hexDigits == 16 && firstSigDigit > '7')) { // too many for Long 478 return createBigInteger(str); 479 } 480 if (hexDigits > 8 || (hexDigits == 8 && firstSigDigit > '7')) { // too many for an int 481 return createLong(str); 482 } 483 return createInteger(str); 484 } 485 final char lastChar = str.charAt(str.length() - 1); 486 String mant; 487 String dec; 488 String exp; 489 final int decPos = str.indexOf('.'); 490 final int expPos = str.indexOf('e') + str.indexOf('E') + 1; // assumes both not present 491 // if both e and E are present, this is caught by the checks on expPos (which prevent IOOBE) 492 // and the parsing which will detect if e or E appear in a number due to using the wrong offset 493 494 int numDecimals = 0; // Check required precision (LANG-693) 495 if (decPos > -1) { // there is a decimal point 496 497 if (expPos > -1) { // there is an exponent 498 if (expPos < decPos || expPos > str.length()) { // prevents double exponent causing IOOBE 499 throw new NumberFormatException(str + " is not a valid number."); 500 } 501 dec = str.substring(decPos + 1, expPos); 502 } else { 503 dec = str.substring(decPos + 1); 504 } 505 mant = str.substring(0, decPos); 506 numDecimals = dec.length(); // gets number of digits past the decimal to ensure no loss of precision for floating point numbers. 507 } else { 508 if (expPos > -1) { 509 if (expPos > str.length()) { // prevents double exponent causing IOOBE 510 throw new NumberFormatException(str + " is not a valid number."); 511 } 512 mant = str.substring(0, expPos); 513 } else { 514 mant = str; 515 } 516 dec = null; 517 } 518 if (!Character.isDigit(lastChar) && lastChar != '.') { 519 if (expPos > -1 && expPos < str.length() - 1) { 520 exp = str.substring(expPos + 1, str.length() - 1); 521 } else { 522 exp = null; 523 } 524 //Requesting a specific type.. 525 final String numeric = str.substring(0, str.length() - 1); 526 final boolean allZeros = isAllZeros(mant) && isAllZeros(exp); 527 switch (lastChar) { 528 case 'l' : 529 case 'L' : 530 if (dec == null 531 && exp == null 532 && (numeric.charAt(0) == '-' && isDigits(numeric.substring(1)) || isDigits(numeric))) { 533 try { 534 return createLong(numeric); 535 } catch (final NumberFormatException nfe) { // NOPMD 536 // Too big for a long 537 } 538 return createBigInteger(numeric); 539 540 } 541 throw new NumberFormatException(str + " is not a valid number."); 542 case 'f' : 543 case 'F' : 544 try { 545 final Float f = NumberUtils.createFloat(numeric); 546 if (!(f.isInfinite() || (f.floatValue() == 0.0F && !allZeros))) { 547 //If it's too big for a float or the float value = 0 and the string 548 //has non-zeros in it, then float does not have the precision we want 549 return f; 550 } 551 552 } catch (final NumberFormatException nfe) { // NOPMD 553 // ignore the bad number 554 } 555 //$FALL-THROUGH$ 556 case 'd' : 557 case 'D' : 558 try { 559 final Double d = NumberUtils.createDouble(numeric); 560 if (!(d.isInfinite() || (d.floatValue() == 0.0D && !allZeros))) { 561 return d; 562 } 563 } catch (final NumberFormatException nfe) { // NOPMD 564 // ignore the bad number 565 } 566 try { 567 return createBigDecimal(numeric); 568 } catch (final NumberFormatException e) { // NOPMD 569 // ignore the bad number 570 } 571 //$FALL-THROUGH$ 572 default : 573 throw new NumberFormatException(str + " is not a valid number."); 574 575 } 576 } 577 //User doesn't have a preference on the return type, so let's start 578 //small and go from there... 579 if (expPos > -1 && expPos < str.length() - 1) { 580 exp = str.substring(expPos + 1, str.length()); 581 } else { 582 exp = null; 583 } 584 if (dec == null && exp == null) { // no decimal point and no exponent 585 //Must be an Integer, Long, Biginteger 586 try { 587 return createInteger(str); 588 } catch (final NumberFormatException nfe) { // NOPMD 589 // ignore the bad number 590 } 591 try { 592 return createLong(str); 593 } catch (final NumberFormatException nfe) { // NOPMD 594 // ignore the bad number 595 } 596 return createBigInteger(str); 597 } 598 599 //Must be a Float, Double, BigDecimal 600 final boolean allZeros = isAllZeros(mant) && isAllZeros(exp); 601 try { 602 if(numDecimals <= 7){// If number has 7 or fewer digits past the decimal point then make it a float 603 final Float f = createFloat(str); 604 if (!(f.isInfinite() || (f.floatValue() == 0.0F && !allZeros))) { 605 return f; 606 } 607 } 608 } catch (final NumberFormatException nfe) { // NOPMD 609 // ignore the bad number 610 } 611 try { 612 if(numDecimals <= 16){// If number has between 8 and 16 digits past the decimal point then make it a double 613 final Double d = createDouble(str); 614 if (!(d.isInfinite() || (d.doubleValue() == 0.0D && !allZeros))) { 615 return d; 616 } 617 } 618 } catch (final NumberFormatException nfe) { // NOPMD 619 // ignore the bad number 620 } 621 622 return createBigDecimal(str); 623 } 624 625 /** 626 * <p>Utility method for {@link #createNumber(java.lang.String)}.</p> 627 * 628 * <p>Returns <code>true</code> if s is <code>null</code>.</p> 629 * 630 * @param str the String to check 631 * @return if it is all zeros or <code>null</code> 632 */ 633 private static boolean isAllZeros(final String str) { 634 if (str == null) { 635 return true; 636 } 637 for (int i = str.length() - 1; i >= 0; i--) { 638 if (str.charAt(i) != '0') { 639 return false; 640 } 641 } 642 return str.length() > 0; 643 } 644 645 //----------------------------------------------------------------------- 646 /** 647 * <p>Convert a <code>String</code> to a <code>Float</code>.</p> 648 * 649 * <p>Returns <code>null</code> if the string is <code>null</code>.</p> 650 * 651 * @param str a <code>String</code> to convert, may be null 652 * @return converted <code>Float</code> (or null if the input is null) 653 * @throws NumberFormatException if the value cannot be converted 654 */ 655 public static Float createFloat(final String str) { 656 if (str == null) { 657 return null; 658 } 659 return Float.valueOf(str); 660 } 661 662 /** 663 * <p>Convert a <code>String</code> to a <code>Double</code>.</p> 664 * 665 * <p>Returns <code>null</code> if the string is <code>null</code>.</p> 666 * 667 * @param str a <code>String</code> to convert, may be null 668 * @return converted <code>Double</code> (or null if the input is null) 669 * @throws NumberFormatException if the value cannot be converted 670 */ 671 public static Double createDouble(final String str) { 672 if (str == null) { 673 return null; 674 } 675 return Double.valueOf(str); 676 } 677 678 /** 679 * <p>Convert a <code>String</code> to a <code>Integer</code>, handling 680 * hex (0xhhhh) and octal (0dddd) notations. 681 * N.B. a leading zero means octal; spaces are not trimmed.</p> 682 * 683 * <p>Returns <code>null</code> if the string is <code>null</code>.</p> 684 * 685 * @param str a <code>String</code> to convert, may be null 686 * @return converted <code>Integer</code> (or null if the input is null) 687 * @throws NumberFormatException if the value cannot be converted 688 */ 689 public static Integer createInteger(final String str) { 690 if (str == null) { 691 return null; 692 } 693 // decode() handles 0xAABD and 0777 (hex and octal) as well. 694 return Integer.decode(str); 695 } 696 697 /** 698 * <p>Convert a <code>String</code> to a <code>Long</code>; 699 * since 3.1 it handles hex (0Xhhhh) and octal (0ddd) notations. 700 * N.B. a leading zero means octal; spaces are not trimmed.</p> 701 * 702 * <p>Returns <code>null</code> if the string is <code>null</code>.</p> 703 * 704 * @param str a <code>String</code> to convert, may be null 705 * @return converted <code>Long</code> (or null if the input is null) 706 * @throws NumberFormatException if the value cannot be converted 707 */ 708 public static Long createLong(final String str) { 709 if (str == null) { 710 return null; 711 } 712 return Long.decode(str); 713 } 714 715 /** 716 * <p>Convert a <code>String</code> to a <code>BigInteger</code>; 717 * since 3.2 it handles hex (0x or #) and octal (0) notations.</p> 718 * 719 * <p>Returns <code>null</code> if the string is <code>null</code>.</p> 720 * 721 * @param str a <code>String</code> to convert, may be null 722 * @return converted <code>BigInteger</code> (or null if the input is null) 723 * @throws NumberFormatException if the value cannot be converted 724 */ 725 public static BigInteger createBigInteger(final String str) { 726 if (str == null) { 727 return null; 728 } 729 int pos = 0; // offset within string 730 int radix = 10; 731 boolean negate = false; // need to negate later? 732 if (str.startsWith("-")) { 733 negate = true; 734 pos = 1; 735 } 736 if (str.startsWith("0x", pos) || str.startsWith("0x", pos)) { // hex 737 radix = 16; 738 pos += 2; 739 } else if (str.startsWith("#", pos)) { // alternative hex (allowed by Long/Integer) 740 radix = 16; 741 pos ++; 742 } else if (str.startsWith("0", pos) && str.length() > pos + 1) { // octal; so long as there are additional digits 743 radix = 8; 744 pos ++; 745 } // default is to treat as decimal 746 747 final BigInteger value = new BigInteger(str.substring(pos), radix); 748 return negate ? value.negate() : value; 749 } 750 751 /** 752 * <p>Convert a <code>String</code> to a <code>BigDecimal</code>.</p> 753 * 754 * <p>Returns <code>null</code> if the string is <code>null</code>.</p> 755 * 756 * @param str a <code>String</code> to convert, may be null 757 * @return converted <code>BigDecimal</code> (or null if the input is null) 758 * @throws NumberFormatException if the value cannot be converted 759 */ 760 public static BigDecimal createBigDecimal(final String str) { 761 if (str == null) { 762 return null; 763 } 764 // handle JDK1.3.1 bug where "" throws IndexOutOfBoundsException 765 if (StringUtils.isBlank(str)) { 766 throw new NumberFormatException("A blank string is not a valid number"); 767 } 768 if (str.trim().startsWith("--")) { 769 // this is protection for poorness in java.lang.BigDecimal. 770 // it accepts this as a legal value, but it does not appear 771 // to be in specification of class. OS X Java parses it to 772 // a wrong value. 773 throw new NumberFormatException(str + " is not a valid number."); 774 } 775 return new BigDecimal(str); 776 } 777 778 // Min in array 779 //-------------------------------------------------------------------- 780 /** 781 * <p>Returns the minimum value in an array.</p> 782 * 783 * @param array an array, must not be null or empty 784 * @return the minimum value in the array 785 * @throws IllegalArgumentException if <code>array</code> is <code>null</code> 786 * @throws IllegalArgumentException if <code>array</code> is empty 787 */ 788 public static long min(final long[] array) { 789 // Validates input 790 validateArray(array); 791 792 // Finds and returns min 793 long min = array[0]; 794 for (int i = 1; i < array.length; i++) { 795 if (array[i] < min) { 796 min = array[i]; 797 } 798 } 799 800 return min; 801 } 802 803 /** 804 * <p>Returns the minimum value in an array.</p> 805 * 806 * @param array an array, must not be null or empty 807 * @return the minimum value in the array 808 * @throws IllegalArgumentException if <code>array</code> is <code>null</code> 809 * @throws IllegalArgumentException if <code>array</code> is empty 810 */ 811 public static int min(final int[] array) { 812 // Validates input 813 validateArray(array); 814 815 // Finds and returns min 816 int min = array[0]; 817 for (int j = 1; j < array.length; j++) { 818 if (array[j] < min) { 819 min = array[j]; 820 } 821 } 822 823 return min; 824 } 825 826 /** 827 * <p>Returns the minimum value in an array.</p> 828 * 829 * @param array an array, must not be null or empty 830 * @return the minimum value in the array 831 * @throws IllegalArgumentException if <code>array</code> is <code>null</code> 832 * @throws IllegalArgumentException if <code>array</code> is empty 833 */ 834 public static short min(final short[] array) { 835 // Validates input 836 validateArray(array); 837 838 // Finds and returns min 839 short min = array[0]; 840 for (int i = 1; i < array.length; i++) { 841 if (array[i] < min) { 842 min = array[i]; 843 } 844 } 845 846 return min; 847 } 848 849 /** 850 * <p>Returns the minimum value in an array.</p> 851 * 852 * @param array an array, must not be null or empty 853 * @return the minimum value in the array 854 * @throws IllegalArgumentException if <code>array</code> is <code>null</code> 855 * @throws IllegalArgumentException if <code>array</code> is empty 856 */ 857 public static byte min(final byte[] array) { 858 // Validates input 859 validateArray(array); 860 861 // Finds and returns min 862 byte min = array[0]; 863 for (int i = 1; i < array.length; i++) { 864 if (array[i] < min) { 865 min = array[i]; 866 } 867 } 868 869 return min; 870 } 871 872 /** 873 * <p>Returns the minimum value in an array.</p> 874 * 875 * @param array an array, must not be null or empty 876 * @return the minimum value in the array 877 * @throws IllegalArgumentException if <code>array</code> is <code>null</code> 878 * @throws IllegalArgumentException if <code>array</code> is empty 879 * @see IEEE754rUtils#min(double[]) IEEE754rUtils for a version of this method that handles NaN differently 880 */ 881 public static double min(final double[] array) { 882 // Validates input 883 validateArray(array); 884 885 // Finds and returns min 886 double min = array[0]; 887 for (int i = 1; i < array.length; i++) { 888 if (Double.isNaN(array[i])) { 889 return Double.NaN; 890 } 891 if (array[i] < min) { 892 min = array[i]; 893 } 894 } 895 896 return min; 897 } 898 899 /** 900 * <p>Returns the minimum value in an array.</p> 901 * 902 * @param array an array, must not be null or empty 903 * @return the minimum value in the array 904 * @throws IllegalArgumentException if <code>array</code> is <code>null</code> 905 * @throws IllegalArgumentException if <code>array</code> is empty 906 * @see IEEE754rUtils#min(float[]) IEEE754rUtils for a version of this method that handles NaN differently 907 */ 908 public static float min(final float[] array) { 909 // Validates input 910 validateArray(array); 911 912 // Finds and returns min 913 float min = array[0]; 914 for (int i = 1; i < array.length; i++) { 915 if (Float.isNaN(array[i])) { 916 return Float.NaN; 917 } 918 if (array[i] < min) { 919 min = array[i]; 920 } 921 } 922 923 return min; 924 } 925 926 // Max in array 927 //-------------------------------------------------------------------- 928 /** 929 * <p>Returns the maximum value in an array.</p> 930 * 931 * @param array an array, must not be null or empty 932 * @return the minimum value in the array 933 * @throws IllegalArgumentException if <code>array</code> is <code>null</code> 934 * @throws IllegalArgumentException if <code>array</code> is empty 935 */ 936 public static long max(final long[] array) { 937 // Validates input 938 validateArray(array); 939 940 // Finds and returns max 941 long max = array[0]; 942 for (int j = 1; j < array.length; j++) { 943 if (array[j] > max) { 944 max = array[j]; 945 } 946 } 947 948 return max; 949 } 950 951 /** 952 * <p>Returns the maximum value in an array.</p> 953 * 954 * @param array an array, must not be null or empty 955 * @return the minimum value in the array 956 * @throws IllegalArgumentException if <code>array</code> is <code>null</code> 957 * @throws IllegalArgumentException if <code>array</code> is empty 958 */ 959 public static int max(final int[] array) { 960 // Validates input 961 validateArray(array); 962 963 // Finds and returns max 964 int max = array[0]; 965 for (int j = 1; j < array.length; j++) { 966 if (array[j] > max) { 967 max = array[j]; 968 } 969 } 970 971 return max; 972 } 973 974 /** 975 * <p>Returns the maximum value in an array.</p> 976 * 977 * @param array an array, must not be null or empty 978 * @return the minimum value in the array 979 * @throws IllegalArgumentException if <code>array</code> is <code>null</code> 980 * @throws IllegalArgumentException if <code>array</code> is empty 981 */ 982 public static short max(final short[] array) { 983 // Validates input 984 validateArray(array); 985 986 // Finds and returns max 987 short max = array[0]; 988 for (int i = 1; i < array.length; i++) { 989 if (array[i] > max) { 990 max = array[i]; 991 } 992 } 993 994 return max; 995 } 996 997 /** 998 * <p>Returns the maximum value in an array.</p> 999 * 1000 * @param array an array, must not be null or empty 1001 * @return the minimum value in the array 1002 * @throws IllegalArgumentException if <code>array</code> is <code>null</code> 1003 * @throws IllegalArgumentException if <code>array</code> is empty 1004 */ 1005 public static byte max(final byte[] array) { 1006 // Validates input 1007 validateArray(array); 1008 1009 // Finds and returns max 1010 byte max = array[0]; 1011 for (int i = 1; i < array.length; i++) { 1012 if (array[i] > max) { 1013 max = array[i]; 1014 } 1015 } 1016 1017 return max; 1018 } 1019 1020 /** 1021 * <p>Returns the maximum value in an array.</p> 1022 * 1023 * @param array an array, must not be null or empty 1024 * @return the minimum value in the array 1025 * @throws IllegalArgumentException if <code>array</code> is <code>null</code> 1026 * @throws IllegalArgumentException if <code>array</code> is empty 1027 * @see IEEE754rUtils#max(double[]) IEEE754rUtils for a version of this method that handles NaN differently 1028 */ 1029 public static double max(final double[] array) { 1030 // Validates input 1031 validateArray(array); 1032 1033 // Finds and returns max 1034 double max = array[0]; 1035 for (int j = 1; j < array.length; j++) { 1036 if (Double.isNaN(array[j])) { 1037 return Double.NaN; 1038 } 1039 if (array[j] > max) { 1040 max = array[j]; 1041 } 1042 } 1043 1044 return max; 1045 } 1046 1047 /** 1048 * <p>Returns the maximum value in an array.</p> 1049 * 1050 * @param array an array, must not be null or empty 1051 * @return the minimum value in the array 1052 * @throws IllegalArgumentException if <code>array</code> is <code>null</code> 1053 * @throws IllegalArgumentException if <code>array</code> is empty 1054 * @see IEEE754rUtils#max(float[]) IEEE754rUtils for a version of this method that handles NaN differently 1055 */ 1056 public static float max(final float[] array) { 1057 // Validates input 1058 validateArray(array); 1059 1060 // Finds and returns max 1061 float max = array[0]; 1062 for (int j = 1; j < array.length; j++) { 1063 if (Float.isNaN(array[j])) { 1064 return Float.NaN; 1065 } 1066 if (array[j] > max) { 1067 max = array[j]; 1068 } 1069 } 1070 1071 return max; 1072 } 1073 1074 /** 1075 * Checks if the specified array is neither null nor empty. 1076 * 1077 * @param array the array to check 1078 * @throws IllegalArgumentException if {@code array} is either {@code null} or empty 1079 */ 1080 private static void validateArray(final Object array) { 1081 if (array == null) { 1082 throw new IllegalArgumentException("The Array must not be null"); 1083 } else if (Array.getLength(array) == 0) { 1084 throw new IllegalArgumentException("Array cannot be empty."); 1085 } 1086 } 1087 1088 // 3 param min 1089 //----------------------------------------------------------------------- 1090 /** 1091 * <p>Gets the minimum of three <code>long</code> values.</p> 1092 * 1093 * @param a value 1 1094 * @param b value 2 1095 * @param c value 3 1096 * @return the smallest of the values 1097 */ 1098 public static long min(long a, final long b, final long c) { 1099 if (b < a) { 1100 a = b; 1101 } 1102 if (c < a) { 1103 a = c; 1104 } 1105 return a; 1106 } 1107 1108 /** 1109 * <p>Gets the minimum of three <code>int</code> values.</p> 1110 * 1111 * @param a value 1 1112 * @param b value 2 1113 * @param c value 3 1114 * @return the smallest of the values 1115 */ 1116 public static int min(int a, final int b, final int c) { 1117 if (b < a) { 1118 a = b; 1119 } 1120 if (c < a) { 1121 a = c; 1122 } 1123 return a; 1124 } 1125 1126 /** 1127 * <p>Gets the minimum of three <code>short</code> values.</p> 1128 * 1129 * @param a value 1 1130 * @param b value 2 1131 * @param c value 3 1132 * @return the smallest of the values 1133 */ 1134 public static short min(short a, final short b, final short c) { 1135 if (b < a) { 1136 a = b; 1137 } 1138 if (c < a) { 1139 a = c; 1140 } 1141 return a; 1142 } 1143 1144 /** 1145 * <p>Gets the minimum of three <code>byte</code> values.</p> 1146 * 1147 * @param a value 1 1148 * @param b value 2 1149 * @param c value 3 1150 * @return the smallest of the values 1151 */ 1152 public static byte min(byte a, final byte b, final byte c) { 1153 if (b < a) { 1154 a = b; 1155 } 1156 if (c < a) { 1157 a = c; 1158 } 1159 return a; 1160 } 1161 1162 /** 1163 * <p>Gets the minimum of three <code>double</code> values.</p> 1164 * 1165 * <p>If any value is <code>NaN</code>, <code>NaN</code> is 1166 * returned. Infinity is handled.</p> 1167 * 1168 * @param a value 1 1169 * @param b value 2 1170 * @param c value 3 1171 * @return the smallest of the values 1172 * @see IEEE754rUtils#min(double, double, double) for a version of this method that handles NaN differently 1173 */ 1174 public static double min(final double a, final double b, final double c) { 1175 return Math.min(Math.min(a, b), c); 1176 } 1177 1178 /** 1179 * <p>Gets the minimum of three <code>float</code> values.</p> 1180 * 1181 * <p>If any value is <code>NaN</code>, <code>NaN</code> is 1182 * returned. Infinity is handled.</p> 1183 * 1184 * @param a value 1 1185 * @param b value 2 1186 * @param c value 3 1187 * @return the smallest of the values 1188 * @see IEEE754rUtils#min(float, float, float) for a version of this method that handles NaN differently 1189 */ 1190 public static float min(final float a, final float b, final float c) { 1191 return Math.min(Math.min(a, b), c); 1192 } 1193 1194 // 3 param max 1195 //----------------------------------------------------------------------- 1196 /** 1197 * <p>Gets the maximum of three <code>long</code> values.</p> 1198 * 1199 * @param a value 1 1200 * @param b value 2 1201 * @param c value 3 1202 * @return the largest of the values 1203 */ 1204 public static long max(long a, final long b, final long c) { 1205 if (b > a) { 1206 a = b; 1207 } 1208 if (c > a) { 1209 a = c; 1210 } 1211 return a; 1212 } 1213 1214 /** 1215 * <p>Gets the maximum of three <code>int</code> values.</p> 1216 * 1217 * @param a value 1 1218 * @param b value 2 1219 * @param c value 3 1220 * @return the largest of the values 1221 */ 1222 public static int max(int a, final int b, final int c) { 1223 if (b > a) { 1224 a = b; 1225 } 1226 if (c > a) { 1227 a = c; 1228 } 1229 return a; 1230 } 1231 1232 /** 1233 * <p>Gets the maximum of three <code>short</code> values.</p> 1234 * 1235 * @param a value 1 1236 * @param b value 2 1237 * @param c value 3 1238 * @return the largest of the values 1239 */ 1240 public static short max(short a, final short b, final short c) { 1241 if (b > a) { 1242 a = b; 1243 } 1244 if (c > a) { 1245 a = c; 1246 } 1247 return a; 1248 } 1249 1250 /** 1251 * <p>Gets the maximum of three <code>byte</code> values.</p> 1252 * 1253 * @param a value 1 1254 * @param b value 2 1255 * @param c value 3 1256 * @return the largest of the values 1257 */ 1258 public static byte max(byte a, final byte b, final byte c) { 1259 if (b > a) { 1260 a = b; 1261 } 1262 if (c > a) { 1263 a = c; 1264 } 1265 return a; 1266 } 1267 1268 /** 1269 * <p>Gets the maximum of three <code>double</code> values.</p> 1270 * 1271 * <p>If any value is <code>NaN</code>, <code>NaN</code> is 1272 * returned. Infinity is handled.</p> 1273 * 1274 * @param a value 1 1275 * @param b value 2 1276 * @param c value 3 1277 * @return the largest of the values 1278 * @see IEEE754rUtils#max(double, double, double) for a version of this method that handles NaN differently 1279 */ 1280 public static double max(final double a, final double b, final double c) { 1281 return Math.max(Math.max(a, b), c); 1282 } 1283 1284 /** 1285 * <p>Gets the maximum of three <code>float</code> values.</p> 1286 * 1287 * <p>If any value is <code>NaN</code>, <code>NaN</code> is 1288 * returned. Infinity is handled.</p> 1289 * 1290 * @param a value 1 1291 * @param b value 2 1292 * @param c value 3 1293 * @return the largest of the values 1294 * @see IEEE754rUtils#max(float, float, float) for a version of this method that handles NaN differently 1295 */ 1296 public static float max(final float a, final float b, final float c) { 1297 return Math.max(Math.max(a, b), c); 1298 } 1299 1300 //----------------------------------------------------------------------- 1301 /** 1302 * <p>Checks whether the <code>String</code> contains only 1303 * digit characters.</p> 1304 * 1305 * <p><code>Null</code> and empty String will return 1306 * <code>false</code>.</p> 1307 * 1308 * @param str the <code>String</code> to check 1309 * @return <code>true</code> if str contains only Unicode numeric 1310 */ 1311 public static boolean isDigits(final String str) { 1312 if (StringUtils.isEmpty(str)) { 1313 return false; 1314 } 1315 for (int i = 0; i < str.length(); i++) { 1316 if (!Character.isDigit(str.charAt(i))) { 1317 return false; 1318 } 1319 } 1320 return true; 1321 } 1322 1323 /** 1324 * <p>Checks whether the String a valid Java number.</p> 1325 * 1326 * <p>Valid numbers include hexadecimal marked with the <code>0x</code> 1327 * qualifier, scientific notation and numbers marked with a type 1328 * qualifier (e.g. 123L).</p> 1329 * 1330 * <p><code>Null</code> and empty String will return 1331 * <code>false</code>.</p> 1332 * 1333 * @param str the <code>String</code> to check 1334 * @return <code>true</code> if the string is a correctly formatted number 1335 * @since 3.3 the code supports hex {@code 0Xhhh} and octal {@code 0ddd} validation 1336 */ 1337 public static boolean isNumber(final String str) { 1338 if (StringUtils.isEmpty(str)) { 1339 return false; 1340 } 1341 final char[] chars = str.toCharArray(); 1342 int sz = chars.length; 1343 boolean hasExp = false; 1344 boolean hasDecPoint = false; 1345 boolean allowSigns = false; 1346 boolean foundDigit = false; 1347 // deal with any possible sign up front 1348 final int start = (chars[0] == '-') ? 1 : 0; 1349 if (sz > start + 1 && chars[start] == '0') { // leading 0 1350 if ( 1351 (chars[start + 1] == 'x') || 1352 (chars[start + 1] == 'X') 1353 ) { // leading 0x/0X 1354 int i = start + 2; 1355 if (i == sz) { 1356 return false; // str == "0x" 1357 } 1358 // checking hex (it can't be anything else) 1359 for (; i < chars.length; i++) { 1360 if ((chars[i] < '0' || chars[i] > '9') 1361 && (chars[i] < 'a' || chars[i] > 'f') 1362 && (chars[i] < 'A' || chars[i] > 'F')) { 1363 return false; 1364 } 1365 } 1366 return true; 1367 } else { // leading 0, but not hex, must be octal 1368 int i = start + 1; 1369 for (; i < chars.length; i++) { 1370 if (chars[i] < '0' || chars[i] > '7') { 1371 return false; 1372 } 1373 } 1374 return true; 1375 } 1376 } 1377 sz--; // don't want to loop to the last char, check it afterwords 1378 // for type qualifiers 1379 int i = start; 1380 // loop to the next to last char or to the last char if we need another digit to 1381 // make a valid number (e.g. chars[0..5] = "1234E") 1382 while (i < sz || (i < sz + 1 && allowSigns && !foundDigit)) { 1383 if (chars[i] >= '0' && chars[i] <= '9') { 1384 foundDigit = true; 1385 allowSigns = false; 1386 1387 } else if (chars[i] == '.') { 1388 if (hasDecPoint || hasExp) { 1389 // two decimal points or dec in exponent 1390 return false; 1391 } 1392 hasDecPoint = true; 1393 } else if (chars[i] == 'e' || chars[i] == 'E') { 1394 // we've already taken care of hex. 1395 if (hasExp) { 1396 // two E's 1397 return false; 1398 } 1399 if (!foundDigit) { 1400 return false; 1401 } 1402 hasExp = true; 1403 allowSigns = true; 1404 } else if (chars[i] == '+' || chars[i] == '-') { 1405 if (!allowSigns) { 1406 return false; 1407 } 1408 allowSigns = false; 1409 foundDigit = false; // we need a digit after the E 1410 } else { 1411 return false; 1412 } 1413 i++; 1414 } 1415 if (i < chars.length) { 1416 if (chars[i] >= '0' && chars[i] <= '9') { 1417 // no type qualifier, OK 1418 return true; 1419 } 1420 if (chars[i] == 'e' || chars[i] == 'E') { 1421 // can't have an E at the last byte 1422 return false; 1423 } 1424 if (chars[i] == '.') { 1425 if (hasDecPoint || hasExp) { 1426 // two decimal points or dec in exponent 1427 return false; 1428 } 1429 // single trailing decimal point after non-exponent is ok 1430 return foundDigit; 1431 } 1432 if (!allowSigns 1433 && (chars[i] == 'd' 1434 || chars[i] == 'D' 1435 || chars[i] == 'f' 1436 || chars[i] == 'F')) { 1437 return foundDigit; 1438 } 1439 if (chars[i] == 'l' 1440 || chars[i] == 'L') { 1441 // not allowing L with an exponent or decimal point 1442 return foundDigit && !hasExp && !hasDecPoint; 1443 } 1444 // last character is illegal 1445 return false; 1446 } 1447 // allowSigns is true iff the val ends in 'E' 1448 // found digit it to make sure weird stuff like '.' and '1E-' doesn't pass 1449 return !allowSigns && foundDigit; 1450 } 1451 1452}