Java'da & ve && arasındaki fark nedir?

Hep düşündüm &&Java operatörü hem boolean işlenenlerdir olmadığını doğrulamak için kullanılır trueve &operatör iki tamsayı türlerinde Bit-bilge işlemleri yapmak için kullanılır.

Son zamanlarda, &operatörün her iki boolean işleneni olup olmadığını doğrulamak için kullanılabileceğini de öğrendim true, tek fark, LHS işleneni yanlış olsa bile RHS işlenmesini kontrol etmesidir.

Is &Java operatör dahili aşırı? Yoksa bunun arkasında başka bir kavram var mı?

& <- her iki işleneni de doğrular
&& <- sonuç yanlış olacağından ilk işlenenin false olarak değerlendirilip değerlendirilmediğini değerlendirmeyi durdurur

(x != 0) & (1/x > 1)<- Bu, değerlendirme (x != 0)sonra değerlendirme (1/x > 1)sonra & yapmak anlamına gelir . sorun x = 0 için bunun bir istisna atmasıdır.

(x != 0) && (1/x > 1)<- Bu, değerlendirme anlamına gelir (x != 0)ve yalnızca bu doğruysa, o zaman değerlendirin; (1/x > 1)bu nedenle x = 0 varsa, bu tamamen güvenlidir ve (x! = 0) yanlış olarak değerlendirirse, her şey doğrudan yanlış olarak değerlendirilirse herhangi bir istisna atmaz. değerlendirmeden (1/x > 1).

DÜZENLE:

exprA | exprB<- Bu, değerlendirme exprAsonra değerlendirme exprBsonra yapmak anlamına gelir |.

exprA || exprB<- Bu, değerlendirme anlamına gelir exprAve ancak bu daha falsesonra değerlendirilir exprBve yapılırsa ||.

Her iki işleneni de değerlendirerek tembel bir değerlendirici olmanın yanı sıra, bitsel operatörlerin temel özelliklerinin aşağıdaki örnekte olduğu gibi işlenenlerin her baytını karşılaştırdığını düşünüyorum:

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

Argümanların türüne bağlıdır ...

Tamsayı bağımsız değişkenleri için tek ve işareti ("&") "bit-bilge AND" operatörüdür. Çift ve işareti ("&&") iki boole argümanından başka bir şey için tanımlanmamıştır.

Boole bağımsız değişkenleri için, tek ve işareti (koşulsuz) "mantıksal AND" operatörünü, çift ve işareti ("&&") "koşullu mantıksal AND" operatörünü oluşturur. Yani tek ve işareti her iki argümanı da değerlendirirken, çift ve sadece ikinci argümanı sadece ilk argüman doğruysa değerlendirir.

Diğer tüm argüman türleri ve kombinasyonları için bir derleme zamanı hatası oluşmalıdır.

&& kısa devre operatörü, && ise AND operatörüdür.

Bunu dene.

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

JLS'de belirtildiği gibi (15.22.2) :

Bir &, ^ veya | operatörü boolean veya Boolean türündeyse, bitsel operatör ifadesinin türü boolean olur. Her durumda, işlenenler gerektiğinde kutudan çıkarma dönüşümüne (§5.1.8) tabidir.

& İçin, her iki işlenen değer de doğruysa sonuç değeri doğrudur; aksi takdirde sonuç yanlıştır.

^ İçin, işlenen değerleri farklıysa sonuç değeri doğrudur; aksi takdirde sonuç yanlıştır.

| İçin, her iki işlenen değeri de false olursa sonuç değeri false olur; aksi takdirde sonuç doğrudur.

"Hile" &bir Tamsayı Bitsel İşleci ve bir Boolean Mantıksal İşleci olmasıdır . Peki neden olmasın, bunu operatörün aşırı yüklenmesi için bir örnek olarak görmek makul.

Cevabımın daha anlaşılır olabileceğini düşünüyorum:

Arasında iki fark vardır &ve &&.

Mantıksal VE

&ve &&mantıksal olabilir AND, &veya&& sol ve sağ ifade sonuçlarının tümü doğru olduğunda, tüm işlem sonucu doğru olabilir.

ne zaman &ve &&mantıklıAND , bir fark vardır:

&&mantıksal olarak kullanıldığındaAND , sol ifade sonucu yanlışsa, sağ ifade yürütülmez.

Örneği ele alalım:

String str = null;

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

}

Kullanıyorsanız &:

String str = null;

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

}

Başka bir örnek:

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
}

& bit operatörü olarak kullanılabilir

&Bitwise ANDoperatörü olarak kullanılabilir , &&yapamaz.

Bitsel AND "&" operatörü, yalnızca işlenenlerindeki bitlerin her ikisi de 1 ise, 1 üretir. Ancak, her iki bit de 0 ise veya her iki bit de farklıysa, bu operatör 0 üretir. AND "&" operatörü, iki bitten herhangi biri 1 olduğunda 1 döndürür ve bitlerden herhangi biri 0 ise 0 döndürür. 

Wiki sayfasından:

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

'&&': - bir Mantıksal AND işleci argümanlarının mantıksal ilişkisine dayanarak doğru veya yanlış bir boolean değeri üretir.

Örneğin: - Koşul1 ve& Koşul2

Koşul1 yanlışsa, (Koşul1 && Koşul2) her zaman yanlış olur, bu nedenle bu mantıksal işleç aynı zamanda Kısa Devre Operatörü olarak da bilinir, çünkü başka bir durumu değerlendirmez. Koşul1 yanlışsa, Koşul 2'yi değerlendirmeye gerek yoktur.

Koşul1 doğruysa, Koşul2 değerlendirilir, doğruysa genel sonuç doğru olur, aksi takdirde yanlış olur.

'&': - bir Bitwise AND Operator. Her iki giriş biti de bir ise, çıkışta bir (1) üretir. Aksi takdirde sıfır (0) üretir.

Örneğin:-

int a = 12; // 12'nin ikili gösterimi 1100'dür

int b = 6; // 6'nın ikili gösterimi 0110

int c = (a & b); // (12 ve 6) 'nın ikili gösterimi 0100

C'nin değeri 4'tür.

referans için bu http://techno-terminal.blogspot.in/2015/11/difference-between-operator-and-operator.html adresine bakın.

&&ve ||buna kısa devre operatörleri denir. Kullanıldıklarında, çünkü ||- ilk işlenen değerlendirilirse true, işlenenlerin geri kalanı değerlendirilmez. İçin &&- ilk işlenen şu şekilde değerlendirirse:false , geri kalanı hiç değerlendirilmez.

bu nedenle if (a || (++x > 0))bu örnekte, x değişkeni, a olsaydı artırılmaz true.

Booleans ile ikisi arasında çıkış farkı yoktur. && ve & veya || ve | ve asla ifadenizin sonucunu değiştirmez.

Fark, bilginin işlendiği sahnenin arkasında yatar. A = 0 ve b = 1 için "(a! = 0) & (b! = 0)" ifadesini düzelttiğinizde, aşağıdakiler gerçekleşir:

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

(a != 0) && ( b != 0)A = 0 ve b = 1 olduğunda bir ifade yazdığınızda, aşağıdakiler gerçekleşir:

a != 0 -->false
expression returns false

Özellikle çok sayıda boole ifadesi veya karmaşık argümanlar yaparken daha az adım, daha az işlem, daha iyi kodlama.

&& ve || kısa devre olduğundan, iki formu karıştırırken operatörün önceliğini de göz önünde bulundurun. Sonuç1 ve sonuç2'nin farklı değerler içerdiği herkes tarafından hemen görülmeyecek.

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

& her iki koşulu kontrol etmek için kullanılan bitsel bir operatör artıdır çünkü bazen her iki koşulu da değerlendirmemiz gerekir. Ancak && mantıksal operatör, ilk koşul doğru olduğunda 2. koşula gider.

tüm cevaplar great, ve öyle görünüyor ki nodaha fazla cevap is needed ama ben sadece hakkında bir şey işaret etmek için kazandı&& operatör denilen birdependent condition

&& ifadesini kullanan ifadelerde - buna “biz diyoruz dependent condition” - bağımlı koşulun değerlendirmesinin anlamlı olması için başka bir koşulun doğru olmasını gerektirebilir.

Bu durumda, hataları önlemek için bağımlı koşul && operatörünün arkasına yerleştirilmelidir.

İfadeyi düşünün (i != 0) && (10 / i == 2). Bağımlı koşul , sıfıra bölünme olasılığını önlemek için operatörün yapması (10 / i == 2)gerekir .appear after&&

başka bir örnek (myObject != null) && (myObject.getValue() == somevaluse)

ve başka bir şey: &&ve ||denir kısa devre değerlendirme ikinci bağımsız yürütülür ya da değerlendirilir çünkü argüman yapar içinonly iffirstnot sufficedeterminevalue arasındaexpression

Kaynaklar: Java ™ Nasıl Programlanır (Erken Nesneler), Onuncu Baskı