Methods for number conversion and parsing : Number « Data Type « Java

Home
Java
1.2D Graphics GUI
2.3D
3.Advanced Graphics
4.Ant
5.Apache Common
6.Chart
7.Class
8.Collections Data Structure
9.Data Type
10.Database SQL JDBC
11.Design Pattern
12.Development Class
13.EJB3
14.Email
15.Event
16.File Input Output
17.Game
18.Generics
19.GWT
20.Hibernate
21.I18N
22.J2EE
23.J2ME
24.JDK 6
25.JNDI LDAP
26.JPA
27.JSP
28.JSTL
29.Language Basics
30.Network Protocol
31.PDF RTF
32.Reflection
33.Regular Expressions
34.Scripting
35.Security
36.Servlets
37.Spring
38.Swing Components
39.Swing JFC
40.SWT JFace Eclipse
41.Threads
42.Tiny Application
43.Velocity
44.Web Services SOA
45.XML
Java » Data Type » NumberScreenshots 
Methods for number conversion and parsing
     
/*
 * Copyright 2002-2006 the original author or authors.
 *
 * Licensed 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.
 */


import java.math.BigDecimal;
import java.math.BigInteger;
import java.text.NumberFormat;
import java.text.ParseException;

/**
 * Miscellaneous utility methods for number conversion and parsing.
 * Mainly for internal use within the framework; consider Jakarta's
 * Commons Lang for a more comprehensive suite of string utilities.
 *
 @author Juergen Hoeller
 @author Rob Harrop
 @since 1.1.2
 */
public abstract class NumberUtils {

  /**
   * Convert the given number into an instance of the given target class.
   @param number the number to convert
   @param targetClass the target class to convert to
   @return the converted number
   @throws IllegalArgumentException if the target class is not supported
   * (i.e. not a standard Number subclass as included in the JDK)
   @see java.lang.Byte
   @see java.lang.Short
   @see java.lang.Integer
   @see java.lang.Long
   @see java.math.BigInteger
   @see java.lang.Float
   @see java.lang.Double
   @see java.math.BigDecimal
   */
  public static Number convertNumberToTargetClass(Number number, Class targetClass)
      throws IllegalArgumentException {


    if (targetClass.isInstance(number)) {
      return number;
    }
    else if (targetClass.equals(Byte.class)) {
      long value = number.longValue();
      if (value < Byte.MIN_VALUE || value > Byte.MAX_VALUE) {
        raiseOverflowException(number, targetClass);
      }
      return new Byte(number.byteValue());
    }
    else if (targetClass.equals(Short.class)) {
      long value = number.longValue();
      if (value < Short.MIN_VALUE || value > Short.MAX_VALUE) {
        raiseOverflowException(number, targetClass);
      }
      return new Short(number.shortValue());
    }
    else if (targetClass.equals(Integer.class)) {
      long value = number.longValue();
      if (value < Integer.MIN_VALUE || value > Integer.MAX_VALUE) {
        raiseOverflowException(number, targetClass);
      }
      return new Integer(number.intValue());
    }
    else if (targetClass.equals(Long.class)) {
      return new Long(number.longValue());
    }
    else if (targetClass.equals(Float.class)) {
      return new Float(number.floatValue());
    }
    else if (targetClass.equals(Double.class)) {
      return new Double(number.doubleValue());
    }
    else if (targetClass.equals(BigInteger.class)) {
      return BigInteger.valueOf(number.longValue());
    }
    else if (targetClass.equals(BigDecimal.class)) {
      // using BigDecimal(String) here, to avoid unpredictability of BigDecimal(double)
      // (see BigDecimal javadoc for details)
      return new BigDecimal(number.toString());
    }
    else {
      throw new IllegalArgumentException("Could not convert number [" + number + "] of type [" +
          number.getClass().getName() "] to unknown target class [" + targetClass.getName() "]");
    }
  }

  /**
   * Raise an overflow exception for the given number and target class.
   @param number the number we tried to convert
   @param targetClass the target class we tried to convert to
   */
  private static void raiseOverflowException(Number number, Class targetClass) {
    throw new IllegalArgumentException("Could not convert number [" + number + "] of type [" +
        number.getClass().getName() "] to target class [" + targetClass.getName() "]: overflow");
  }

  /**
   * Parse the given text into a number instance of the given target class,
   * using the corresponding default <code>decode</code> methods. Trims the
   * input <code>String</code> before attempting to parse the number. Supports
   * numbers in hex format (with leading 0x) and in octal format (with leading 0).
   @param text the text to convert
   @param targetClass the target class to parse into
   @return the parsed number
   @throws IllegalArgumentException if the target class is not supported
   * (i.e. not a standard Number subclass as included in the JDK)
   @see java.lang.Byte#decode
   @see java.lang.Short#decode
   @see java.lang.Integer#decode
   @see java.lang.Long#decode
   @see #decodeBigInteger(String)
   @see java.lang.Float#valueOf
   @see java.lang.Double#valueOf
   @see java.math.BigDecimal#BigDecimal(String)
   */
  public static Number parseNumber(String text, Class targetClass) {


    String trimmed = text.trim();

    if (targetClass.equals(Byte.class)) {
      return Byte.decode(trimmed);
    }
    else if (targetClass.equals(Short.class)) {
      return Short.decode(trimmed);
    }
    else if (targetClass.equals(Integer.class)) {
      return Integer.decode(trimmed);
    }
    else if (targetClass.equals(Long.class)) {
      return Long.decode(trimmed);
    }
    else if (targetClass.equals(BigInteger.class)) {
      return decodeBigInteger(trimmed);
    }
    else if (targetClass.equals(Float.class)) {
      return Float.valueOf(trimmed);
    }
    else if (targetClass.equals(Double.class)) {
      return Double.valueOf(trimmed);
    }
    else if (targetClass.equals(BigDecimal.class|| targetClass.equals(Number.class)) {
      return new BigDecimal(trimmed);
    }
    else {
      throw new IllegalArgumentException(
          "Cannot convert String [" + text + "] to target class [" + targetClass.getName() "]");
    }
  }

  /**
   * Parse the given text into a number instance of the given target class,
   * using the given NumberFormat. Trims the input <code>String</code>
   * before attempting to parse the number.
   @param text the text to convert
   @param targetClass the target class to parse into
   @param numberFormat the NumberFormat to use for parsing (if <code>null</code>,
   * this method falls back to <code>parseNumber(String, Class)</code>)
   @return the parsed number
   @throws IllegalArgumentException if the target class is not supported
   * (i.e. not a standard Number subclass as included in the JDK)
   @see java.text.NumberFormat#parse
   @see #convertNumberToTargetClass
   @see #parseNumber(String, Class)
   */
  public static Number parseNumber(String text, Class targetClass, NumberFormat numberFormat) {
    if (numberFormat != null) {

      try {
        Number number = numberFormat.parse(text.trim());
        return convertNumberToTargetClass(number, targetClass);
      }
      catch (ParseException ex) {
        throw new IllegalArgumentException(ex.getMessage());
      }
    }
    else {
      return parseNumber(text, targetClass);
    }
  }

  /**
   * Decode a {@link java.math.BigInteger} from a {@link String} value.
   * Supports decimal, hex and octal notation.
   @see BigInteger#BigInteger(String, int)
   */
  private static BigInteger decodeBigInteger(String value) {
    int radix = 10;
    int index = 0;
    boolean negative = false;

    // Handle minus sign, if present.
    if (value.startsWith("-")) {
      negative = true;
      index++;
    }

    // Handle radix specifier, if present.
    if (value.startsWith("0x", index|| value.startsWith("0X", index)) {
      index += 2;
      radix = 16;
    }
    else if (value.startsWith("#", index)) {
      index++;
      radix = 16;
    }
    else if (value.startsWith("0", index&& value.length() + index) {
      index++;
      radix = 8;
    }

    BigInteger result = new BigInteger(value.substring(index), radix);
    return (negative ? result.negate() : result);
  }

}

   
    
    
    
    
  
Related examples in the same category
1.Get Digit Number String
2.Convert to numbers
3.Check Number properties and convert from Number
4.Check if number are in a given range
5.Various number-related routines and classes that are frequently used
6.Turns a string value into a java.lang.Number.
7.Provides IEEE-754r variants of NumberUtils methods.
8.Checks whether the String a valid Java number.
9.Specifies sizes of various types in bytes.
10.Class to represent 16-bit unsigned integers.
11.Implements an integer object wrapper which allows changing the integer value.Implements an integer object wrapper which allows changing the integer value.
12.Mixed Radix Number
13.This class allows a number to be converted to it's unsigned value.
14.Numbers will be equals if enough decimals are equals, without thinking about approximations.
15.Ternary Numnber
16.Implements a long object wrapper which allows changing the long value.
17.Convert the given number into an instance of the given target class.
java2s.com  | Contact Us | Privacy Policy
Copyright 2009 - 12 Demo Source and Support. All rights reserved.
All other trademarks are property of their respective owners.