判断浮点数是否相等

1. 浮点数 == 什么时候出现问题

1.1 都为小数或整数,不参与运算

/**
*无论 a = 0.1 or 1.0 or 1.1   结果都为true
*/
public static void main(String[] args){
	double a = 0.1;
	double b = 0.1;
	float c = 0.1f;
	float d = 0.1f;

    System.out.println("a==b : "+ (a == b));

	System.out.println("c==d : "+ (c == d));
}

1.2 参与加减法

1.2.1 纯小数 + 纯小数 or 纯整数

public static void main(String[] args){
	double a = 0.1;
	double b = 0.1;
	float c = 0.1f;
	float d = 0.1f;

	a  = a + 1 - 1; //不论是 1 or 1.0 or 1.1,只要大于0.101 均输出 false
   	//b = b + 1 - 1; 若执行此行,则输出 true
	System.out.println("a==b : "+ (a == b)); //输出 false

	c = c + 0.1f - 0.1f;

	System.out.println("c==d : "+ (c == d)); //输出 true
}

1.2.2 纯整数 + 纯小数 or 纯整数

public static void main(String[] args){
    double a = 1;
    double b = 1;
    float c = 1f;
    float d = 1f;

    a  = a + 0.1 - 0.1;

    c = c + 1f - 1f;

    System.out.println("a==b : "+ (a == b)); // true

    System.out.println("c==d : "+ (c == d)); // true
}

1.2.3 非纯整数 + 纯小数 or 纯整数

public static void main(String[] args){
    double a = 1.1;
    double b = 1.1;
    float c = 1.1f;
    float d = 1.1f;

    a = a + 1 - 1;

    c = c + 0.1f - 0.1f;

    System.out.println("a==b : "+ (a == b));// true

    System.out.println("c==d : "+ (c == d));// true
}

1.3 个人总结

以上测试都是放屁,换个数值又会出问题,规律我是不会去找了,还是用别的方法吧

2. == 和 equals 的区别

== equals
基础数据类型:比较他们的值是否相等
引用数据类型:比较的是引用的地址是否相同 所指向对象的内容是否相等

String 类的 equals()方法源码

public boolean equals(Object anObject) {
    if (this == anObject) {
        return true;
    }
    if (anObject instanceof String) {
        String anotherString = (String)anObject;
        int n = value.length;
        if (n == anotherString.value.length) {
            char v1[] = value;
            char v2[] = anotherString.value;
            int i = 0;
            while (n-- != 0) {
                if (v1[i] != v2[i])
                    return false;
                i++;
            }
            return true;
        }
    }
    return false;
}

简单说,判断规则

  1. 引用不同,不相等
  2. 类型不同,不相等
  3. 长度不同,不相等
  4. 字符不同,不相等

当且仅当参数不是null且是String对象表示与此对象相同的字符序列时,结果为true

3.浮点数相等的判断方法

3.1 绝对值比较,看精度要求情况

private static void doubleCompare(double dby,double dbx){
    final double epsilon = 0.0000001;
    if(Math.abs(dby - dbx) < epsilon){
        System.out.println("绝对值比较结果: true");
    }else{
        System.out.println("绝对值比较结果: false");
    }
}

3.2 转换成字符串后使用 equals 方法比较

private static void doubleCompare(double dby,double dbx){
	System.out.println("字符串 equals方法比较结果 : "+ Double.toString(dby).equals(Double.toString(dbx)));
}

3.3 Double.doubleToLongBits()方法比较

public static long doubleToLongBits(double value)

根据IEEE 754浮点“双格式”位布局返回指定浮点值的表示形式。

位63(由掩码0x8000000000000000L选择的位)表示浮点数的符号。 比特62-52(由掩码0x7ff0000000000000L选择的比特)表示指数。 比特51-0(由掩码0x000fffffffffffffL选择的比特)表示0x000fffffffffffffL的有效数(有时称为尾数)。

如果参数为正无穷大,则结果为0x7ff0000000000000L

如果参数为负无穷大,则结果为0xfff0000000000000L

如果参数为NaN,则结果为0x7ff8000000000000L

在所有情况下,结果都是一个long整数,当给定longBitsToDouble(long)方法时,将生成与doubleToLongBits的参数相同的浮点值(除了所有NaN值都折叠为单个“规范”NaN值)。

  • 参数

value - 精度为 double浮点数。

  • 结果

表示浮点数的位。

private static void doubleCompare(double dby,double dbx){
	System.out.println("Long 的 == 方法比较结果 : "+ (Double.doubleToLongBits(dby) == Double.doubleToLongBits(dbx)));
}

3.4 使用BigDecimal类型的equals方法或compareTo方法

/**
* 两种方法均先判断构造方法参数是否相同,不同均返回 false
* compareTo 只比较数值大小,不比较比例
* equals 需要比较数值和比例大小,都相等,才返回 true,以下测试结果和预期不同,原因未知
*/
private static void doubleCompare(){
	System.out.println(new BigDecimal("0.1").equals(new BigDecimal("0.10")));  //输出false
	System.out.println(new BigDecimal("0.1").compareTo(new BigDecimal("0.10")) == 0); //输出true  

	System.out.println(new BigDecimal(0.1).equals(new BigDecimal("0.10"))); //输出false
	System.out.println(new BigDecimal(0.1).compareTo(new BigDecimal("0.10")) == 0); //输出false  

	System.out.println(new BigDecimal(0.1).equals(new BigDecimal(0.10))); //输出true
	System.out.println(new BigDecimal(0.1).compareTo(new BigDecimal(0.10)) == 0);//输出true
}
      • public int compareTo(BigDecimal val)
        

        将此BigDecimal与指定的BigDecimal 。 通过此方法,两个值相等但具有不同比例(如2.0和2.00)的BigDecimal对象被视为相等。 对于六个布尔比较运算符(<,==,>,> =,!=,<=)中的每一个,优先考虑该方法。 建议执行这些比较的习惯用法是: (x.compareTo(y) < op > 0) ,其中< op >是六个比较运算符之一。

        • Specified by:

          compareTo ,界面 Comparable

        • 参数

          val - BigDecimal这个 BigDecimal要比较。

        • 结果

          -1,0或1,因为该 BigDecimal在数值上小于,等于或大于 val

      • public boolean equals(Object x)
        

        将此BigDecimal与指定的Object进行相等性比较。 与compareTo不同,此方法仅考虑两个BigDecimal对象的值和比例相等(因此通过此方法比较时2.0不等于2.00)。

        • 重写:

          equals ,类 Object

        • 参数

          x - ObjectBigDecimal比较。

        • 结果

          true当且仅当指定的 ObjectBigDecimal其值和比例等于此 BigDecimal

        • 另请参见:

          compareTo(java.math.BigDecimal)hashCode()

原文地址:https://www.cnblogs.com/huaranmeng/p/12668903.html

时间: 2024-10-30 09:53:27

判断浮点数是否相等的相关文章

CODE[VS]-判断浮点数是否相等-浮点数处理-天梯青铜

题目描述 Description 给出两个浮点数,请你判断这两个浮点数是否相等 输入描述 Input Description 输入仅一行,包含两个浮点数 输出描述 Output Description 输出仅一行,如果相等则输出yes,否则输出no. 样例输入 Sample Input 2.980000001 2.9800000000001 样例输出 Sample Output yes 数据范围及提示 Data Size & Hint 我们一般认为两个浮点数相等,当且当他们之间的误差不超过1e-

从如何判断浮点数是否等于0说起——浮点数的机器级表示

本文很大程度上收到林锐博士一些文章的启发,lz也是在大学期间读过,感觉收益良多,但是当时林锐也是说了结论,lz也只是知其然,而不知其所以然,为什么要那样写?为什么要这样用?往往一深究起来就稀里糊涂了,现在有幸还是继续读书,我发现了很多问题理解的还不透彻,亡羊补牢. 比如:有int d;  int *d; bool d; double d:几个变量,经过一系列的计算之后,那么去判断这个四个变量是否等于0该怎么做? 很多菜鸟或者编程功底不扎实的就会出错,一些烂书,尤其国内的一部分大学教材,教授编程语

1203 判断浮点数是否相等

题目描述 Description 给出两个浮点数,请你判断这两个浮点数是否相等 输入描述 Input Description 输入仅一行,包含两个浮点数 输出描述 Output Description 输出仅一行,如果相等则输出yes,否则输出no. 样例输入 Sample Input 2.980000001 2.9800000000001 样例输出 Sample Output yes 数据范围及提示 Data Size & Hint 我们一般认为两个浮点数相等,当且当他们之间的误差不超过1e-

equal_float判断浮点数相等

/*! \brief 判断两个浮点数是否相等 \return 相等返回true 不等返回false \param float absfloat - 允许的最小误差范围 */ #include "limits.h" using namespace std; bool equal_float( float fa, float fb, float absfloat = numeric_limits<float>::epsilon() ) { if ( fa == fb ) ret

判断浮点数是否为整数

#include<bits/stdc++.h> using namespace std; const double eps=1e-2; bool f(double x) { if(x>(int)(x+0.5)) { if(x-(int)(x+0.5)<eps) return true; } else { if((int)(x+0.5)-x<eps) return true; } return false; } int main() { cout<<f(1.0000

不能用==判断两个浮点数相等

在判断两个浮点数 a 和 b 是否相等时,不要用 a==b,应该判断二者之差的绝对值fabs(a-b) 是否小于某个阈值,例如 1e-9. ////在判断两个浮点数 a 和 b 是否相等时,不要用 a==b,应该判断二者之差的绝对值 ////fabs(a - b) 是否小于某个阈值,例如 1e-9. //#include <stdio.h> //#include <math.h> //#define EPSILON 0.000001 //int main() //{ // floa

MATLAB的eps,浮点数相对精度

MATLAB的eps函数,官方帮助文档是这么描述的:Floating-point relateive accuracy,也就是浮点数的相对精度. 大家都知道,在数学中,实数有无穷多个,数值可以无限大,精度也可以无限小.而在计算机中,因为表示数值的字长有限,不可能无限地表示一个数的有效数字.所以在计算机中,是没有绝对概念上的无穷大和无穷小的.两个相邻数字(中间不能再有其他数值)的“间隔”,就是一般意义上的相对精度.(相对精度的具体含义可以自行Baidu,也可以参见这个帖子:关于Matlab的eps

[ACM]计算几何_浮点数相关

1.多用double少用float double的输入与输出:(注意占位符:scanf中是%lf,printf中是%f) 1 double x; 2 scanf("%lf",&x); 3 printf("%f,x); 2.判断浮点数大于0/小于0/等于0 使用sgn(x): 1 #define EPS (1e-8) 2 inline int sgn(double x){ 3 return (x > EPS) - (x < -EPS); 4 } 3.判断两个

ACM中的浮点数精度处理

在ACM中,精度问题非常常见.其中计算几何头疼的地方一般在于代码量大和精度问题,代码量问题只要平时注意积累模板一般就不成问题了.精度问题则不好说,有时候一个精度问题就可能成为一道题的瓶颈,让你debug半天都找不到错误出在哪. 1.浮点数为啥会有精度问题: 浮点数(以C/C++为准),一般用的较多的是float, double. 占字节数 数值范围 十进制精度位数 float 4 -3.4e-38-3.4e38 6~7 double 8 -1.7e-308-1.7e308 14~15 如果内存不