Java中将float转换为String以及将String转换为float

Question

如何将浮点数转换为字符串或将字符串转换为浮点数？

就我而言，我需要在两个值字符串（我从表中获得的值）和我计算的浮点值之间进行断言。

String valueFromTable = "25";
Float valueCalculated =25.0;

我尝试从浮点到字符串：

String sSelectivityRate = String.valueOf(valueCalculated);

但断言失败

Answer 1

使用 Java 的 Float 类。

float f = Float.parseFloat("25");
String s = Float.toString(25.0f);

要进行比较，最好将字符串转换为浮点数并作为两个浮点数进行比较。这是因为对于一个浮点数有多种字符串表示形式，这些表示形式与字符串比较时是不同的（例如“25”！=“25.0”！=“25.00”等）

Answer 2

浮点到字符串 - String.valueOf()

float amount=100.00f;
String strAmount=String.valueOf(amount);
// or  Float.toString(float)

字符串到浮点 - Float.parseFloat()

String strAmount="100.20";
float amount=Float.parseFloat(strAmount)
// or  Float.valueOf(string)

Answer 3

您可以尝试以下代码示例：

public class StringToFloat
{

  public static void main (String[] args)
  {

    // String s = "fred";    // do this if you want an exception

    String s = "100.00";

    try
    {
      float f = Float.valueOf(s.trim()).floatValue();
      System.out.println("float f = " + f);
    }
    catch (NumberFormatException nfe)
    {
      System.out.println("NumberFormatException: " + nfe.getMessage());
    }
  }
}

此处

Answer 4

我相信以下代码会有所帮助：

float f1 = 1.23f;
String f1Str = Float.toString(f1);      
float f2 = Float.parseFloat(f1Str);

Answer 5

这是一个可能的答案，这也会给出精确的数据，只需按所需的形式更改小数点即可。

public class TestStandAlone {

    /**
     * 
该方法的主要
     * @param args  void
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        try {
            Float f1=152.32f;
            BigDecimal roundfinalPrice = new BigDecimal(f1.floatValue()).setScale(2,BigDecimal.ROUND_HALF_UP);

            System.out.println("f1 --> "+f1);
            String s1=roundfinalPrice.toPlainString();
            System.out.println("s1 "+s1);
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

}

输出将是

f1 --> 152.32
s1 152.32

Answer 6

如果您要查找，请说小数点后两位。
<代码>
浮点 f = (浮点)12.34;
String s = new DecimalFormat("#.00").format(f);

Answer 7

嗯，这种方法不是一个好的方法，但很简单，不推荐。也许我应该说这是最不有效的方法，也是最糟糕的编码实践，但是，使用起来很有趣，

float val=10.0;
String str=val+"";

空引号，向变量 str 添加一个空字符串，将 'val' 向上转换为字符串类型。

Answer 8

将浮点数转换为字符串有三种方法。

1. "" + f
2. Float.toString(f)
3. String.valueOf(f)

有两种方法 将字符串转换为浮点数

1. Float.valueOf(str)
2. Float.parseFloat(str);

示例：-

public class Test {

    public static void main(String[] args) {
        System.out.println("convert FloatToString " + convertFloatToString(34.0f));

        System.out.println("convert FloatToStr Using Float Method " + convertFloatToStrUsingFloatMethod(23.0f));

        System.out.println("convert FloatToStr Using String Method " + convertFloatToStrUsingFloatMethod(233.0f));

        float f = Float.valueOf("23.00");
    }

    public static String convertFloatToString(float f) {
        return "" + f;
    }

    public static String convertFloatToStrUsingFloatMethod(float f) {
        return Float.toString(f);
    }

    public static String convertFloatToStrUsingStringMethod(float f) {
        return String.valueOf(f);
    }

}

Answer 9

String str = "1234.56";
float num = 0.0f;

int digits = str.length()- str.indexOf('.') - 1;

float factor = 1f;

for(int i=0;i<digits;i++) factor /= 10;

for(int i=str.length()-1;i>=0;i--){

    if(str.charAt(i) == '.'){
        factor = 1;
        System.out.println("Reset, value="+num);
        continue;
    }

    num += (str.charAt(i) - '0') * factor;
    factor *= 10;
}

System.out.println(num);

Answer 10

要走完整的手动路线：此方法通过移动数字的小数点并使用下限（长整型）和模数来提取数字，从而将双精度数转换为字符串。此外，它使用基数除法来计算小数点所属的位置。一旦数字到达小数点后的位数，它还可以“删除”数字的较高部分，以避免丢失超大双精度数的精度。请参阅最后的注释代码。在我的测试中，当 Java 浮点表示实际上显示这些不精确的小数点后位时，它的精确度绝不会低于 Java 浮点表示本身。

/**
 * Convert the given double to a full string representation, i.e. no scientific notation
 * and always twelve digits after the decimal point.
 * @param d The double to be converted
 * @return A full string representation
 */
public static String fullDoubleToString(final double d) {
    // treat 0 separately, it will cause problems on the below algorithm
    if (d == 0) {
        return "0.000000000000";
    }
    // find the number of digits above the decimal point
    double testD = Math.abs(d);
    int digitsBeforePoint = 0;
    while (testD >= 1) {
        // doesn't matter that this loses precision on the lower end
        testD /= 10d;
        ++digitsBeforePoint;
    }

    // create the decimal digits
    StringBuilder repr = new StringBuilder();
    // 10^ exponent to determine divisor and current decimal place
    int digitIndex = digitsBeforePoint;
    double dabs = Math.abs(d);
    while (digitIndex > 0) {
        // Recieves digit at current power of ten (= place in decimal number)
        long digit = (long)Math.floor(dabs / Math.pow(10, digitIndex-1)) % 10;
        repr.append(digit);
        --digitIndex;
    }

    // insert decimal point
    if (digitIndex == 0) {
        repr.append(".");
    }

    // remove any parts above the decimal point, they create accuracy problems
    long digit = 0;
    dabs -= (long)Math.floor(dabs);
    // Because of inaccuracy, move to entirely new system of computing digits after decimal place.
    while (digitIndex > -12) {
        // Shift decimal point one step to the right
        dabs *= 10d;
        final var oldDigit = digit;
        digit = (long)Math.floor(dabs) % 10;
        repr.append(digit);

        // This may avoid float inaccuracy at the very last decimal places.
        // However, in practice, inaccuracy is still as high as even Java itself reports.
        // dabs -= oldDigit * 10l;
        --digitIndex;
    }

    return repr.insert(0, d < 0 ? "-" : "").toString(); 
}

请注意，虽然使用 StringBuilder 是为了提高速度，但可以轻松重写此方法以使用数组，因此也适用于其他语言。