Kenapa kita biasanya menggunakan || lebih | Apa bedanya?

Saya hanya ingin tahu mengapa kita biasanya menggunakan OR logis ||antara dua boolean bukan bitwise ATAU |, meskipun keduanya bekerja dengan baik.

Maksud saya, lihat yang berikut ini:

if(true  | true)  // pass
if(true  | false) // pass
if(false | true)  // pass
if(false | false) // no pass

if(true  || true)  // pass
if(true  || false) // pass
if(false || true)  // pass
if(false || false) // no pass

Bisakah kita menggunakan |bukan ||? Hal yang sama dengan &dan &&.

Jika Anda menggunakan ||dan &&formulir, dan bukan |dan &dari operator ini, Java tidak akan repot untuk mengevaluasi operan kanan saja.

Masalahnya adalah apakah Anda ingin mempersingkat evaluasi atau tidak - sebagian besar waktu yang Anda inginkan.

Cara yang baik untuk menggambarkan manfaat hubungan arus pendek adalah dengan mempertimbangkan contoh berikut.

Boolean b = true;
if(b || foo.timeConsumingCall())
{
   //we entered without calling timeConsumingCall()
}

Manfaat lain, seperti yang disebutkan Jeremy dan Peter, untuk hubungan pendek adalah pemeriksaan referensi nol:

if(string != null && string.isEmpty())
{
    //we check for string being null before calling isEmpty()
}

Info lebih lanjut

| tidak melakukan evaluasi hubung singkat dalam ekspresi boolean. ||akan berhenti mengevaluasi jika operan pertama benar, tetapi |tidak akan.

Selain itu, |dapat digunakan untuk melakukan operasi bitwise-OR pada nilai byte / pendek / int / panjang. ||tidak bisa.

Jadi, hanya untuk membangun jawaban lain dengan sebuah contoh, hubungan arus pendek sangat penting dalam pemeriksaan defensif berikut:

if (foo == null || foo.isClosed()) {
    return;
}

if (bar != null && bar.isBlue()) {
    foo.doSomething();
}

Menggunakan |dan &sebagai gantinya dapat menyebabkan NullPointerExceptiondilemparkan ke sini.

Logis ||dan &&periksa sisi kanan hanya jika perlu. The |dan &memeriksa kedua sisi setiap kali.

Sebagai contoh:

int i = 12;
if (i == 10 & i < 9) // It will check if i == 10 and if i < 9
...

Tulis ulang:

int i = 12;
if (i == 10 && i < 9) // It will check if i == 10 and stop checking afterward because i != 10
...

Contoh lain:

int i = 12;
if (i == 12 | i > 10) // It will check if i == 12 and it will check if i > 10
...

Tulis ulang:

int i = 12;
if (i == 12 || i > 10) // It will check if i == 12, it does, so it stops checking and executes what is in the if statement
...

Perhatikan juga jebakan yang umum: Operator yang tidak malas mendahului operator yang malas, jadi:

boolean a, b, c;
a || b && c; //resolves to a || (b && c)
a | b && c; //resolves to (a | b) && c

Hati-hati saat mencampurnya.

Selain hubungan arus pendek, hal lain yang perlu diingat adalah melakukan operasi logika bitwise pada nilai yang bisa selain 0 atau 1 memiliki arti yang sangat berbeda dari logika kondisional. Meskipun BIASANYA adalah sama untuk |dan ||, dengan &dan &&Anda mendapatkan hasil yang sangat berbeda (mis. 2 & 40 / false sedangkan 2 && 41 / benar).

Jika hal yang Anda peroleh dari suatu fungsi sebenarnya adalah kode kesalahan dan Anda sedang menguji untuk non-0-ness, ini bisa sangat berarti.

Ini bukan masalah di Jawa di mana Anda harus secara eksplisit mengetik typecast ke boolean atau membandingkan dengan 0 atau sejenisnya, tetapi dalam bahasa lain dengan sintaksis yang sama (C / C ++ et al) itu bisa sangat membingungkan.

Juga, perhatikan bahwa & dan | hanya bisa berlaku untuk nilai tipe integer, dan tidak semua yang setara dengan tes boolean. Sekali lagi, dalam bahasa non-Jawa, ada beberapa hal yang dapat digunakan sebagai boolean dengan != 0perbandingan implisit (pointer, float, objek dengan operator bool(), dll.) Dan operator bitwise hampir selalu tidak masuk akal dalam konteks tersebut.

Satu-satunya waktu Anda akan menggunakan |atau &bukan ||atau &&adalah ketika Anda memiliki ekspresi boolean yang sangat sederhana dan biaya pemotongan pendek (yaitu cabang) lebih besar dari waktu yang Anda simpan dengan tidak mengevaluasi ekspresi nanti.

Namun, ini adalah optimasi mikro yang jarang penting kecuali dalam kode level paling rendah.

|| adalah operator logika atau sementara | adalah bitwise atau operator.

boolean a = true;
boolean b = false;

if (a || b) {
}

int a = 0x0001;
a = a | 0x0002;

a | b: mengevaluasi b dalam hal apa pun

a || b: mengevaluasi b hanya jika a bernilai false

Selain fakta bahwa | adalah operator bitwise: || adalah operator hubungan pendek - ketika satu elemen salah, ia tidak akan memeriksa yang lain.

 if(something || someotherthing)
 if(something | someotherthing)

jika ada sesuatu yang BENAR, || tidak akan mengevaluasi apa pun, sementara | akan melakukan. Jika variabel dalam pernyataan-if Anda sebenarnya adalah panggilan fungsi, gunakan || mungkin menghemat banyak kinerja.

| is the binary or operator

|| is the logic or operator

Operator ||dan &&disebut operator kondisional , sementara |dan &disebut operator bitwise . Mereka melayani tujuan yang berbeda.

Operator bersyarat hanya bekerja dengan ekspresi yang secara statis dievaluasi booleandi kedua sisi kiri dan kanan.

Operator bitwise bekerja dengan operan numerik apa pun.

Jika Anda ingin melakukan perbandingan logis, Anda harus menggunakan operator kondisional , karena Anda akan menambahkan semacam jenis keamanan ke kode Anda.

Catatan samping: Java memiliki | = tetapi bukan || =

Contoh kapan Anda harus menggunakan || adalah ketika ekspresi pertama adalah ujian untuk melihat apakah ekspresi kedua akan meledak. mis. Menggunakan satu | dalam hte, kasus berikut dapat menghasilkan NPE.

public static boolean isNotSet(String text) {
   return text == null || text.length() == 0;
}

Jawaban lain telah melakukan pekerjaan yang baik untuk menutupi perbedaan fungsional antara operator, tetapi jawaban itu dapat berlaku untuk hampir semua bahasa yang diturunkan dari C yang ada saat ini. Pertanyaan ditandai denganJawa, dan saya akan berusaha menjawab secara khusus dan teknis untuk bahasa Jawa.

&dan |dapat berupa Integer Bitwise Operators, atau Boolean Logical Operator. Sintaks untuk Operator Bitwise dan Logical ( §15.22 ) adalah:

AndExpression:
  EqualityExpression 
  AndExpression & EqualityExpression

ExclusiveOrExpression:
  AndExpression 
  ExclusiveOrExpression ^ AndExpression

InclusiveOrExpression:
  ExclusiveOrExpression 
  InclusiveOrExpression | ExclusiveOrExpression

Sintaks untuk EqualityExpressiondidefinisikan dalam §15.21 , yang mengharuskan RelationalExpressiondidefinisikan dalam §15.20 , yang pada gilirannya memerlukan ShiftExpressiondan ReferenceTypedidefinisikan dalam §15.19 dan §4.3 , masing-masing. ShiftExpressionmembutuhkan AdditiveExpressiondidefinisikan dalam §15.18 , yang terus menelusuri , mendefinisikan aritmatika dasar, operator unary, dll. ReferenceTypemengebor semua cara untuk mewakili suatu jenis. (Sementara ReferenceTypetidak termasuk tipe primitif, definisi tipe primitif akhirnya diperlukan, karena mereka mungkin tipe dimensi untuk array, yang merupakan sebuah ReferenceType.)

Operator Bitwise dan Logical memiliki properti berikut:

• Operator ini memiliki prioritas yang berbeda, dengan &memiliki prioritas tertinggi dan |prioritas terendah.
• Masing-masing operator ini secara sintaksis kiri-asosiatif (masing-masing kelompok kiri-ke-kanan).
• Setiap operator bersifat komutatif jika ekspresi operan tidak memiliki efek samping.
• Setiap operator bersifat asosiatif.
• Operator bitwise dan logis dapat digunakan untuk membandingkan dua operan tipe numerik atau dua operan tipe boolean. Semua kasus lainnya menghasilkan kesalahan waktu kompilasi.

Perbedaan antara apakah operator berfungsi sebagai operator bitwise atau operator logis tergantung pada apakah operan "dapat dikonversi ke tipe integral primitif" ( §4.2 ) atau jika mereka bertipeboolean atau Boolean( §5.1.8 ).

Jika operan adalah tipe integral, promosi numerik biner ( §5.6.2 ) dilakukan pada kedua operan, menjadikan keduanya sebagai longs atau ints untuk operasi. Jenis operasi akan menjadi jenis operan (dipromosikan). Pada saat itu, &akan menjadi bitwise AND, ^akan menjadi bitwise eksklusif ATAU, dan |akan termasuk bitwise ATAU. ( §15.22.1 )

Jika operan adalah booleanatau Boolean, operan akan dikenakan konversi unboxing jika perlu ( §5.1.8 ), dan jenis operasinya akan boolean. &akan menghasilkan truejika kedua operan true, ^akan menghasilkan truejika kedua operan berbeda, dan |akan menghasilkan truejika salah satu operan true. ( §15.22.2 )

Sebaliknya, && adalah "Kondisional-Dan Operator" ( §15.23 ) dan ||"Kondisional-Atau Operator" ( §15.24 ). Sintaksnya didefinisikan sebagai:

ConditionalAndExpression:
  InclusiveOrExpression 
  ConditionalAndExpression && InclusiveOrExpression

ConditionalOrExpression:
  ConditionalAndExpression 
  ConditionalOrExpression || ConditionalAndExpression

&&seperti &, kecuali hanya mengevaluasi operan kanan jika operan kiri true. ||seperti |, kecuali hanya mengevaluasi operan kanan jika operan kiri false.

Conditional-And memiliki sifat-sifat berikut:

• Conditional-and operator secara sintaksis kiri-asosiatif (mengelompokkan kiri-ke-kanan).
• Operator bersyarat dan sepenuhnya asosiatif sehubungan dengan efek samping dan nilai hasil. Yaitu, untuk setiap ekspresi a,, bdan c, evaluasi ekspresi ((a) && (b)) && (c)menghasilkan hasil yang sama, dengan efek samping yang sama terjadi dalam urutan yang sama, seperti evaluasi ekspresi (a) && ((b) && (c)).
• Setiap operand kondisional dan operator harus bertipe booleanatau Boolean, atau kesalahan waktu kompilasi terjadi.
• Tipe dari conditional-and expression selalu boolean.
• Pada waktu berjalan, ekspresi operan kiri dievaluasi terlebih dahulu; jika hasilnya bertipe Boolean, maka akan dikenakan konversi unboxing ( §5.1.8 ).
• Jika nilai yang dihasilkan adalah false, nilai ekspresi kondisional dan adalah falsedan ekspresi operan kanan tidak dievaluasi.
• Jika nilai operan tangan kiri adalah true, maka ekspresi tangan kanan dievaluasi; jika hasilnya bertipe Boolean, maka akan dikenakan konversi unboxing ( §5.1.8 ). Nilai yang dihasilkan menjadi nilai dari kondisi-dan ekspresi.
• Jadi, &&hitung hasil yang sama seperti &pada booleanoperan. Perbedaannya hanya pada ekspresi operan kanan dievaluasi secara kondisional daripada biasanya.

Conditional-Atau memiliki sifat-sifat berikut:

• Kondisional-atau operator secara sintaksis kiri-asosiatif (mengelompokkan kiri-ke-kanan).
• Operator bersyarat - atau sepenuhnya asosiatif sehubungan dengan efek samping dan nilai hasil. Yaitu, untuk setiap ekspresi a,, bdan c, evaluasi ekspresi ((a) || (b)) || (c)menghasilkan hasil yang sama, dengan efek samping yang sama terjadi dalam urutan yang sama, seperti evaluasi ekspresi (a) || ((b) || (c)).
• Setiap operand dari conditional-atau operator harus bertipe booleanatau Boolean, atau kesalahan waktu kompilasi terjadi.
• Jenis ekspresi atau kondisi selalu boolean.
• Pada waktu berjalan, ekspresi operan kiri dievaluasi terlebih dahulu; jika hasilnya bertipe Boolean, maka akan dikenakan konversi unboxing ( §5.1.8 ).
• Jika nilai yang dihasilkan adalah true, nilai kondisional-atau ekspresi adalah truedan ekspresi operan kanan tidak dievaluasi.
• Jika nilai operan tangan kiri adalah false, maka ekspresi tangan kanan dievaluasi; jika hasilnya bertipe Boolean, maka akan dikenakan konversi unboxing ( §5.1.8 ). Nilai yang dihasilkan menjadi nilai dari conditional-atau ekspresi.
• Jadi, ||hitung hasil yang sama seperti |pada booleanatau Booleanoperan. Perbedaannya hanya pada ekspresi operan kanan dievaluasi secara kondisional daripada biasanya.

Singkatnya, seperti @JohnMeagher telah berulang kali menunjukkan dalam komentar, &dan |, pada kenyataannya, adalah operator boolean non-korsleting dalam kasus spesifik dari operan baik booleanatau Boolean. Dengan praktik yang baik (yaitu: tidak ada efek sekunder), ini adalah perbedaan kecil. Ketika operan tidak booleans atau Booleans, bagaimanapun, operator berperilaku sangat berbeda: operasi bitwise dan logis tidak bisa dibandingkan dengan baik pada pemrograman Java tingkat tinggi.

1). (Ekspresi1 | ekspresi2), | operator akan mengevaluasi ekspresi2 terlepas dari apakah hasil ekspresi1 benar atau salah.

Contoh:

class Or 
{
    public static void main(String[] args) 
    {
        boolean b=true;

        if (b | test());
    }

    static boolean test()
    {
        System.out.println("No short circuit!");
        return false;
    }
}

2). (Expression1 || expression2), || operator tidak akan mengevaluasi ekspresi2 jika ekspresi1 benar.

Contoh:

class Or 
{
    public static void main(String[] args) 
    {
        boolean b=true;

        if (b || test())
        {
            System.out.println("short circuit!");
        }
    }

    static boolean test()
    {
        System.out.println("No short circuit!");
        return false;
    }
}

|| mengembalikan nilai boolean dengan OR'ing dua nilai (Itulah sebabnya dikenal sebagai LOGIS atau)

YAITU:

if (A || B) 

Akan mengembalikan true jika A atau B benar, atau salah jika keduanya salah.

| adalah operator yang melakukan operasi bitwise pada dua nilai. Untuk lebih memahami operasi bitwise, Anda dapat membaca di sini:

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

Satu perbedaan utama adalah bahwa || dan && menunjukkan "hubungan arus pendek", sehingga RHS hanya akan dievaluasi jika diperlukan.

Untuk misalnya

if (a || b) {
    path1...
} else {
    path2..
}

Di atas jika a benar maka b tidak akan diuji dan path1 dieksekusi. Jika | digunakan maka kedua belah pihak akan dievaluasi bahkan jika 'a' benar.

Lihat Di Sini dan di sini , untuk informasi lebih lanjut.

Semoga ini membantu.

Non-hubungan arus pendek dapat bermanfaat. Terkadang Anda ingin memastikan bahwa dua ekspresi mengevaluasi. Misalnya, Anda memiliki metode yang menghapus objek dari dua daftar terpisah. Anda mungkin ingin melakukan sesuatu seperti ini:

class foo {

    ArrayList<Bar> list1 = new ArrayList<Bar>();
    ArrayList<Bar> list2 = new ArrayList<Bar>();

    //Returns true if bar is removed from both lists, otherwise false.
    boolean removeBar(Bar bar) {
        return (list1.remove(bar) & list2.remove(bar));
    }
}

Jika metode Anda sebagai gantinya menggunakan operan bersyarat, itu akan gagal untuk menghapus objek dari daftar kedua jika daftar pertama kembali palsu.

//Fails to execute the second remove if the first returns false.
boolean removeBar(Bar bar) {
    return (list1.remove(bar) && list2.remove(bar));
}

Ini tidak terlalu berguna, dan (seperti pada kebanyakan tugas pemrograman) Anda dapat mencapainya dengan cara lain. Tapi ini adalah kasus penggunaan untuk operan bitwise.

Perbedaan mendasar di antara mereka adalah bahwa | pertama-tama mengkonversi nilai-nilai ke biner kemudian melakukan sedikit bijak atau operasi. Sementara itu, || tidak mengubah data menjadi biner dan hanya melakukan atau ekspresi pada kondisi aslinya.

int two = -2; int four = -4;
result = two | four; // bitwise OR example

System.out.println(Integer.toBinaryString(two));
System.out.println(Integer.toBinaryString(four));
System.out.println(Integer.toBinaryString(result));

Output:
11111111111111111111111111111110
11111111111111111111111111111100
11111111111111111111111111111110

Baca selengkapnya: http://javarevisited.blogspot.com/2015/01/difference-between-bitwsie-and-logical.html#ixzz45PCxdQhk

Ketika saya memiliki pertanyaan ini, saya membuat kode uji untuk mendapatkan ide tentang ini.

public class HelloWorld{

   public static boolean bool(){
      System.out.println("Bool");
      return true;
   }

   public static void main(String []args){

     boolean a = true;
     boolean b = false;

     if(a||bool())
     {
        System.out.println("If condition executed"); 
     }
     else{
         System.out.println("Else condition executed");
     }

 }
}

Dalam hal ini, kami hanya mengubah nilai sisi kiri jika kondisi menambahkan a atau b.

|| Skenario, ketika sisi kiri true [if (a || bool ())]

keluaran "If condition executed"

|| Skenario, ketika sisi kiri false [if (b || bool ())]

Keluaran-

Bool
If condition executed

Conclusion of || Saat digunakan ||, sisi kanan hanya memeriksa ketika sisi kiri salah.

| Skenario, ketika sisi kiri true [if (a | bool ())]

Keluaran-

Bool
If condition executed

| Skenario, ketika sisi kiri false [if (b | bool ())]

Keluaran-

Bool
If condition executed

Conclusion of | Saat digunakan |, periksa sisi kiri dan kanan.

| = bitwise atau, || = logika atau

biasanya saya gunakan ketika ada operator increment dan post increment. Lihatlah kode berikut:

package ocjpPractice;
/**
 * @author tithik
 *
 */
public class Ex1 {

    public static void main(String[] args) {
    int i=10;
    int j=9;
    int x=10;
    int y=9;
    if(i==10 | ++i>j){
        System.out.println("it will print in first if");  
        System.out.println("i is: "+i);
    }

    if(x==10 ||++x>y){
        System.out.println("it will print in second if");   
        System.out.println("x is: "+x);
    }
    }
}

keluaran:

itu akan mencetak pertama jika
saya adalah: 11

akan mencetak dalam kedua jika
x adalah: 10

kedua ifblok sama tetapi hasilnya berbeda. ketika ada |, kedua kondisi akan dievaluasi. Tetapi jika ya ||, itu tidak akan mengevaluasi kondisi kedua karena kondisi pertama sudah benar.

Ada banyak kasus penggunaan yang menunjukkan mengapa Anda harus ||memilih |. Beberapa kasus penggunaan harus menggunakan |operator untuk memeriksa semua kondisi.

Misalnya, jika Anda ingin memeriksa validasi formulir dan Anda ingin memperlihatkan kepada pengguna semua bidang yang tidak valid dengan teks kesalahan dan bukan hanya bidang yang tidak valid pertama.

|| operator akan menjadi,

   if(checkIfEmpty(nameField) || checkIfEmpty(phoneField) || checkIfEmpty(emailField)) {
      // invalid form with one or more empty fields
   }

   private boolean checkIfEmpty(Widget field) {
      if(field.isEmpty()) {
        field.setErrorMessage("Should not be empty!");
        return true;
      }
      return false;
   }

Jadi dengan cuplikan di atas, jika pengguna mengirimkan formulir dengan SEMUA bidang kosong, HANYA nameFieldakan ditampilkan dengan pesan kesalahan. Tetapi, jika Anda mengubahnya menjadi,

   if(checkIfEmpty(nameField) | checkIfEmpty(phoneField) | checkIfEmpty(emailField)) {
      // invalid form with one or more empty fields
   }

Ini akan menampilkan pesan kesalahan yang tepat pada setiap bidang terlepas dari truekondisi.

Setelah membaca dengan seksama topik ini masih belum jelas bagi saya jika menggunakan |sebagai operator logis sesuai dengan praktik pola Java.

Saya baru-baru ini memodifikasi kode dalam permintaan tarik mengalamatkan komentar di mana

if(function1() | function2()){
  ...
}

harus diubah menjadi

boolean isChanged = function1();
isChanged |= function2();
if (isChanged){
  ...
}

Apa versi yang sebenarnya diterima?

Dokumentasi Java tidak disebutkan |sebagai operator OR non-shortcircuiting yang logis.

Tidak tertarik dengan pemungutan suara, tetapi lebih pada menemukan standar ?! Kedua versi kode mengkompilasi dan berfungsi seperti yang diharapkan.

|| itu logis atau dan | sedikit bijak atau.

Operator Java

| bitwise atau, || logis atau.

Melihat:

http://java.sun.com/docs/books/tutorial/java/nutsandbolts/operators.html

| termasuk ATAU bitwise

|| logis ATAU

| adalah operator bitwise. || adalah operator yang logis.

Satu akan mengambil dua bit dan atau mereka.

Seseorang akan menentukan kebenaran (ini ATAU itu). Jika ini benar atau itu benar, maka jawabannya benar.

Oh, dan orang-orang sialan menjawab pertanyaan-pertanyaan ini dengan cepat.