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