Java/Data Type/float

Материал из Java эксперт
Перейти к: навигация, поиск

Check if a string is a valid number

   <source lang="java">

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);
 }

} 



 </source>



Clones a two dimensional array of floats.

   <source lang="java">

/* 

* 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 { 

 /**
  * Clones a two dimensional array of floats.
  *
  * @param array  the array.
  *
  * @return A clone of the array.
  */
 public static float[][] clone(final float[][] array) {
     if (array == null) {
         return null;
     }
     final float[][] result = new float[array.length][];
     System.arraycopy(array, 0, result, 0, array.length);
     for (int i = 0; i < array.length; i++) {
         final float[] child = array[i];
         final float[] copychild = new float[child.length];
         System.arraycopy(child, 0, copychild, 0, child.length);
         result[i] = copychild;
     }
     return result;
 }

} 


 </source>



Compares two floats for order.

   <source lang="java">

/* 

* 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 
* @since 2.0
* @version $Id: NumberUtils.java 609475 2008-01-06 23:58:59Z 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.

*
    *
  • It returns -1 if the first value is less than the second. *
  • It returns +1 if the first value is greater than the second. *
  • It returns 0 if the values are equal. * 
  *
*

The ordering is as follows, largest to smallest: *

    *
  • NaN *
  • Positive infinity *
  • Maximum float *
  • Normal positive numbers *
  • +0.0 *
  • -0.0 *
  • Normal negative numbers *
  • Minimum float (-Float.MAX_VALUE) *
  • Negative infinity * 
  *
  * <p>Comparing NaN with NaN will return
* 0.

  * 
  * @param lhs  the first float
  * @param rhs  the second float
  * @return -1 if lhs is less, +1 if greater,
  *  0 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;
     }
 }

} 



 </source>



Compare Two Java float Arrays

   <source lang="java">

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));
 }

} 



 </source>



convert Fahrenheit to Celsius back and forth with float

   <source lang="java">

public class Weather { 

 public static void main(String[] arguments) {
   float fah = 86;
   System.out.println(fah + " degrees Fahrenheit is ...");
   fah = fah - 32;
   fah = fah / 9;
   fah = fah * 5;
   System.out.println(fah + " degrees Celsius\n");
   float cel = 33;
   System.out.println(cel + " degrees Celsius is ...");
   cel = cel * 9;
   cel = cel / 5;
   cel = cel + 32;
   System.out.println(cel + " degrees Fahrenheit");
 }

} 




 </source>



Convert from float to String

   <source lang="java">

public class Main { 

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

} 



 </source>



Convert from String to float

   <source lang="java">

public class Main { 

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

} 



 </source>



Converting a String to a float type Number

   <source lang="java">

public class Main { 

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

} 



 </source>



Convert Java Float to Numeric Primitive Data Types

   <source lang="java">

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);
 }

} 



 </source>



Convert Java String to Float Object

   <source lang="java">

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

  • /



 </source>



Float class creates primitives that wrap themselves around data items of the float data type

   <source lang="java">

public class MainClass { 

 public static void main(String[] args) {
   float f = -29.6f;
   Float f2 = new Float(f);
   System.out.println(f2.floatValue());
 }

} 



 </source>



Float compare to

   <source lang="java">

/* From http://java.sun.ru/docs/books/tutorial/index.html */ /* 

* Copyright (c) 2006 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:
*
* -Redistribution of source code must retain the above copyright notice, this
*  list of conditions and the following disclaimer.
*
* -Redistribution 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, Inc. or the names of contributors may
* be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* This software is provided "AS IS," without a warranty of any kind. ALL
* EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES, INCLUDING
* ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
* OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN MIDROSYSTEMS, INC. ("SUN")
* AND ITS LICENSORS SHALL NOT BE LIABLE FOR ANY DAMAGES SUFFERED BY LICENSEE
* AS A RESULT OF USING, MODIFYING OR DISTRIBUTING THIS SOFTWARE OR ITS
* DERIVATIVES. IN NO EVENT WILL SUN OR ITS LICENSORS BE LIABLE FOR ANY LOST
* REVENUE, PROFIT OR DATA, OR FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL,
* INCIDENTAL OR PUNITIVE DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY
* OF LIABILITY, ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE,
* EVEN IF SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
*
* You acknowledge that this software is not designed, licensed or intended
* for use in the design, construction, operation or maintenance of any
* nuclear facility.
*/

public class NumberDemo { 

 public static void main(String args[]) {
   Float one = new Float(14.78f - 13.78f);
   Float oneAgain = Float.valueOf("1.0");
   Double doubleOne = new Double(1.0);
   int difference = one.rupareTo(oneAgain);
   if (difference == 0) {
     System.out.println("one is equal to oneAgain.");
   } else if (difference < 0) {
     System.out.println("one is less than oneAgain.");
   } else if (difference > 0) {
     System.out.println("one is greater than oneAgain.");
   }
   System.out.println("one is "
       + ((one.equals(doubleOne)) ? "equal" : "not equal")
       + " to doubleOne.");
 }

} 




 </source>



Float Double Time

   <source lang="java">

public class FloatDoubleTime { 

 /** How many times to do the loop */
 protected static final int HOW_MANY = 10000000;
 public static void main(String[] args) {
   long t0 = System.currentTimeMillis();
   float f = 0;
   for (int i=0; i<HOW_MANY; i++)
     f *= i;
   long t1 = System.currentTimeMillis();
   double d = 0;
   for (int i=0; i<HOW_MANY; i++)
     d *= i;
   long t2 = System.currentTimeMillis();
   System.out.println("Float:  " + (t1 - t0) + " " + f);
   System.out.println("Double: " + (t2 - t1) + " " + d);
 }

} 




 </source>



Floating pioint comparisons

   <source lang="java">

class MainClass { 

 public static void main(String[] args) {
   double num1 = -0.0;
   double num2 = 0.0;
   double sqrPos = Math.sqrt(4.0);
   double sqrNeg1 = Math.sqrt(-4.0);
   double sqrNeg2 = Math.sqrt(-9.0);
   System.out.println("Using == to compare 0.0 and -0.0 ");
   if (num1 == num2)
     System.out.println("numbers are equal");
   else
     System.out.println("numbers are not equal");
   Double n1 = new Double(num1);
   Double n2 = new Double(num2);
   System.out.println("Using equals() method to compare 0.0 and -0.0 ");
   if (n1.equals(n2))
     System.out.println("numbers are equal");
   else
     System.out.println("numbers are not equal");
   Double sp1 = new Double(sqrPos);
   Double sn1 = new Double(sqrNeg1);
   Double sn2 = new Double(sqrNeg2);
   System.out.println("Using equals() method to compare two NaNs ");
   if (sn1.equals(sn2))
     System.out.println("NaNs are equal");
   else
     System.out.println("NaNs are not equal");
 }

} 




 </source>



Floating-point comparisons

   <source lang="java">

/** 

* Floating-point comparisons.
* @author Ian F. Darwin, http://www.darwinsys.ru/
* @version $Id: FloatCmp.java,v 1.11 2004/02/09 03:33:56 ian Exp $
*/

public class FloatCmp { 

 final static double EPSILON = 0.0000001;
 public static void main(String[] argv) {
   double da = 3 * .3333333333;
   double db = 0.99999992857;
   // Compare two numbers that are expected to be close.
   if (da == db) {
     System.out.println("Java considers " + da + "==" + db);
   // else compare with our own equals method
   } else if (equals(da, db, 0.0000001)) {
     System.out.println("True within epsilon " + EPSILON);
   } else {
     System.out.println(da + " != " + db);
   }
   // Show that comparing two NaNs is not a good idea:
   double d1 = Double.NaN;
   double d2 = Double.NaN;
   if (d1 == d2)
     System.err.println("Comparing two NaNs incorrectly returns true.");
   if (!new Double(d1).equals(new Double(d2)))
     System.err.println("Double(NaN).equal(NaN) incorrectly returns false.");
 }
 /** Compare two doubles within a given epsilon */
 public static boolean equals(double a, double b, double eps) {
   if (a==b) return true;
   // If the difference is less than epsilon, treat as equal.
   return Math.abs(a - b) < eps;
 }
 /** Compare two doubles, using default epsilon */
 public static boolean equals(double a, double b) {
   if (a==b) return true;
   // If the difference is less than epsilon, treat as equal.
   return Math.abs(a - b) < EPSILON * Math.max(Math.abs(a), Math.abs(b));
 }

} 




 </source>



Floating-point error diagnostics

   <source lang="java">

/* Java Programming for Engineers Julio Sanchez Maria P. Canton

ISBN: 0849308100 Publisher: CRC Press

  • /

// Java for Engineers //Filename: FpError //Reference: Chapter 24 //Description: // Floating-pioint error diagnostics //Requires: // Keyin class in current directory

class FpError { 

 public static void main(String[] args) {
   double res;
   double divisor = 0;
   double dividend, root;
   // Get user input for numerator
   System.out.println("Forcing division by zero error");
   dividend = 10d;
   res = dividend / divisor;
   // Test for negative invifinity
   if (res == Double.NEGATIVE_INFINITY)
     System.out.println("result is NEGATIVE_INFINITY");
   if (res == Double.POSITIVE_INFINITY)
     System.out.println("result is POSITIVE_INFINITY");
   // Test for either infinity
   if (Double.isInfinite(res))
     System.out.println("result is infinite");
   // Get user input for square root
   System.out.println("\nCalculating square root (try negative)");
   root = 10d;
   res = Math.sqrt(root);
   if (Double.isNaN(res))
     System.out.println("result is Nan");
   else
     System.out.println("Square root = " + res);
 }

} 




 </source>



Floating�Point Types

   <source lang="java">

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);
 }

} 



 </source>



Gets the maximum of three float values.

   <source lang="java">

/* 

* 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 
* @since 2.0
* @version $Id: NumberUtils.java 609475 2008-01-06 23:58:59Z bayard $
*/

public class Main { 

 /**
*

Gets the maximum of three float values.

  *
*

If any value is NaN, NaN is * returned. Infinity is handled.

  *
  * @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(float a, float b, float c) {
     return Math.max(Math.max(a, b), c);
 }

} 



 </source>



Gets the minimum of three float values.

   <source lang="java">

/* 

* 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 
* @since 2.0
* @version $Id: NumberUtils.java 609475 2008-01-06 23:58:59Z bayard $
*/

public class Main { 

 /**
*

Gets the minimum of three float values.

  *
*

If any value is NaN, NaN is * returned. Infinity is handled.

  *
  * @param a  value 1
  * @param b  value 2
  * @param c  value 3
  * @return  the smallest of the values
  * @see IEEE754rUtils#min(float, float, float) for a version of this method that handles NaN differently
  */
 public static float min(float a, float b, float c) {
     return Math.min(Math.min(a, b), c);
 }

} 



 </source>



Java Float Comparison

   <source lang="java">

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("=");
   }
 }

} 



 </source>



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

   <source lang="java">

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 



 </source>



Java Float isInfinite Method

   <source lang="java">

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);
 }

} 



 </source>



Java Float isNaN Method

   <source lang="java">

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);
 }

} 



 </source>



Java Float Wrapper Class

   <source lang="java">

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);
 }

} 



 </source>



Min and Max values of data type float

   <source lang="java">

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

  • /



 </source>



Pass floats as string literals to a method

   <source lang="java">

public class Main { 

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

} 



 </source>



Returns the sign for float value x

   <source lang="java">

import java.math.BigDecimal; /* 

* 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 { 

 /**
  * Returns the 
  * for float value x.
*

* For a float value x, this method returns +1.0F if x > 0, 0.0F if x = * 0.0F, and -1.0F if x < 0. Returns NaN if x * is NaN.

  * 
  * @param x the value, a float
  * @return +1.0F, 0.0F, or -1.0F, depending on the sign of x
  */
 public static float sign(final float x) {
     if (Float.isNaN(x)) {
         return Float.NaN;
     }
     return (x == 0.0F) ? 0.0F : (x > 0.0F) ? 1.0F : -1.0F;
 }

} 



 </source>



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

   <source lang="java">

public class Main { 

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

} 



 </source>



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

   <source lang="java">

public class Main { 

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

} 



 </source>
Источник — «http://jexp.ru/index.php?title=Java/Data_Type/float&oldid=6811»