避开精度导致的误判：正确使用Java BigDecimal比较的方法

巧妙处理Java中 BigDecimal 的精度问题

前言：
今天在改bug的时候，发现一个比较基础的精度问题，下面来分享给大家。

在Java编程中，处理金钱和精度相关的计算时，经常会使用 BigDecimal 类。然而，有时即使数值相等，两个 BigDecimal 对象也会被视为不相等。这篇博客将会带你深入了解其中的原因，并提供代码示例，帮助你正确处理 BigDecimal 的精度问题。

一、BigDecimal精度问题的背景

BigDecimal 对象的比较不仅仅依赖于数值，还考虑数值的精度。例如，假设我们有两个 BigDecimal 对象，一个是 3.000000，另一个是 3，虽然看起来数值是一样的，但在 BigDecimal 的 equals 方法中，它们并不相等。

让我们看一个具体的例子：

import java.math.BigDecimal;

public class BigDecimalTest {
    public static void main(String[] args) {
        BigDecimal value1 = new BigDecimal("3.000000");
        BigDecimal value2 = new BigDecimal("3");

        // 比较结果
        boolean isEqual = value1.equals(value2);
        System.out.println("value1 equals value2: " + isEqual); // 输出: false
    }
}

在上面的代码中，尽管我们直观上认为 value1 和 value2 是相等的，但实际比较结果却是 false。

二、使用compareTo方法进行比较

为了正确比较两个 BigDecimal 对象的数值，我们可以使用 compareTo 方法。compareTo 方法将忽略精度，只比较数值是否相等。

import java.math.BigDecimal;

public class BigDecimalTest {
    public static void main(String[] args) {
        BigDecimal value1 = new BigDecimal("3.000000");
        BigDecimal value2 = new BigDecimal("3");

        // 使用 compareTo 方法比较
        boolean isValueEqual = value1.compareTo(value2) == 0;
        System.out.println("value1 compareTo value2: " + isValueEqual); // 输出: true
    }
}

在这个例子中，通过 compareTo 方法进行比较，正确地判定 value1 和 value2 是相等的。

三、实际应用中的示例

下面是一个实际应用中的场景，我们需要比较两个对象的所有字段，并找出所有不同的字段。假如我们的对象中包含 BigDecimal 类型的字段，就需要特别处理 BigDecimal 字段的比较。

以下是一个完整的示例，展示了如何实现包含 BigDecimal 特殊处理的字段比较工具类：

package io.terminus.lshm.item.server.domain.log.util;

import cn.hutool.core.collection.CollUtil;
import io.terminus.lshm.item.common.model.item.FieldDiffTO;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang3.ObjectUtils;
import org.springframework.stereotype.Component;

import java.lang.reflect.Field;
import java.math.BigDecimal;
import java.util.*;

@Component
public class LogUtil<T> {
    public List<FieldDiffTO> compareFields(T originalModel, T updatedModel, String... ignoreProperties) {
        List<FieldDiffTO> diffFields = new ArrayList<>();
        Set<String> ignoreSet = CollUtil.newHashSet(ignoreProperties);
        Class<?> clazz = updatedModel.getClass();
        Field[] fields = clazz.getDeclaredFields();

        for (Field field : fields) {
            if (ignoreSet.contains(field.getName())) {
                continue;
            }
            field.setAccessible(true);
            try {
                Object oldValue = field.get(originalModel);
                Object newValue = field.get(updatedModel);

                if (ObjectUtils.isEmpty(oldValue) && ObjectUtils.isEmpty(newValue)) {
                    continue;
                }

                // Special handling for BigDecimal comparison
                if (oldValue instanceof BigDecimal && newValue instanceof BigDecimal) {
                    if (((BigDecimal) oldValue).compareTo((BigDecimal) newValue) != 0) {
                        FieldDiffTO fieldDiff = new FieldDiffTO(field.getName(), oldValue, newValue);
                        diffFields.add(fieldDiff);
                    }
                    continue;
                }

                // Collection comparison
                if (oldValue instanceof Collection && newValue instanceof Collection) {
                    if (!CollectionUtils.isEqualCollection((Collection<?>) oldValue, (Collection<?>) newValue)) {
                        FieldDiffTO fieldDiff = new FieldDiffTO(field.getName(), oldValue, newValue);
                        diffFields.add(fieldDiff);
                    }
                    continue;
                }

                // General comparison
                if (oldValue == null || newValue == null || !oldValue.equals(newValue)) {
                    FieldDiffTO fieldDiff = new FieldDiffTO(field.getName(), oldValue, newValue);
                    diffFields.add(fieldDiff);
                }

            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
        }
        return diffFields;
    }
}

四、测试字段比较工具类

下面是一个简单的测试类，展示了如何使用上述工具类进行两个对象的字段比较：

public class TestBigDecimalComparison {
    public static void main(String[] args) {
        ItemTO originalItem = new ItemTO(new BigDecimal("3.000000"));
        ItemTO updatedItem = new ItemTO(new BigDecimal("3"));

        LogUtil<ItemTO> logUtil = new LogUtil<>();
        List<FieldDiffTO> diffs = logUtil.compareFields(originalItem, updatedItem);

        System.out.println(diffs.isEmpty() ? "No differences found" : "Differences found:");
        for (FieldDiffTO diff : diffs) {
            System.out.println(diff);
        }
    }
}

本文总结

在Java中使用 BigDecimal 进行数值比较时，一定要注意其 equals 方法的行为，它不仅考虑数值，还包括精度。为了避免因精度问题导致的 BigDecimal 比较不相等，建议使用 compareTo 方法进行数值比较。

希望这篇博客能帮助大家更好地理解和处理 BigDecimal 的精度问题，若有任何问题欢迎在评论区交流讨论！

---

希望这篇文章能够帮助你更好地处理 BigDecimal 的精度问题。如果你觉得这篇文章对你有帮助，请点赞、收藏和分享，让更多人受益。谢谢！