Theo trang java.sun này == là toán tử so sánh đẳng thức cho các số dấu phẩy động trong Java.

Tuy nhiên, khi tôi gõ mã này:

if(sectionID == currentSectionID)

vào trình chỉnh sửa của tôi và chạy phân tích tĩnh, tôi nhận được: "JAVA0078 Giá trị dấu phẩy động so với =="

Điều gì là sai với việc sử dụng ==để so sánh các giá trị dấu phẩy động? Cách chính xác để làm điều đó là gì? 

cách chính xác để kiểm tra số float cho 'đẳng thức' là:

if(Math.abs(sectionID - currentSectionID) < epsilon)

trong đó epsilon là một số rất nhỏ như 0,00000001, tùy thuộc vào độ chính xác mong muốn.

Các giá trị dấu phẩy động có thể tắt đi một chút, vì vậy chúng có thể không báo cáo chính xác như nhau. Ví dụ: đặt dấu phẩy thành "6.1" và sau đó in lại, bạn có thể nhận được giá trị được báo cáo của một cái gì đó như "6.099999904632568359375". Đây là nền tảng cho cách thức hoạt động của phao; do đó, bạn không muốn so sánh chúng bằng cách sử dụng đẳng thức, mà là so sánh trong một phạm vi, nghĩa là, nếu độ chênh lệch của số float với số bạn muốn so sánh nó nhỏ hơn một giá trị tuyệt đối nhất định.

Bài viết này về Đăng ký cung cấp một cái nhìn tổng quan tốt về lý do tại sao đây là trường hợp; đọc hữu ích và thú vị.

Chỉ cần đưa ra lý do đằng sau những gì mọi người khác đang nói.

Các đại diện nhị phân của một float là loại gây phiền nhiễu.

Trong hệ nhị phân, hầu hết các lập trình viên đều biết mối tương quan giữa 1b = 1d, 10b = 2d, 100b = 4d, 1000b = 8d

Vâng, nó hoạt động theo cách khác quá.

.1b = .5d, .01b = .25d, .001b = .125, ...

Vấn đề là không có cách chính xác nào để biểu diễn hầu hết các số thập phân như .1, .2, .3, v.v. Tất cả những gì bạn có thể làm là gần đúng ở dạng nhị phân. Hệ thống thực hiện một chút làm tròn khi các số in sao cho nó hiển thị .1 thay vì .10000000000001 hoặc .999999999999 (có lẽ gần giống với đại diện được lưu trữ như .1)

Chỉnh sửa từ nhận xét: Lý do đây là một vấn đề là kỳ vọng của chúng tôi. Chúng tôi hoàn toàn mong đợi 2/3 sẽ bị sai lệch tại một số điểm khi chúng tôi chuyển đổi nó thành số thập phân, 0,7 hoặc 0,67 hoặc 0,666667 .. Nhưng chúng tôi không tự động mong đợi .1 sẽ được làm tròn theo cách tương tự như 2/3 - và đó chính xác là những gì đang xảy ra.

Nhân tiện, nếu bạn tò mò con số mà nó lưu trữ bên trong là một biểu diễn nhị phân thuần túy bằng cách sử dụng "Ký hiệu khoa học" nhị phân. Vì vậy, nếu bạn bảo nó lưu số thập phân 10,75d, nó sẽ lưu 1010b cho số 10 và .11b cho số thập phân. Vì vậy, nó sẽ lưu trữ .101011 sau đó nó sẽ tiết kiệm một vài bit ở cuối để nói: Di ​​chuyển dấu thập phân bốn vị trí bên phải.

.

Điều gì sai khi sử dụng == để so sánh các giá trị dấu phẩy động?

Bởi vì nó không đúng 0.1 + 0.2 == 0.3

Tôi nghĩ rằng có rất nhiều nhầm lẫn xung quanh phao (và đôi), thật tốt để làm sáng tỏ nó.

1. Không có gì sai khi sử dụng float như ID trong JVM tuân thủ tiêu chuẩn [*]. Nếu bạn chỉ đơn giản đặt ID float thành x, không làm gì với nó (tức là không có mỹ phẩm) và sau đó kiểm tra y == x, bạn sẽ ổn. Ngoài ra, không có gì sai khi sử dụng chúng làm khóa trong HashMap. Những gì bạn không thể làm là giả sử các đẳng thức như x == (x - y) + y, v.v. Điều này được nói, mọi người thường sử dụng các loại số nguyên làm ID và bạn có thể quan sát rằng hầu hết mọi người ở đây bị loại bỏ bởi mã này, vì vậy, vì lý do thực tế, tốt hơn là tuân thủ các quy ước . Lưu ý rằng có nhiều doublegiá trị khác nhau khi có values, vì vậy bạn không thu được gì khi sử dụng double. Ngoài ra, việc tạo "ID khả dụng tiếp theo" có thể khó khăn gấp đôi và đòi hỏi một số kiến ​​thức về số học dấu phẩy động. Không đáng để gặp rắc rối.

2. Mặt khác, dựa vào sự bình đẳng bằng số của kết quả của hai phép tính tương đương toán học là rủi ro. Điều này là do các lỗi làm tròn và mất độ chính xác khi chuyển đổi từ biểu diễn thập phân sang nhị phân. Điều này đã được thảo luận đến chết trên SO.

[*] Khi tôi nói "JVM tuân thủ tiêu chuẩn", tôi muốn loại trừ một số triển khai JVM bị tổn thương não. Xem này .

Đây là một vấn đề không cụ thể đối với java. Sử dụng == để so sánh hai số float / double / bất kỳ số loại thập phân nào có khả năng gây ra sự cố do cách chúng được lưu trữ. Một float có độ chính xác đơn (theo tiêu chuẩn IEEE 754) có 32 bit, được phân phối như sau:

1 bit - Dấu (0 = dương, 1 = âm)
8 bit - Biểu diễn lũy thừa (đặc biệt (độ lệch-127) của x trong 2 ^ x)
23 bit - Mantisa. Số Actuall được lưu trữ.

Các mantisa là những gì gây ra vấn đề. Nó giống như ký hiệu khoa học, chỉ có số trong cơ sở 2 (nhị phân) trông giống như 1.110011 x 2 ^ 5 hoặc một cái gì đó tương tự. Nhưng trong hệ nhị phân, số 1 đầu tiên luôn là số 1 (ngoại trừ biểu diễn bằng 0)

Do đó, để tiết kiệm một chút dung lượng bộ nhớ (ý định chơi chữ), IEEE đã quyết định rằng 1 nên được giả sử. Ví dụ, một mantisa của 1011 thực sự là 1.1011.

Điều này có thể gây ra một số vấn đề khi so sánh, đặc biệt là với 0 vì 0 không thể được biểu diễn chính xác trong một float. Đây là lý do chính khiến == không được khuyến khích, ngoài các vấn đề toán học dấu phẩy động được mô tả bởi các câu trả lời khác.

Java có một vấn đề duy nhất là ngôn ngữ này là phổ quát trên nhiều nền tảng khác nhau, mỗi nền tảng có thể có định dạng nổi duy nhất của riêng nó. Điều đó làm cho nó thậm chí còn quan trọng hơn để tránh ==.

Cách thích hợp để so sánh hai số float (tâm trí cụ thể không phải ngôn ngữ của bạn) cho sự bình đẳng như sau:

if(ABS(float1 - float2) < ACCEPTABLE_ERROR)
    //they are approximately equal

trong đó ACCEPTABLE_ERROR là #d xác định hoặc một số hằng số khác bằng 0,000000001 hoặc bất kỳ độ chính xác nào được yêu cầu, như Victor đã đề cập.

Một số ngôn ngữ có chức năng này hoặc hằng số này được tích hợp, nhưng nhìn chung đây là một thói quen tốt.

Cho đến hôm nay, cách nhanh chóng và dễ dàng để làm điều đó là:

if (Float.compare(sectionID, currentSectionID) == 0) {...}

Tuy nhiên, các tài liệu không chỉ định rõ ràng giá trị của chênh lệch biên (một epsilon từ câu trả lời của @Victor) luôn có trong các tính toán trên phao, nhưng nó phải là một thứ hợp lý vì nó là một phần của thư viện ngôn ngữ tiêu chuẩn.

Tuy nhiên, nếu cần độ chính xác cao hơn hoặc tùy chỉnh, thì

float epsilon = Float.MIN_NORMAL;  
if(Math.abs(sectionID - currentSectionID) < epsilon){...}

là một lựa chọn giải pháp khác.

Giá trị điểm cho phép không đáng tin cậy, do lỗi vòng.

Vì vậy, có lẽ chúng không nên được sử dụng làm giá trị chính, chẳng hạn như partID. Sử dụng số nguyên thay thế hoặc longnếu intkhông chứa đủ giá trị có thể.

Ngoài các câu trả lời trước đó, bạn nên lưu ý rằng có những hành vi lạ liên quan đến -0.0fvà +0.0f(chúng có ==nhưng không equals) và Float.NaN(đó là equalsnhưng không== ) (hy vọng tôi đã hiểu đúng - argh, đừng làm điều đó!).

Chỉnh sửa: Hãy kiểm tra!

import static java.lang.Float.NaN;
public class Fl {
    public static void main(String[] args) {
        System.err.println(          -0.0f   ==              0.0f);   // true
        System.err.println(new Float(-0.0f).equals(new Float(0.0f))); // false
        System.err.println(            NaN   ==               NaN);   // false
        System.err.println(new Float(  NaN).equals(new Float( NaN))); // true
    }
} 

Chào mừng bạn đến với IEEE / 754.

Dưới đây là một cuộc thảo luận rất dài (nhưng hy vọng hữu ích) về vấn đề này và nhiều vấn đề về điểm nổi khác mà bạn có thể gặp phải: Điều mà mọi nhà khoa học máy tính nên biết về số học dấu phẩy động

Bạn có thể sử dụng Float.floatToIntBits ().

Float.floatToIntBits(sectionID) == Float.floatToIntBits(currentSectionID)

Trước hết, họ nổi hay nổi? Nếu một trong số chúng là Float, bạn nên sử dụng phương thức equals (). Ngoài ra, có lẽ tốt nhất để sử dụng phương pháp Float.compare tĩnh.

Sau đây tự động sử dụng độ chính xác tốt nhất:

/**
 * Compare to floats for (almost) equality. Will check whether they are
 * at most 5 ULP apart.
 */
public static boolean isFloatingEqual(float v1, float v2) {
    if (v1 == v2)
        return true;
    float absoluteDifference = Math.abs(v1 - v2);
    float maxUlp = Math.max(Math.ulp(v1), Math.ulp(v2));
    return absoluteDifference < 5 * maxUlp;
}

Tất nhiên, bạn có thể chọn nhiều hơn hoặc ít hơn 5 ULP ('đơn vị ở vị trí cuối cùng').

Nếu bạn vào thư viện Apache Commons, Precisionlớp có compareTo()và equals()với cả epsilon và ULP.

bạn có thể muốn nó là ==, nhưng 123.4444444444443! = 123.4444444444442

Nếu bạn * phải * sử dụng float, từ khóarictfp có thể hữu ích.

http://en.wikipedia.org/wiki/strictfp

Hai phép tính khác nhau tạo ra các số thực bằng nhau không nhất thiết tạo ra các số có dấu phẩy động bằng nhau. Những người sử dụng == để so sánh kết quả tính toán thường sẽ bị bất ngờ bởi điều này, vì vậy cảnh báo giúp gắn cờ những gì có thể là một lỗi tinh vi và khó tái tạo.

Bạn có đang xử lý mã thuê ngoài sẽ sử dụng float cho những thứ có tên partID và currentSectionID không? Chỉ tò mò thôi.

@Bill K: "Đại diện nhị phân của một float là loại gây phiền nhiễu." Làm sao vậy Làm thế nào bạn sẽ làm điều đó tốt hơn? Có một số con số nhất định không thể được biểu diễn trong bất kỳ cơ sở nào, bởi vì chúng không bao giờ kết thúc. Pi là một ví dụ tốt. Bạn chỉ có thể ước chừng nó. Nếu bạn có giải pháp tốt hơn, hãy liên hệ với Intel.

Như đã đề cập trong các câu trả lời khác, đôi có thể có độ lệch nhỏ. Và bạn có thể viết phương pháp của riêng bạn để so sánh chúng bằng cách sử dụng độ lệch "chấp nhận được". Tuy nhiên ...

Có một lớp apache để so sánh đôi: org.apache.commons.math3.util.Precision

Nó chứa một số hằng số thú vị: SAFE_MINvàEPSILON , đó là độ lệch tối đa có thể có của các phép toán số học đơn giản.

Nó cũng cung cấp các phương pháp cần thiết để so sánh, nhân đôi hoặc tròn. (sử dụng ulps hoặc độ lệch tuyệt đối)

Trong một câu trả lời tôi có thể nói, bạn nên sử dụng:

Float.floatToIntBits(sectionID) == Float.floatToIntBits(currentSectionID)

Để làm cho bạn tìm hiểu thêm về cách sử dụng các toán tử liên quan một cách chính xác, tôi đang xây dựng một số trường hợp ở đây: Nói chung, có ba cách để kiểm tra các chuỗi trong Java. Bạn có thể sử dụng ==, .equals () hoặc Object.equals ().

Họ khác nhau như thế nào? == kiểm tra chất lượng tham chiếu trong chuỗi có nghĩa là tìm hiểu xem hai đối tượng có giống nhau không. Mặt khác, .equals () kiểm tra xem hai chuỗi có giá trị bằng nhau hay không. Cuối cùng, Object.equals () kiểm tra bất kỳ null nào trong hai chuỗi sau đó xác định xem có gọi .equals () không.

Toán tử lý tưởng để sử dụng

Vâng, điều này đã phải chịu nhiều cuộc tranh luận bởi vì mỗi trong số ba nhà khai thác có tập hợp điểm mạnh và điểm yếu riêng. Ví dụ, == thường là một tùy chọn ưa thích khi so sánh tham chiếu đối tượng, nhưng có những trường hợp dường như cũng có thể so sánh các giá trị chuỗi.

Tuy nhiên, những gì bạn nhận được là một giá trị giảm vì Java tạo ra ảo tưởng rằng bạn đang so sánh các giá trị nhưng theo nghĩa thực tế thì bạn không phải vậy. Hãy xem xét hai trường hợp dưới đây:

Trường hợp 1:

String a="Test";
String b="Test";
if(a==b) ===> true

Trường hợp 2:

String nullString1 = null;
String nullString2 = null;
//evaluates to true
nullString1 == nullString2;
//throws an exception
nullString1.equals(nullString2);

Vì vậy, cách tốt hơn là sử dụng mỗi toán tử khi kiểm tra thuộc tính cụ thể mà nó được thiết kế cho. Nhưng trong hầu hết các trường hợp, Object.equals () là một toán tử phổ quát hơn do đó các nhà phát triển web có kinh nghiệm lựa chọn nó.

Tại đây bạn có thể biết thêm chi tiết: http://fluenttheme.com/use-compare-strings-java/

Cách chính xác sẽ là

java.lang.Float.compare(float1, float2)

Một cách để giảm lỗi làm tròn là sử dụng gấp đôi thay vì nổi. Điều này sẽ không làm cho vấn đề biến mất, nhưng nó làm giảm số lượng lỗi trong chương trình của bạn và float gần như không bao giờ là lựa chọn tốt nhất. IMHO.