Sự khác biệt giữa & và && trong Java là gì?

Tôi luôn nghĩ rằng &&toán tử trong Java được sử dụng để xác minh xem cả hai toán hạng boolean của nó là gì truevà &toán tử được sử dụng để thực hiện các hoạt động Bit-khôn ngoan trên hai loại số nguyên.

Gần đây tôi biết rằng &toán tử cũng có thể được sử dụng để xác minh xem cả hai toán hạng boolean của nó có hay không true, điểm khác biệt duy nhất là nó kiểm tra toán hạng RHS ngay cả khi toán hạng LHS là sai.

Là &toán tử trong Java quá tải nội bộ? Hoặc có một số khái niệm khác đằng sau này?

& <- xác minh cả hai toán hạng
&& <- dừng đánh giá nếu toán hạng đầu tiên đánh giá là sai vì kết quả sẽ là sai

(x != 0) & (1/x > 1)<- điều này có nghĩa là đánh giá (x != 0)sau đó đánh giá (1/x > 1)sau đó thực hiện &. vấn đề là với x = 0, điều này sẽ tạo ra một ngoại lệ.

(x != 0) && (1/x > 1)<- điều này có nghĩa là đánh giá (x != 0)và chỉ khi điều này là đúng thì hãy đánh giá (1/x > 1)vì vậy nếu bạn có x = 0 thì điều này hoàn toàn an toàn và sẽ không đưa ra bất kỳ ngoại lệ nào nếu (x! = 0) đánh giá sai toàn bộ điều trực tiếp đánh giá là sai mà không đánh giá (1/x > 1).

BIÊN TẬP:

exprA | exprB<- điều này có nghĩa là đánh giá exprAsau đó đánh giá exprBsau đó làm |.

exprA || exprB<- điều này có nghĩa là đánh giá exprAvà chỉ khi điều này được falseđánh giá exprBvà thực hiện ||.

Bên cạnh việc không phải là một người đánh giá lười biếng bằng cách đánh giá cả hai toán hạng, tôi nghĩ rằng các đặc điểm chính của toán tử bitwise so sánh từng byte của toán hạng như trong ví dụ sau:

int a = 4;
int b = 7;
System.out.println(a & b); // prints 4
//meaning in an 32 bit system
// 00000000 00000000 00000000 00000100
// 00000000 00000000 00000000 00000111
// ===================================
// 00000000 00000000 00000000 00000100

boolean a, b;

Operation     Meaning                       Note
---------     -------                       ----
   a && b     logical AND                    short-circuiting
   a || b     logical OR                     short-circuiting
   a &  b     boolean logical AND            not short-circuiting
   a |  b     boolean logical OR             not short-circuiting
   a ^  b     boolean logical exclusive OR
  !a          logical NOT

short-circuiting        (x != 0) && (1/x > 1)   SAFE
not short-circuiting    (x != 0) &  (1/x > 1)   NOT SAFE

Nó phụ thuộc vào loại đối số ...

Đối với các đối số nguyên, ký hiệu đơn ("&") là toán tử "bit-khôn ngoan AND". Ký hiệu kép ("&&") không được xác định cho bất cứ điều gì ngoại trừ hai đối số boolean.

Đối với các đối số boolean, các ký hiệu đơn và tạo thành toán tử "logic AND" (vô điều kiện) trong khi các ký hiệu kép ("&&") là toán tử "logic logic" có điều kiện. Điều đó có nghĩa là các ký hiệu đơn và luôn luôn đánh giá cả hai đối số trong khi các ký hiệu kép sẽ chỉ đánh giá đối số thứ hai nếu đối số thứ nhất là đúng.

Đối với tất cả các loại đối số và kết hợp khác, sẽ xảy ra lỗi thời gian biên dịch.

&& là toán tử ngắn mạch trong khi & là toán tử AND.

Thử cái này.

    String s = null;
    boolean b = false & s.isEmpty(); // NullPointerException
    boolean sb = false && s.isEmpty(); // sb is false

nó được chỉ định trong JLS (15.22.2) :

Khi cả hai toán hạng của một &, ^ hoặc | Toán tử có kiểu boolean hoặc Boolean, sau đó kiểu của biểu thức toán tử bitwise là boolean. Trong mọi trường hợp, các toán hạng có thể chuyển đổi unboxing (§5.1.8) khi cần thiết.

Đối với &, giá trị kết quả là đúng nếu cả hai giá trị toán hạng đều đúng; mặt khác, kết quả là sai

Đối với ^, giá trị kết quả là đúng nếu các giá trị toán hạng khác nhau; mặt khác, kết quả là sai

Với |, giá trị kết quả là sai nếu cả hai giá trị toán hạng đều sai; mặt khác, kết quả là đúng

"Bí quyết" đó &là Toán tử Bitwise Integer cũng như Toán tử logic Boolean . Vậy tại sao không, xem đây là một ví dụ cho quá tải toán tử là hợp lý.

Tôi nghĩ rằng câu trả lời của tôi có thể dễ hiểu hơn:

Có hai sự khác biệt giữa &và &&.

Nếu họ sử dụng như logic VÀ

&và &&có thể logic AND, khi tất cả các kết quả biểu thức &hoặc &&trái và phải đều đúng, toàn bộ kết quả hoạt động có thể đúng.

khi &và &&theo logic AND, có một sự khác biệt:

khi sử dụng &&làm logic AND, nếu kết quả biểu thức bên trái là sai, biểu thức bên phải sẽ không thực thi.

Lấy ví dụ:

String str = null;

if(str!=null && !str.equals("")){  // the right expression will not execute

}

Nếu sử dụng &:

String str = null;

if(str!=null & !str.equals("")){  // the right expression will execute, and throw the NullPointerException 

}

Một ví dụ khác:

int x = 0;
int y = 2;
if(x==0 & ++y>2){
    System.out.print(“y=”+y);  // print is: y=3
}

int x = 0;
int y = 2;
if(x==0 && ++y>2){
    System.out.print(“y=”+y);  // print is: y=2
}

& có thể được sử dụng như toán tử bit

&có thể được sử dụng như ANDtoán tử Bitwise , &&không thể.

Toán tử bitwise AND "&" tạo ra 1 khi và chỉ khi cả hai bit trong toán hạng của nó là 1. Tuy nhiên, nếu cả hai bit bằng 0 hoặc cả hai bit đều khác nhau thì toán tử này tạo ra 0. Để chính xác hơn từng bit Toán tử AND "&" trả về 1 nếu bất kỳ một trong hai bit là 1 và nó trả về 0 nếu bất kỳ bit nào là 0. 

Từ trang wiki:

http://www.roseindia.net/java/master-java/java-bitwise-and.shtml

'&&': - là toán tử AND logic tạo ra giá trị boolean là đúng hoặc sai dựa trên mối quan hệ logic của các đối số của nó.

Ví dụ: - Điều kiện1 && Điều kiện2

Nếu Điều kiện 1 là sai, thì (Điều kiện1 && Điều kiện2) sẽ luôn luôn sai, đó là lý do tại sao toán tử logic này còn được gọi là Toán tử ngắn mạch vì nó không đánh giá điều kiện khác. Nếu Điều kiện 1 là sai, thì không cần phải đánh giá Condtiton2.

Nếu Điều kiện 1 là đúng, thì Điều kiện 2 được đánh giá, nếu nó đúng thì kết quả tổng thể sẽ đúng nếu không nó sẽ sai.

'&': - là một toán tử bit và toán tử. Nó tạo ra một (1) trong đầu ra nếu cả hai bit đầu vào là một. Nếu không, nó tạo ra không (0).

Ví dụ:-

int a = 12; // biểu diễn nhị phân của 12 là 1100

int b = 6; // biểu diễn nhị phân của 6 là 0110

int c = (a & b); // biểu diễn nhị phân của (12 & 6) là 0100

Giá trị của c là 4.

để tham khảo, hãy tham khảo http://techno-terminal.blogspot.in/2015/11/difference-b between-operator- and- operator.html

&&và ||được gọi là toán tử ngắn mạch. Khi chúng được sử dụng, for ||- nếu toán hạng đầu tiên ước tính true, thì phần còn lại của toán hạng không được đánh giá. Vì &&- nếu toán hạng đầu tiên ước tính false, phần còn lại của chúng không được đánh giá.

vì vậy if (a || (++x > 0))trong ví dụ này, biến x sẽ không được tăng nếu a true.

Với booleans, không có sự khác biệt đầu ra giữa hai. Bạn có thể trao đổi && và & hoặc || và | và nó sẽ không bao giờ thay đổi kết quả của biểu hiện của bạn.

Sự khác biệt nằm ở phía sau hiện trường nơi thông tin đang được xử lý. Khi bạn đúng một biểu thức "(a! = 0) & (b! = 0)" cho a = 0 và b = 1, điều sau đây xảy ra:

left side: a != 0 --> false
right side: b 1= 0 --> true
left side and right side are both true? --> false
expression returns false

Khi bạn viết một biểu thức (a != 0) && ( b != 0)khi a = 0 và b = 1, điều sau đây xảy ra:

a != 0 -->false
expression returns false

Ít bước hơn, xử lý ít hơn, mã hóa tốt hơn, đặc biệt là khi thực hiện nhiều biểu thức boolean hoặc các đối số phức tạp.

Ngoài && và || bị đoản mạch, cũng xem xét ưu tiên toán tử khi trộn hai dạng. Tôi nghĩ rằng mọi người sẽ không thấy rõ kết quả1 và result2 chứa các giá trị khác nhau.

boolean a = true;
boolean b = false;
boolean c = false;

boolean result1 = a || b && c; //is true;  evaluated as a || (b && c)
boolean result2 = a  | b && c; //is false; evaluated as (a | b) && c

& là toán tử bitwise cộng với được sử dụng để kiểm tra cả hai điều kiện bởi vì đôi khi chúng ta cần đánh giá cả hai điều kiện. Nhưng && toán tử logic chuyển sang điều kiện thứ 2 khi điều kiện đầu tiên cho đúng.

tất cả các câu trả lời là great, và có vẻ như nocâu trả lời nhiều hơn is needed nhưng tôi chỉ không muốn chỉ ra một cái gì đó về &&toán tử được gọidependent condition

Trong các biểu thức sử dụng toán tử &&, một điều kiện, chúng tôi sẽ gọi đây là dependent conditionmột điều kiện đòi hỏi một điều kiện khác là đúng để đánh giá điều kiện phụ thuộc là có ý nghĩa.

Trong trường hợp này, điều kiện phụ thuộc phải được đặt sau toán tử && để tránh lỗi.

Hãy xem xét biểu thức (i != 0) && (10 / i == 2). Điều kiện phụ thuộc (10 / i == 2)phải appear afterlà &&toán tử để ngăn khả năng chia cho số không.

một vi dụ khac (myObject != null) && (myObject.getValue() == somevaluse)

và một điều: &&và ||được gọi là đánh giá ngắn mạch vì đối số thứ hai được thực hiện hoặc đánh giá only ifcác firsttham số không not sufficeđể determinecác valuecủaexpression

Tài liệu tham khảo: Cách lập trình Java ™ (Đối tượng ban đầu), Phiên bản thứ mười