Toán tử phím tắt “hoặc-gán” (| =) trong Java

Tôi có một tập hợp dài các phép so sánh phải làm trong Java và tôi muốn biết liệu một hoặc nhiều trong số chúng có đúng hay không. Chuỗi so sánh dài và khó đọc, vì vậy tôi đã chia nhỏ nó ra để dễ đọc và tự động chuyển sang sử dụng toán tử phím tắt |=thay vì sử dụng negativeValue = negativeValue || boolean.

boolean negativeValue = false;
negativeValue |= (defaultStock < 0);
negativeValue |= (defaultWholesale < 0);
negativeValue |= (defaultRetail < 0);
negativeValue |= (defaultDelivery < 0);

Tôi hy vọng negativeValuelà đúng nếu bất kỳ giá trị <something> nào mặc định là âm. Điều này có hợp lệ không? Nó sẽ làm những gì tôi mong đợi? Tôi không thể thấy nó được đề cập trên trang web hoặc stackoverflow của Sun, nhưng Eclipse dường như không có vấn đề với nó và mã biên dịch và chạy.

Tương tự, nếu tôi muốn thực hiện một số giao điểm hợp lý, tôi có thể sử dụng &=thay thế &&không?

Đây |=là một toán tử gán ghép ( JLS 15.26.2 ) cho toán tử logic boolean |( JLS 15.22.2 ); không bị nhầm lẫn với điều kiện-hoặc ||( JLS 15.24 ). Ngoài ra còn có &=và ^=tương ứng với phiên bản gán ghép của lôgic boolean &và ^tương ứng.

Nói cách khác, boolean b1, b2hai điều này tương đương nhau:

 b1 |= b2;
 b1 = b1 | b2;

Sự khác biệt giữa các toán tử logic ( &và |) so với các đối tác có điều kiện của chúng ( &&và ||) là các toán tử trước đây không "ngắn mạch"; cái sau làm. Đó là:

• &và | luôn đánh giá cả hai toán hạng
• &&và ||đánh giá toán hạng bên phải theo điều kiện ; toán hạng bên phải chỉ được đánh giá nếu giá trị của nó có thể ảnh hưởng đến kết quả của phép toán nhị phân. Điều đó có nghĩa là toán hạng bên phải KHÔNG được đánh giá khi:
  • Toán hạng bên trái của &&đánh giá làfalse
    • (bởi vì bất kể toán hạng bên phải được đánh giá là gì, toàn bộ biểu thức là false)
  • Toán hạng bên trái của ||đánh giá làtrue
    • (bởi vì bất kể toán hạng bên phải được đánh giá là gì, toàn bộ biểu thức là true)

Vì vậy, quay trở lại câu hỏi ban đầu của bạn, vâng, cấu trúc đó hợp lệ, và mặc dù |=không phải là một phím tắt tương đương cho =và ||, nó tính toán những gì bạn muốn. Vì phía bên tay phải của |=toán tử trong cách sử dụng của bạn là một phép toán so sánh số nguyên đơn giản, thực tế là |không ngắn mạch là không đáng kể.

Có những trường hợp, khi bạn muốn hoặc thậm chí là bắt buộc, nhưng kịch bản của bạn không phải là một trong số đó.

Thật không may là không giống như một số ngôn ngữ khác, Java không có &&=và ||=. Điều này đã được thảo luận trong câu hỏi Tại sao Java không có các phiên bản gán ghép của các toán tử điều kiện-và và điều kiện-hoặc? (&& =, || =) .

Nó không phải là toán tử "phím tắt" (hoặc đoản mạch) theo cách || và && là (ở chỗ họ sẽ không đánh giá RHS nếu họ đã biết kết quả dựa trên LHS) nhưng nó sẽ làm những gì bạn muốn về mặt làm việc .

Ví dụ về sự khác biệt, mã này sẽ ổn nếu textlà null:

boolean nullOrEmpty = text == null || text.equals("")

trong khi điều này sẽ không:

boolean nullOrEmpty = false;
nullOrEmpty |= text == null;
nullOrEmpty |= text.equals(""); // Throws exception if text is null

(Rõ ràng bạn có thể làm "".equals(text)cho trường hợp cụ thể đó - tôi chỉ đang cố gắng chứng minh nguyên tắc.)

Bạn chỉ có thể có một tuyên bố. Được thể hiện qua nhiều dòng, nó đọc gần như chính xác như mã mẫu của bạn, chỉ ít bắt buộc hơn:

boolean negativeValue
    = defaultStock < 0 
    | defaultWholesale < 0
    | defaultRetail < 0
    | defaultDelivery < 0;

Đối với các biểu thức đơn giản nhất, việc sử dụng |có thể nhanh hơn ||vì mặc dù nó tránh thực hiện phép so sánh nhưng nó có nghĩa là sử dụng một nhánh ngầm và điều đó có thể đắt hơn nhiều lần.

Mặc dù nó có thể là quá mức cần thiết cho vấn đề của bạn, nhưng thư viện Guava có một số cú pháp hay với Predicates và đánh giá ngắn mạch của hoặc / và Predicates.

Về cơ bản, các so sánh được chuyển thành các đối tượng, được đóng gói thành một bộ sưu tập và sau đó được lặp lại. Đối với hoặc các vị từ, lần truy cập true đầu tiên trả về từ lần lặp và ngược lại đối với và.

Nếu đó là về khả năng đọc, tôi đã có khái niệm tách dữ liệu được kiểm tra khỏi logic kiểm tra. Mẫu mã:

// declare data
DataType [] dataToTest = new DataType[] {
    defaultStock,
    defaultWholesale,
    defaultRetail,
    defaultDelivery
}

// define logic
boolean checkIfAnyNegative(DataType [] data) {
    boolean negativeValue = false;
    int i = 0;
    while (!negativeValue && i < data.length) {
        negativeValue = data[i++] < 0;
    }
    return negativeValue;
}

Mã trông dài dòng hơn và dễ hiểu hơn. Bạn thậm chí có thể tạo một mảng trong cuộc gọi phương thức, như thế này:

checkIfAnyNegative(new DataType[] {
    defaultStock,
    defaultWholesale,
    defaultRetail,
    defaultDelivery
});

Nó dễ đọc hơn 'chuỗi so sánh' và cũng có lợi thế về hiệu suất của việc đoản mạch (với chi phí phân bổ mảng và gọi phương thức).

Chỉnh sửa: Có thể dễ dàng đọc hơn nữa bằng cách sử dụng các tham số varargs:

Chữ ký phương thức sẽ là:

boolean checkIfAnyNegative(DataType ... data)

Và cuộc gọi có thể trông như thế này:

checkIfAnyNegative( defaultStock, defaultWholesale, defaultRetail, defaultDelivery );

Đây là một bài viết cũ nhưng để cung cấp một góc nhìn khác cho người mới bắt đầu, tôi xin đưa ra một ví dụ.

Tôi nghĩ rằng trường hợp sử dụng phổ biến nhất cho một toán tử ghép tương tự sẽ là +=. Tôi chắc rằng tất cả chúng ta đã viết một cái gì đó như thế này:

int a = 10;   // a = 10
a += 5;   // a = 15

Mục đích của việc này là gì? Mục đích là tránh viết sẵn và loại bỏ mã lặp lại.

Vì vậy, dòng tiếp theo thực hiện hoàn toàn tương tự, tránh nhập biến b1hai lần trên cùng một dòng.

b1 |= b2;

List<Integer> params = Arrays.asList (defaultStock, defaultWholesale, 
                                       defaultRetail, defaultDelivery);
int minParam = Collections.min (params);
negativeValue = minParam < 0;

|| boolean logic HOẶC
| bitwise HOẶC

| = bitwise bao gồm OR và toán tử gán

Lý do tại sao | = không shortcircit là bởi vì nó thực hiện một cách bitwise HOẶC không phải là OR logic. Điều đó có nghĩa là:

C | = 2 tương tự như C = C | 2

Hướng dẫn cho các toán tử java