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