Java Tutorial/Data Type/Float

Check if a string is a valid number

public class Main {
  public static void main(String[] argv) throws Exception {
    String age = "1";
    String height = "1.5";
    String weight = "5.9";
    int theAge = Integer.parseInt(age);
    float theHeight = Float.parseFloat(height);
    double theWeight = Double.parseDouble(weight);
    System.out.println("Age: " + theAge);
    System.out.println("Height: " + theHeight);
    System.out.println("Weight: " + theWeight);
  }
}

Compares two floats for order.

import java.math.BigDecimal;
import java.math.BigInteger;
/**
 * 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.
 */

/**
 * Provides extra functionality for Java Number classes.
 *
 * @author 
 * @author Eric Pugh
 * @author Phil Steitz
 * @since 1.0
 * @version $Id: NumberUtils.java 488819 2006-12-19 21:50:04Z bayard $
 * 
 */
public class Main {




  
  /**
   * Compares two floats for order.
   *
   * This method is more comprehensive than the standard Java greater than,
   * less than and equals operators.
   * <ul>
   *  <li>It returns <code>-1</code> if the first value is less than the second.
   *  <li>It returns <code>+1</code> if the first value is greater than the second.
   *  <li>It returns <code>0</code> if the values are equal.
   * </ul>
   *
   *  The ordering is as follows, largest to smallest:
   * <ul>
   * <li>NaN
   * <li>Positive infinity
   * <li>Maximum float
   * <li>Normal positive numbers
   * <li>+0.0
   * <li>-0.0
   * <li>Normal negative numbers
   * <li>Minimum float (-Float.MAX_VALUE)
   * <li>Negative infinity
   * </ul>
   *
   * Comparing <code>NaN</code> with <code>NaN</code> will return
   * <code>0</code>.
   * 
   * @param lhs  the first <code>float</code>
   * @param rhs  the second <code>float</code>
   * @return <code>-1</code> if lhs is less, <code>+1</code> if greater,
   *  <code>0</code> if equal to rhs
   */
  public static int compare(float lhs, float rhs) {
      if (lhs < rhs) {
          return -1;
      }
      if (lhs > rhs) {
          return +1;
      }
      //Need to compare bits to handle 0.0 == -0.0 being true
      // compare should put -0.0 < +0.0
      // Two NaNs are also == for compare purposes
      // where NaN == NaN is false
      int lhsBits = Float.floatToIntBits(lhs);
      int rhsBits = Float.floatToIntBits(rhs);
      if (lhsBits == rhsBits) {
          return 0;
      }
      //Something exotic! A comparison to NaN or 0.0 vs -0.0
      //Fortunately NaN"s int is > than everything else
      //Also negzeros bits < poszero
      //NAN: 2143289344
      //MAX: 2139095039
      //NEGZERO: -2147483648
      if (lhsBits < rhsBits) {
          return -1;
      } else {
          return +1;
      }
  }
}

Compare Two Java float Arrays

import java.util.Arrays;
public class Main {
  public static void main(String[] args) {
    float[] a1 = new float[] { 4.4f, 3.3f, 5.3f };
    float[] a2 = new float[] { 4.4f, 3.3f, 5.3f };
    System.out.println(Arrays.equals(a1, a2));
  }
}

Convert from float to String

public class Main {
  public static void main(String[] args) throws Exception {
    String str = Float.toString(0.3F);
  }
}

Convert from String to float

public class Main {
  public static void main(String[] args) throws Exception {
    Float f = Float.valueOf("0.2").floatValue();
  }
}

Converting a String to a float type Number

public class Main {
  public static void main(String[] argv) throws Exception {
    float f = Float.parseFloat("123.4");
    System.out.println(f);
  }
}

Convert Java Float to Numeric Primitive Data Types

public class Main {
  public static void main(String[] args) {
    Float fObj = new Float("10.50");
    byte b = fObj.byteValue();
    System.out.println(b);
    short s = fObj.shortValue();
    System.out.println(s);
    int i = fObj.intValue();
    System.out.println(i);
    float f = fObj.floatValue();
    System.out.println(f);
    double d = fObj.doubleValue();
    System.out.println(d);
  }
}

Convert Java String to Float Object

public class Main {
  public static void main(String[] args) {
    Float fObj1 = new Float("10.64");
    System.out.println(fObj1);
    Float fObj2 = Float.valueOf("10.76");
    System.out.println(fObj2);
    float f = Float.parseFloat("7.39");
    System.out.println(f);
  }
}
/*
10.64
10.76
7.39
*/

Declaring a variable of type float

public class MainClass{
  public static void main(String[] arg){
    float f1 = 9E-28F;
    System.out.println(f1);
  }
}

9.0E-28

Declaring more than one float variable in a single statement

public class MainClass {
  public static void main(String[] arg) {
    float f1 = 185.2F, f2 = 108.5F;
    System.out.println(f1);
    System.out.println(f2);
  }
}

185.2
108.5

Floating�Point Types

public class Main {
  public static void main(String[] args) {
    double pi = 3.14159;
    float f = 2.2F;
    System.out.println("pi = " + pi);
    System.out.println("f = " + f);
    int n = 15, d = 4;
    f = n / d;
    System.out.println("15/4 = " + f);
    
    int radius = 10;
    double area = pi * radius * radius;
    System.out.println("area = " + area);
  }
}

For a float value x, this method returns +f x >= 0 and -f Returns NaN if x is NaN.

import java.io.File;
/* 
 * 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.
 *
 *
 */
public class Main {
  /**
   * For a float value x, this method returns +1.0F if x >= 0 and -1.0F if x <
   * 0. Returns <code>NaN</code> if <code>x</code> is <code>NaN</code>.
   * 
   * @param x the value, a float
   * @return +1.0F or -1.0F, depending on the sign of x
   */
  public static float indicator(final float x) {
      if (Float.isNaN(x)) {
          return Float.NaN;
      }
      return (x >= 0.0F) ? 1.0F : -1.0F;
  }
}

Java Float Comparison

public class Main {
  public static void main(String[] args) {
    float f1 = 5.5f;
    float f2 = 5.4f;
    int i1 = Float.rupare(f1, f2);
    if (i1 > 0) {
      System.out.println(">");
    } else if (i1 < 0) {
      System.out.println("<");
    } else {
      System.out.println("=");
    }
    Float fObj1 = new Float("5.5");
    Float fObj2 = new Float("5.4");
    int i2 = fObj1.rupareTo(fObj2);
    if (i2 > 0) {
      System.out.println(">");
    } else if (i2 < 0) {
      System.out.println("<");
    } else {
      System.out.println("=");
    }
  }
}

Java float is 32 bit single precision type and used when fractional precision calculation is required.

public class Main {
  public static void main(String[] args) {
    float f = 12.3f;
    System.out.println("Value of float variable f is :" + f);
  }
}
//Value of float variable f is :12.3

Java Float isInfinite Method

public class Main {
  public static void main(String[] args) {
    float f = (float) 1 / 0;
    boolean b1 = Float.isInfinite(f);
    System.out.println(b1);
    Float fObj = new Float(f);
    boolean b2 = fObj.isInfinite();
    System.out.println(b2);
  }
}

Java Float isNaN Method

public class Main {
  public static void main(String[] args) {
    float f = (float) Math.sqrt(-10);
    boolean b1 = Float.isNaN(f);
    System.out.println(b1);
    Float fObj = new Float(f);
    boolean b2 = fObj.isNaN();
    System.out.println(b2);
  }
}

Java Float Wrapper Class

public class Main {
  public static void main(String[] args) {
    float f = 10.10f;
    Float fObj1 = new Float(f);
    System.out.println(fObj1);
    double d = 10.10;
    Float fObj2 = new Float(d);
    System.out.println(fObj2);
    Float fObj3 = new Float("25.34");
    System.out.println(fObj3);
  }
}

Min and Max values of data type float

public class Main {
  public static void main(String[] args) {
    System.out.println(Float.MIN_VALUE);
    System.out.println(Float.MAX_VALUE);
  }
}
/*
1.4E-45
3.4028235E38
*/

Pass floats as string literals to a method

public class Main {
  public static void main(String[] argv) {
    System.out.println(0.1f);
  }
}

Tests two float arrays for equality.

import java.util.Arrays;
/* 
 * JCommon : a free general purpose class library for the Java(tm) platform
 * 
 *
 * (C) Copyright 2000-2005, by Object Refinery Limited and Contributors.
 *
 * Project Info:  http://www.jfree.org/jcommon/index.html
 *
 * This library is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation; either version 2.1 of the License, or
 * (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
 * License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301,
 * USA.
 *
 * [Java is a trademark or registered trademark of Sun Microsystems, Inc.
 * in the United States and other countries.]
 *
 * -------------------
 * ArrayUtilities.java
 * -------------------
 * (C) Copyright 2003-2005, by Object Refinery Limited.
 *
 * Original Author:  David Gilbert (for Object Refinery Limited);
 * Contributor(s):   -;
 *
 * $Id: ArrayUtilities.java,v 1.7 2008/09/10 09:21:30 mungady Exp $
 *
 * Changes
 * -------
 * 21-Aug-2003 : Version 1 (DG);
 * 04-Oct-2004 : Renamed ArrayUtils --> ArrayUtilities (DG);
 *
 */
public class Main {
  /**
   * Tests two float arrays for equality.
   *
   * @param array1  the first array (<code>null</code> permitted).
   * @param array2  the second arrray (<code>null</code> permitted).
   *
   * @return A boolean.
   */
  public static boolean equal(final float[][] array1,
                              final float[][] array2) {
      if (array1 == null) {
          return (array2 == null);
      }
      if (array2 == null) {
          return false;
      }
      if (array1.length != array2.length) {
          return false;
      }
      for (int i = 0; i < array1.length; i++) {
          if (!Arrays.equals(array1[i], array2[i])) {
              return false;
          }
      }
      return true;
  }
}

Use Float constructor to convert float primitive type to a Float object.

public class Main {
  public static void main(String[] args) {
    float f = 10.56f;
    Float fObj = new Float(f);
    System.out.println(fObj);
  }
}

Use Float.valueOf to convert string value to float

/*
 * Copyright (c) 1995 - 2008 Sun Microsystems, Inc.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *   - Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *
 *   - Redistributions in binary form must reproduce the above copyright
 *     notice, this list of conditions and the following disclaimer in the
 *     documentation and/or other materials provided with the distribution.
 *
 *   - Neither the name of Sun Microsystems nor the names of its
 *     contributors may be used to endorse or promote products derived
 *     from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
 * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
public class ValueOfDemo {
  public static void main(String[] args) {
    // this program requires two arguments on the command line
    if (args.length == 2) {
      // convert strings to numbers
      float a = (Float.valueOf(args[0])).floatValue();
      float b = (Float.valueOf(args[1])).floatValue();
      // do some arithmetic
      System.out.println("a + b = " + (a + b));
      System.out.println("a - b = " + (a - b));
      System.out.println("a * b = " + (a * b));
      System.out.println("a / b = " + (a / b));
      System.out.println("a % b = " + (a % b));
    } else {
      System.out.println("This program requires two command-line arguments.");
    }
  }
}

Use System.out.printf to format float point number

/*
 * Copyright (c) 1995 - 2008 Sun Microsystems, Inc.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *   - Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *
 *   - Redistributions in binary form must reproduce the above copyright
 *     notice, this list of conditions and the following disclaimer in the
 *     documentation and/or other materials provided with the distribution.
 *
 *   - Neither the name of Sun Microsystems nor the names of its
 *     contributors may be used to endorse or promote products derived
 *     from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
 * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
public class ExponentialDemo {
  public static void main(String[] args) {
    double x = 11.635;
    double y = 2.76;
    System.out.printf("The value of e is %.4f%n", Math.E);
    System.out.printf("exp(%.3f) is %.3f%n", x, Math.exp(x));
    System.out.printf("log(%.3f) is %.3f%n", x, Math.log(x));
    System.out.printf("pow(%.3f, %.3f) is %.3f%n", x, y, Math.pow(x, y));
    System.out.printf("sqrt(%.3f) is %.3f%n", x, Math.sqrt(x));
  }
}

Use toString method of Float class to convert Float into String.

public class Main {
  public static void main(String[] args) {
    Float fObj = new Float(10.25);
    String str = fObj.toString();
    System.out.println(str);
  }
}