Apa perbedaan antara & dan && di Jawa?

Saya selalu berpikir bahwa &&operator di Jawa digunakan untuk memverifikasi apakah kedua operan booleannya true, dan &operator digunakan untuk melakukan operasi Bit-Wise pada dua tipe integer.

Baru-baru ini saya mengetahui bahwa &operator juga dapat digunakan memverifikasi apakah kedua operan boolean-nya true, satu-satunya perbedaan adalah bahwa ia memeriksa operan RHS bahkan jika operan LHS salah.

Apakah &operator di Jawa kelebihan beban secara internal? Atau ada konsep lain di balik ini?

& <- memverifikasi kedua operan
&& <- berhenti mengevaluasi jika operan pertama bernilai false karena hasilnya akan salah

(x != 0) & (1/x > 1)<- ini berarti mengevaluasi (x != 0)lalu mengevaluasi (1/x > 1)lalu lakukan &. masalahnya adalah untuk x = 0 ini akan memunculkan eksepsi.

(x != 0) && (1/x > 1)<- ini berarti mengevaluasi (x != 0)dan hanya jika ini benar maka evaluasi (1/x > 1)jadi jika Anda memiliki x = 0 maka ini benar-benar aman dan tidak akan membuang pengecualian jika (x! = 0) mengevaluasi ke false semuanya langsung mengevaluasi ke false tanpa mengevaluasi (1/x > 1).

EDIT:

exprA | exprB<- ini berarti mengevaluasi exprAlalu mengevaluasi exprBlalu lakukan |.

exprA || exprB<- ini berarti mengevaluasi exprAdan hanya jika ini falsekemudian mengevaluasi exprBdan melakukan ||.

Selain tidak menjadi evaluator yang malas dengan mengevaluasi kedua operan, saya pikir karakteristik utama dari operator bitwise membandingkan setiap byte operan seperti dalam contoh berikut:

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

Itu tergantung pada jenis argumen ...

Untuk argumen integer, ampersand tunggal ("&") adalah operator "sedikit-bijaksana DAN". Double ampersand ("&&") tidak didefinisikan untuk apa pun kecuali dua argumen boolean.

Untuk argumen boolean, single ampersand merupakan operator "logical AND" (tanpa syarat) sedangkan double ampersand ("&&") adalah operator "conditional logical AND". Artinya, single ampersand selalu mengevaluasi kedua argumen sedangkan double ampersand hanya akan mengevaluasi argumen kedua jika argumen pertama benar.

Untuk semua jenis argumen dan kombinasi lainnya, kesalahan waktu kompilasi harus terjadi.

&& adalah operator hubungan pendek sedangkan & adalah operator DAN.

Coba ini.

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

seperti yang ditentukan dalam JLS (15.22.2) :

Ketika kedua operan dari &, ^, atau | operator bertipe boolean atau Boolean, maka jenis ekspresi operator bitwise adalah boolean. Dalam semua kasus, operan tunduk pada konversi unboxing (§5.1.8) sebagaimana diperlukan.

Untuk &, nilai hasil adalah benar jika kedua nilai operan benar; jika tidak, hasilnya salah.

Untuk ^, nilai hasilnya benar jika nilai operan berbeda; jika tidak, hasilnya salah.

Untuk |, nilai hasil salah jika kedua nilai operan salah; jika tidak, hasilnya benar.

"Trik" adalah yang &merupakan Operator Bitwise Integer serta Operator Logical Boolean . Jadi mengapa tidak, melihat ini sebagai contoh untuk operator yang berlebihan adalah masuk akal.

Saya pikir jawaban saya bisa lebih dimengerti:

Ada dua perbedaan antara &dan &&.

Jika mereka menggunakan AND

&dan &&bisa logis AND, ketika &atau &&kiri dan ungkapan yang tepat menghasilkan semua benar, hasil operasi seluruh bisa benar.

kapan &dan &&sebagai logis AND, ada perbedaan:

saat digunakan &&sebagai logis AND, jika hasil ekspresi kiri salah, ekspresi kanan tidak akan dijalankan.

Ambil contoh:

String str = null;

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

}

Jika menggunakan &:

String str = null;

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

}

Contoh lainnya:

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
}

& dapat digunakan sebagai operator bit

&dapat digunakan sebagai ANDoperator Bitwise , &&tidak bisa.

Operator bitwise AND "&" menghasilkan 1 jika dan hanya jika kedua bit dalam operandnya adalah 1. Namun, jika kedua bit tersebut adalah 0 atau kedua bit tersebut berbeda maka operator ini menghasilkan 0. Untuk lebih tepat bitwise DAN "&" operator mengembalikan 1 jika salah satu dari dua bit adalah 1 dan mengembalikan 0 jika salah satu dari bit adalah 0. 

Dari halaman wiki:

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

'&&': - adalah operator DAN logis yang menghasilkan nilai boolean benar atau salah berdasarkan hubungan logis dari argumennya.

Misalnya: - Condition1 && Condition2

Jika Condition1 salah, maka (Condition1 && Condition2) akan selalu salah, itulah alasan mengapa operator logis ini juga dikenal sebagai Operator Sirkuit Pendek karena tidak mengevaluasi kondisi lain. Jika Condition1 salah, maka tidak perlu untuk mengevaluasi Condtiton2.

Jika Condition1 benar, maka Condition2 dievaluasi, jika itu benar maka hasil keseluruhan akan benar lain itu akan salah.

'&': - adalah Operator Bitwise DAN. Ini menghasilkan satu (1) dalam output jika kedua bit input adalah satu. Kalau tidak menghasilkan nol (0).

Sebagai contoh:-

int a = 12; // representasi biner dari 12 adalah 1100

int b = 6; // representasi biner dari 6 adalah 0110

int c = (a & b); // Representasi biner dari (12 & 6) adalah 0100

Nilai c adalah 4.

untuk referensi, lihat http://techno-terminal.blogspot.in/2015/11/difference-between-operator-and-operator.html ini

&&dan ||disebut operator hubungan pendek. Ketika mereka digunakan, untuk ||- jika operan pertama dievaluasi true, maka sisa operan tidak dievaluasi. Untuk &&- jika operan pertama dievaluasi false, sisanya tidak dievaluasi sama sekali.

jadi if (a || (++x > 0))dalam contoh ini variabel x tidak akan bertambah jika ada true.

Dengan boolean, tidak ada perbedaan output antara keduanya. Anda dapat menukar && dan & atau || dan | dan itu tidak akan pernah mengubah hasil dari ekspresi Anda.

Perbedaannya terletak di belakang adegan di mana informasi sedang diproses. Saat Anda benar ekspresi "(a! = 0) & (b! = 0)" untuk a = 0 dan b = 1, Berikut ini terjadi:

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

Saat Anda menulis ekspresi (a != 0) && ( b != 0)ketika a = 0 dan b = 1, berikut ini terjadi:

a != 0 -->false
expression returns false

Lebih sedikit langkah, kurang pemrosesan, pengkodean yang lebih baik, terutama ketika melakukan banyak ekspresi boolean atau argumen rumit.

Selain && dan || karena hubungan arus pendek, pertimbangkan juga prioritas operator saat menggabungkan kedua bentuk. Saya pikir itu tidak akan segera jelas bagi semua orang bahwa result1 dan result2 mengandung nilai yang berbeda.

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

& adalah operator bitwise plus digunakan untuk memeriksa kedua kondisi karena kadang-kadang kita perlu mengevaluasi kedua kondisi. Tapi && operator logis masuk ke kondisi ke-2 ketika kondisi pertama memberikan true.

semua jawaban adalah great, dan tampaknya nolebih banyak jawaban is needed tetapi saya tidak ingin menunjukkan sesuatu tentang &&operator yang dipanggildependent condition

Dalam ekspresi menggunakan operator &&, suatu kondisi — kita akan menyebutnya sebagai dependent condition—mungkin memerlukan kondisi lain yang benar agar evaluasi kondisi dependen menjadi bermakna.

Dalam hal ini, kondisi dependen harus ditempatkan setelah operator && untuk mencegah kesalahan.

Pertimbangkan ungkapannya (i != 0) && (10 / i == 2). Kondisi tergantung (10 / i == 2)harus appear afteryang &&operator untuk mencegah kemungkinan pembagian dengan nol.

contoh lain (myObject != null) && (myObject.getValue() == somevaluse)

dan hal lain: &&dan ||disebut arus pendek evaluasi karena argumen kedua dijalankan atau dievaluasi only ifdengan firstargumen tidak not sufficeuntuk determineyang valuedariexpression

Referensi: Java ™ Cara Memprogram (Objek Awal), Edisi Kesepuluh