в 18:01, 31 мая 2010

2010-05-31T18:01:44Z

Новая страница

== 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.
* <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 (<code>-Float.MAX_VALUE</code>)
* <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;
}
}
}

</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 <code>float</code> values.
*
* If any value is <code>NaN</code>, <code>NaN</code> 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 <code>float</code> values.
*
* If any value is <code>NaN</code>, <code>NaN</code> 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 <code>x</code>.
* 
* 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 <code>NaN</code> if <code>x</code>
* is <code>NaN</code>.
*
* @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>

Java/Data Type/float - История изменений

Admin: 1 версия

в 18:01, 31 мая 2010

← Предыдущая	Версия 06:20, 1 июня 2010
(нет различий)