-
Notifications
You must be signed in to change notification settings - Fork 1.6k
/
NumberUtils.java
1863 lines (1758 loc) · 63.6 KB
/
NumberUtils.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
/*
* 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://www.apache.org/licenses/LICENSE-2.0
*
* 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.lang.reflect.Array;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.math.RoundingMode;
import java.util.Objects;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.Validate;
/**
* Provides extra functionality for Java Number classes.
*
* @since 2.0
*/
public class NumberUtils {
/** Reusable Long constant for zero. */
public static final Long LONG_ZERO = Long.valueOf(0L);
/** Reusable Long constant for one. */
public static final Long LONG_ONE = Long.valueOf(1L);
/** Reusable Long constant for minus one. */
public static final Long LONG_MINUS_ONE = Long.valueOf(-1L);
/** Reusable Integer constant for zero. */
public static final Integer INTEGER_ZERO = Integer.valueOf(0);
/** Reusable Integer constant for one. */
public static final Integer INTEGER_ONE = Integer.valueOf(1);
/** Reusable Integer constant for two */
public static final Integer INTEGER_TWO = Integer.valueOf(2);
/** Reusable Integer constant for minus one. */
public static final Integer INTEGER_MINUS_ONE = Integer.valueOf(-1);
/** Reusable Short constant for zero. */
public static final Short SHORT_ZERO = Short.valueOf((short) 0);
/** Reusable Short constant for one. */
public static final Short SHORT_ONE = Short.valueOf((short) 1);
/** Reusable Short constant for minus one. */
public static final Short SHORT_MINUS_ONE = Short.valueOf((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 = Double.valueOf(0.0d);
/** Reusable Double constant for one. */
public static final Double DOUBLE_ONE = Double.valueOf(1.0d);
/** Reusable Double constant for minus one. */
public static final Double DOUBLE_MINUS_ONE = Double.valueOf(-1.0d);
/** Reusable Float constant for zero. */
public static final Float FLOAT_ZERO = Float.valueOf(0.0f);
/** Reusable Float constant for one. */
public static final Float FLOAT_ONE = Float.valueOf(1.0f);
/** Reusable Float constant for minus one. */
public static final Float FLOAT_MINUS_ONE = Float.valueOf(-1.0f);
/**
* {@link Integer#MAX_VALUE} as a {@link Long}.
*
* @since 3.12.0
*/
public static final Long LONG_INT_MAX_VALUE = Long.valueOf(Integer.MAX_VALUE);
/**
* {@link Integer#MIN_VALUE} as a {@link Long}.
*
* @since 3.12.0
*/
public static final Long LONG_INT_MIN_VALUE = Long.valueOf(Integer.MIN_VALUE);
/**
* Compares two {@code byte} values numerically. This is the same functionality as provided in Java 7.
*
* @param x the first {@code byte} to compare
* @param y the second {@code byte} to compare
* @return the value {@code 0} if {@code x == y};
* a value less than {@code 0} if {@code x < y}; and
* a value greater than {@code 0} if {@code x > y}
* @since 3.4
*/
public static int compare(final byte x, final byte y) {
return x - y;
}
/**
* Compares two {@code int} values numerically. This is the same functionality as provided in Java 7.
*
* @param x the first {@code int} to compare
* @param y the second {@code int} to compare
* @return the value {@code 0} if {@code x == y};
* a value less than {@code 0} if {@code x < y}; and
* a value greater than {@code 0} if {@code x > y}
* @since 3.4
*/
public static int compare(final int x, final int y) {
if (x == y) {
return 0;
}
return x < y ? -1 : 1;
}
/**
* Compares to {@code long} values numerically. This is the same functionality as provided in Java 7.
*
* @param x the first {@code long} to compare
* @param y the second {@code long} to compare
* @return the value {@code 0} if {@code x == y};
* a value less than {@code 0} if {@code x < y}; and
* a value greater than {@code 0} if {@code x > y}
* @since 3.4
*/
public static int compare(final long x, final long y) {
if (x == y) {
return 0;
}
return x < y ? -1 : 1;
}
/**
* Compares to {@code short} values numerically. This is the same functionality as provided in Java 7.
*
* @param x the first {@code short} to compare
* @param y the second {@code short} to compare
* @return the value {@code 0} if {@code x == y};
* a value less than {@code 0} if {@code x < y}; and
* a value greater than {@code 0} if {@code x > y}
* @since 3.4
*/
public static int compare(final short x, final short y) {
if (x == y) {
return 0;
}
return x < y ? -1 : 1;
}
/**
* Creates a {@link BigDecimal} from a {@link String}.
*
* <p>Returns {@code null} if the string is {@code null}.</p>
*
* @param str a {@link String} to convert, may be null
* @return converted {@link BigDecimal} (or null if the input is null)
* @throws NumberFormatException if the value cannot be converted
*/
public static BigDecimal createBigDecimal(final String str) {
if (str == null) {
return null;
}
// handle JDK1.3.1 bug where "" throws IndexOutOfBoundsException
if (StringUtils.isBlank(str)) {
throw new NumberFormatException("A blank string is not a valid number");
}
return new BigDecimal(str);
}
/**
* Creates a {@link BigInteger} from a {@link String}.
*
* Handles hexadecimal (0x or #) and octal (0) notations.
*
* <p>Returns {@code null} if the string is {@code null}.</p>
*
* @param str a {@link String} to convert, may be null
* @return converted {@link BigInteger} (or null if the input is null)
* @throws NumberFormatException if the value cannot be converted
* @since 3.2
*/
public static BigInteger createBigInteger(final String str) {
if (str == null) {
return null;
}
if (str.isEmpty()) {
throw new NumberFormatException("An empty string is not a valid number");
}
int pos = 0; // offset within string
int radix = 10;
boolean negate = false; // need to negate later?
final char char0 = str.charAt(0);
if (char0 == '-') {
negate = true;
pos = 1;
} else if (char0 == '+') {
pos = 1;
}
if (str.startsWith("0x", pos) || str.startsWith("0X", pos)) { // hex
radix = 16;
pos += 2;
} else if (str.startsWith("#", pos)) { // alternative hex (allowed by Long/Integer)
radix = 16;
pos++;
} else if (str.startsWith("0", pos) && str.length() > pos + 1) { // octal; so long as there are additional digits
radix = 8;
pos++;
} // default is to treat as decimal
final BigInteger value = new BigInteger(str.substring(pos), radix);
return negate ? value.negate() : value;
}
/**
* Creates a {@link Double} from a {@link String}.
*
* <p>Returns {@code null} if the string is {@code null}.</p>
*
* @param str a {@link String} to convert, may be null
* @return converted {@link Double} (or null if the input is null)
* @throws NumberFormatException if the value cannot be converted
*/
public static Double createDouble(final String str) {
if (str == null) {
return null;
}
return Double.valueOf(str);
}
/**
* Creates a {@link Float} from a {@link String}.
*
* <p>Returns {@code null} if the string is {@code null}.</p>
*
* @param str a {@link String} to convert, may be null
* @return converted {@link Float} (or null if the input is null)
* @throws NumberFormatException if the value cannot be converted
*/
public static Float createFloat(final String str) {
if (str == null) {
return null;
}
return Float.valueOf(str);
}
/**
* Creates an {@link Integer} from a {@link String}.
*
* Handles hexadecimal (0xhhhh) and octal (0dddd) notations.
* N.B. a leading zero means octal; spaces are not trimmed.
*
* <p>Returns {@code null} if the string is {@code null}.</p>
*
* @param str a {@link String} to convert, may be null
* @return converted {@link Integer} (or null if the input is null)
* @throws NumberFormatException if the value cannot be converted
*/
public static Integer createInteger(final String str) {
if (str == null) {
return null;
}
// decode() handles 0xAABD and 0777 (hex and octal) as well.
return Integer.decode(str);
}
/**
* Creates a {@link Long} from a {@link String}.
*
* Handles hexadecimal (0Xhhhh) and octal (0ddd) notations.
* N.B. a leading zero means octal; spaces are not trimmed.
*
* <p>Returns {@code null} if the string is {@code null}.</p>
*
* @param str a {@link String} to convert, may be null
* @return converted {@link Long} (or null if the input is null)
* @throws NumberFormatException if the value cannot be converted
* @since 3.1
*/
public static Long createLong(final String str) {
if (str == null) {
return null;
}
return Long.decode(str);
}
/**
* Creates a {@link Number} from a {@link String}.
*
* <p>If the string starts with {@code 0x} or {@code -0x} (lower or upper case) or {@code #} or {@code -#}, it
* will be interpreted as a hexadecimal Integer - or Long, if the number of digits after the
* prefix is more than 8 - or BigInteger if there are more than 16 digits.
* </p>
* <p>Then, the value is examined for a type qualifier on the end, i.e. one of
* {@code 'f', 'F', 'd', 'D', 'l', 'L'}. 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 {@link Integer} to
* {@link BigInteger} and from {@link Float} to
* {@link BigDecimal}.</p>
*
* <p>
* Integral values with a leading {@code 0} will be interpreted as octal; the returned number will
* be Integer, Long or BigDecimal as appropriate.
* </p>
*
* <p>Returns {@code null} if the string is {@code null}.</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 (or null if the input is null)
* @throws NumberFormatException if the value cannot be converted
*/
public static Number createNumber(final String str) {
if (str == null) {
return null;
}
if (StringUtils.isBlank(str)) {
throw new NumberFormatException("A blank string is not a valid number");
}
// Need to deal with all possible hex prefixes here
final String[] hexPrefixes = {"0x", "0X", "#"};
final int length = str.length();
final int offset = str.charAt(0) == '+' || str.charAt(0) == '-' ? 1 : 0;
int pfxLen = 0;
for (final String pfx : hexPrefixes) {
if (str.startsWith(pfx, offset)) {
pfxLen += pfx.length() + offset;
break;
}
}
if (pfxLen > 0) { // we have a hex number
char firstSigDigit = 0; // strip leading zeroes
for (int i = pfxLen; i < length; i++) {
firstSigDigit = str.charAt(i);
if (firstSigDigit != '0') {
break;
}
pfxLen++;
}
final int hexDigits = length - pfxLen;
if (hexDigits > 16 || hexDigits == 16 && firstSigDigit > '7') { // too many for Long
return createBigInteger(str);
}
if (hexDigits > 8 || hexDigits == 8 && firstSigDigit > '7') { // too many for an int
return createLong(str);
}
return createInteger(str);
}
final char lastChar = str.charAt(length - 1);
final String mant;
final String dec;
final String exp;
final int decPos = str.indexOf('.');
final int expPos = str.indexOf('e') + str.indexOf('E') + 1; // assumes both not present
// if both e and E are present, this is caught by the checks on expPos (which prevent IOOBE)
// and the parsing which will detect if e or E appear in a number due to using the wrong offset
// Detect if the return type has been requested
final boolean requestType = !Character.isDigit(lastChar) && lastChar != '.';
if (decPos > -1) { // there is a decimal point
if (expPos > -1) { // there is an exponent
if (expPos <= decPos || expPos > length) { // prevents double exponent causing IOOBE
throw new NumberFormatException(str + " is not a valid number.");
}
dec = str.substring(decPos + 1, expPos);
} else {
// No exponent, but there may be a type character to remove
dec = str.substring(decPos + 1, requestType ? length - 1 : length);
}
mant = getMantissa(str, decPos);
} else {
if (expPos > -1) {
if (expPos > length) { // prevents double exponent causing IOOBE
throw new NumberFormatException(str + " is not a valid number.");
}
mant = getMantissa(str, expPos);
} else {
// No decimal, no exponent, but there may be a type character to remove
mant = getMantissa(str, requestType ? length - 1 : length);
}
dec = null;
}
if (requestType) {
if (expPos > -1 && expPos < length - 1) {
exp = str.substring(expPos + 1, length - 1);
} else {
exp = null;
}
//Requesting a specific type.
final String numeric = str.substring(0, length - 1);
switch (lastChar) {
case 'l' :
case 'L' :
if (dec == null
&& exp == null
&& (!numeric.isEmpty() && numeric.charAt(0) == '-' && isDigits(numeric.substring(1)) || isDigits(numeric))) {
try {
return createLong(numeric);
} catch (final NumberFormatException ignored) {
// Too big for a long
}
return createBigInteger(numeric);
}
throw new NumberFormatException(str + " is not a valid number.");
case 'f' :
case 'F' :
try {
final Float f = createFloat(str);
if (!(f.isInfinite() || f.floatValue() == 0.0F && !isZero(mant, dec))) {
//If it's too big for a float or the float value = 0 and the string
//has non-zeros in it, then float does not have the precision we want
return f;
}
} catch (final NumberFormatException ignored) {
// ignore the bad number
}
//$FALL-THROUGH$
case 'd' :
case 'D' :
try {
final Double d = createDouble(str);
if (!(d.isInfinite() || d.doubleValue() == 0.0D && !isZero(mant, dec))) {
return d;
}
} catch (final NumberFormatException ignored) {
// ignore the bad number
}
try {
return createBigDecimal(numeric);
} catch (final NumberFormatException ignored) {
// ignore the bad number
}
//$FALL-THROUGH$
default :
throw new NumberFormatException(str + " is not a valid number.");
}
}
//User doesn't have a preference on the return type, so let's start
//small and go from there...
if (expPos > -1 && expPos < length - 1) {
exp = str.substring(expPos + 1);
} else {
exp = null;
}
if (dec == null && exp == null) { // no decimal point and no exponent
//Must be an Integer, Long, Biginteger
try {
return createInteger(str);
} catch (final NumberFormatException ignored) {
// ignore the bad number
}
try {
return createLong(str);
} catch (final NumberFormatException ignored) {
// ignore the bad number
}
return createBigInteger(str);
}
//Must be a Float, Double, BigDecimal
try {
final Float f = createFloat(str);
final Double d = createDouble(str);
if (!f.isInfinite()
&& !(f.floatValue() == 0.0F && !isZero(mant, dec))
&& f.toString().equals(d.toString())) {
return f;
}
if (!d.isInfinite() && !(d.doubleValue() == 0.0D && !isZero(mant, dec))) {
final BigDecimal b = createBigDecimal(str);
if (b.compareTo(BigDecimal.valueOf(d.doubleValue())) == 0) {
return d;
}
return b;
}
} catch (final NumberFormatException ignored) {
// ignore the bad number
}
return createBigDecimal(str);
}
/**
* Utility method for {@link #createNumber(String)}.
*
* <p>Returns mantissa of the given number.</p>
*
* @param str the string representation of the number
* @param stopPos the position of the exponent or decimal point
* @return mantissa of the given number
* @throws NumberFormatException if no mantissa can be retrieved
*/
private static String getMantissa(final String str, final int stopPos) {
final char firstChar = str.charAt(0);
final boolean hasSign = firstChar == '-' || firstChar == '+';
final int length = str.length();
if (length <= (hasSign ? 1 : 0) || length < stopPos) {
throw new NumberFormatException(str + " is not a valid number.");
}
return hasSign ? str.substring(1, stopPos) : str.substring(0, stopPos);
}
/**
* Utility method for {@link #createNumber(java.lang.String)}.
*
* <p>Returns {@code true} if s is {@code null} or empty.</p>
*
* @param str the String to check
* @return if it is all zeros or {@code null}
*/
private static boolean isAllZeros(final String str) {
if (str == null) {
return true;
}
for (int i = str.length() - 1; i >= 0; i--) {
if (str.charAt(i) != '0') {
return false;
}
}
return true;
}
/**
* Checks whether the String is a valid Java number.
*
* <p>Valid numbers include hexadecimal marked with the {@code 0x} or
* {@code 0X} qualifier, octal numbers, scientific notation and
* numbers marked with a type qualifier (e.g. 123L).</p>
*
* <p>Non-hexadecimal strings beginning with a leading zero are
* treated as octal values. Thus the string {@code 09} will return
* {@code false}, since {@code 9} is not a valid octal value.
* However, numbers beginning with {@code 0.} are treated as decimal.</p>
*
* <p>{@code null} and empty/blank {@link String} will return
* {@code false}.</p>
*
* <p>Note, {@link #createNumber(String)} should return a number for every
* input resulting in {@code true}.</p>
*
* @param str the {@link String} to check
* @return {@code true} if the string is a correctly formatted number
* @since 3.5
*/
public static boolean isCreatable(final String str) {
if (StringUtils.isEmpty(str)) {
return false;
}
final char[] chars = str.toCharArray();
int sz = chars.length;
boolean hasExp = false;
boolean hasDecPoint = false;
boolean allowSigns = false;
boolean foundDigit = false;
// deal with any possible sign up front
final int start = chars[0] == '-' || chars[0] == '+' ? 1 : 0;
if (sz > start + 1 && chars[start] == '0' && !StringUtils.contains(str, '.')) { // leading 0, skip if is a decimal number
if (chars[start + 1] == 'x' || chars[start + 1] == 'X') { // leading 0x/0X
int i = start + 2;
if (i == sz) {
return false; // str == "0x"
}
// checking hex (it can't be anything else)
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;
}
if (Character.isDigit(chars[start + 1])) {
// leading 0, but not hex, must be octal
int i = start + 1;
for (; i < chars.length; i++) {
if (chars[i] < '0' || chars[i] > '7') {
return false;
}
}
return true;
}
}
sz--; // don't want to loop to the last char, check it afterwards
// for type qualifiers
int i = start;
// loop to the next to last char or to the last char if we need another digit to
// make a valid number (e.g. chars[0..5] = "1234E")
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) {
// two decimal points or dec in exponent
return false;
}
hasDecPoint = true;
} else if (chars[i] == 'e' || chars[i] == 'E') {
// we've already taken care of hex.
if (hasExp) {
// two E's
return false;
}
if (!foundDigit) {
return false;
}
hasExp = true;
allowSigns = true;
} else if (chars[i] == '+' || chars[i] == '-') {
if (!allowSigns) {
return false;
}
allowSigns = false;
foundDigit = false; // we need a digit after the E
} else {
return false;
}
i++;
}
if (i < chars.length) {
if (chars[i] >= '0' && chars[i] <= '9') {
// no type qualifier, OK
return true;
}
if (chars[i] == 'e' || chars[i] == 'E') {
// can't have an E at the last byte
return false;
}
if (chars[i] == '.') {
if (hasDecPoint || hasExp) {
// two decimal points or dec in exponent
return false;
}
// single trailing decimal point after non-exponent is ok
return foundDigit;
}
if (!allowSigns
&& (chars[i] == 'd'
|| chars[i] == 'D'
|| chars[i] == 'f'
|| chars[i] == 'F')) {
return foundDigit;
}
if (chars[i] == 'l'
|| chars[i] == 'L') {
// not allowing L with an exponent or decimal point
return foundDigit && !hasExp && !hasDecPoint;
}
// last character is illegal
return false;
}
// allowSigns is true iff the val ends in 'E'
// found digit it to make sure weird stuff like '.' and '1E-' doesn't pass
return !allowSigns && foundDigit;
}
/**
* Checks whether the {@link String} contains only
* digit characters.
*
* <p>{@code null} and empty String will return
* {@code false}.</p>
*
* @param str the {@link String} to check
* @return {@code true} if str contains only Unicode numeric
*/
public static boolean isDigits(final String str) {
return StringUtils.isNumeric(str);
}
/**
* Checks whether the String is a valid Java number.
*
* <p>Valid numbers include hexadecimal marked with the {@code 0x} or
* {@code 0X} qualifier, octal numbers, scientific notation and
* numbers marked with a type qualifier (e.g. 123L).</p>
*
* <p>Non-hexadecimal strings beginning with a leading zero are
* treated as octal values. Thus the string {@code 09} will return
* {@code false}, since {@code 9} is not a valid octal value.
* However, numbers beginning with {@code 0.} are treated as decimal.</p>
*
* <p>{@code null} and empty/blank {@link String} will return
* {@code false}.</p>
*
* <p>Note, {@link #createNumber(String)} should return a number for every
* input resulting in {@code true}.</p>
*
* @param str the {@link String} to check
* @return {@code true} if the string is a correctly formatted number
* @since 3.3 the code supports hexadecimal {@code 0Xhhh} an
* octal {@code 0ddd} validation
* @deprecated This feature will be removed in Lang 4,
* use {@link NumberUtils#isCreatable(String)} instead
*/
@Deprecated
public static boolean isNumber(final String str) {
return isCreatable(str);
}
/**
* Checks whether the given String is a parsable number.
*
* <p>Parsable numbers include those Strings understood by {@link Integer#parseInt(String)},
* {@link Long#parseLong(String)}, {@link Float#parseFloat(String)} or
* {@link Double#parseDouble(String)}. This method can be used instead of catching {@link java.text.ParseException}
* when calling one of those methods.</p>
*
* <p>Hexadecimal and scientific notations are <strong>not</strong> considered parsable.
* See {@link #isCreatable(String)} on those cases.</p>
*
* <p>{@code null} and empty String will return {@code false}.</p>
*
* @param str the String to check.
* @return {@code true} if the string is a parsable number.
* @since 3.4
*/
public static boolean isParsable(final String str) {
if (StringUtils.isEmpty(str)) {
return false;
}
if (str.charAt(str.length() - 1) == '.') {
return false;
}
if (str.charAt(0) == '-') {
if (str.length() == 1) {
return false;
}
return withDecimalsParsing(str, 1);
}
return withDecimalsParsing(str, 0);
}
/**
* Utility method for {@link #createNumber(java.lang.String)}.
*
* <p>This will check if the magnitude of the number is zero by checking if there
* are only zeros before and after the decimal place.</p>
*
* <p>Note: It is <strong>assumed</strong> that the input string has been converted
* to either a Float or Double with a value of zero when this method is called.
* This eliminates invalid input for example {@code ".", ".D", ".e0"}.</p>
*
* <p>Thus the method only requires checking if both arguments are null, empty or
* contain only zeros.</p>
*
* <p>Given {@code s = mant + "." + dec}:</p>
* <ul>
* <li>{@code true} if s is {@code "0.0"}
* <li>{@code true} if s is {@code "0."}
* <li>{@code true} if s is {@code ".0"}
* <li>{@code false} otherwise (this assumes {@code "."} is not possible)
* </ul>
*
* @param mant the mantissa decimal digits before the decimal point (sign must be removed; never null)
* @param dec the decimal digits after the decimal point (exponent and type specifier removed;
* can be null)
* @return true if the magnitude is zero
*/
private static boolean isZero(final String mant, final String dec) {
return isAllZeros(mant) && isAllZeros(dec);
}
/**
* Returns the maximum value in an array.
*
* @param array an array, must not be null or empty
* @return the maximum value in the array
* @throws NullPointerException if {@code array} is {@code null}
* @throws IllegalArgumentException if {@code array} is empty
* @since 3.4 Changed signature from max(byte[]) to max(byte...)
*/
public static byte max(final byte... array) {
// Validates input
validateArray(array);
// Finds and returns max
byte max = array[0];
for (int i = 1; i < array.length; i++) {
if (array[i] > max) {
max = array[i];
}
}
return max;
}
/**
* Gets the maximum of three {@code byte} values.
*
* @param a value 1
* @param b value 2
* @param c value 3
* @return the largest of the values
*/
public static byte max(byte a, final byte b, final byte c) {
if (b > a) {
a = b;
}
if (c > a) {
a = c;
}
return a;
}
/**
* Returns the maximum value in an array.
*
* @param array an array, must not be null or empty
* @return the maximum value in the array
* @throws NullPointerException if {@code array} is {@code null}
* @throws IllegalArgumentException if {@code array} is empty
* @see IEEE754rUtils#max(double[]) IEEE754rUtils for a version of this method that handles NaN differently
* @since 3.4 Changed signature from max(double[]) to max(double...)
*/
public static double max(final double... array) {
// Validates input
validateArray(array);
// Finds and returns max
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;
}
/**
* Gets the maximum of three {@code double} values.
*
* <p>If any value is {@code NaN}, {@code NaN} 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(final double a, final double b, final double c) {
return Math.max(Math.max(a, b), c);
}
/**
* Returns the maximum value in an array.
*
* @param array an array, must not be null or empty
* @return the maximum value in the array
* @throws NullPointerException if {@code array} is {@code null}
* @throws IllegalArgumentException if {@code array} is empty
* @see IEEE754rUtils#max(float[]) IEEE754rUtils for a version of this method that handles NaN differently
* @since 3.4 Changed signature from max(float[]) to max(float...)
*/
public static float max(final float... array) {
// Validates input
validateArray(array);
// Finds and returns max
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;
}
// must handle Long, Float, Integer, Float, Short,
// BigDecimal, BigInteger and Byte
// useful methods:
// Byte.decode(String)
// Byte.valueOf(String, int radix)
// Byte.valueOf(String)
// Double.valueOf(String)
// Float.valueOf(String)
// Float.valueOf(String)
// Integer.valueOf(String, int radix)
// Integer.valueOf(String)
// Integer.decode(String)
// Integer.getInteger(String)
// Integer.getInteger(String, int val)
// Integer.getInteger(String, Integer val)
// Integer.valueOf(String)
// Double.valueOf(String)
// new Byte(String)
// Long.valueOf(String)
// Long.getLong(String)
// Long.getLong(String, int)
// Long.getLong(String, Integer)
// Long.valueOf(String, int)
// Long.valueOf(String)
// Short.valueOf(String)
// Short.decode(String)
// Short.valueOf(String, int)
// Short.valueOf(String)
// new BigDecimal(String)
// new BigInteger(String)
// new BigInteger(String, int radix)
// Possible inputs:
// 45 45.5 45E7 4.5E7 Hex Oct Binary xxxF xxxD xxxf xxxd
// plus minus everything. Prolly more. A lot are not separable.
/**
* Gets the maximum of three {@code float} values.
*
* <p>If any value is {@code NaN}, {@code NaN} 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(final float a, final float b, final float c) {
return Math.max(Math.max(a, b), c);
}
/**
* Returns the maximum value in an array.
*
* @param array an array, must not be null or empty
* @return the maximum value in the array
* @throws NullPointerException if {@code array} is {@code null}
* @throws IllegalArgumentException if {@code array} is empty
* @since 3.4 Changed signature from max(int[]) to max(int...)
*/
public static int max(final int... array) {
// Validates input
validateArray(array);
// Finds and returns max
int max = array[0];
for (int j = 1; j < array.length; j++) {
if (array[j] > max) {
max = array[j];
}
}
return max;
}
/**
* Gets the maximum of three {@code int} values.
*
* @param a value 1
* @param b value 2
* @param c value 3
* @return the largest of the values
*/
public static int max(int a, final int b, final int c) {
if (b > a) {
a = b;
}
if (c > a) {
a = c;
}
return a;
}
/**
* Returns the maximum value in an array.
*
* @param array an array, must not be null or empty
* @return the maximum value in the array
* @throws NullPointerException if {@code array} is {@code null}
* @throws IllegalArgumentException if {@code array} is empty
* @since 3.4 Changed signature from max(long[]) to max(long...)
*/
public static long max(final long... array) {
// Validates input
validateArray(array);
// Finds and returns max
long max = array[0];
for (int j = 1; j < array.length; j++) {
if (array[j] > max) {
max = array[j];
}