なぜ私たちは通常使うのですか|| 以上|？違いはなんですか？

どちらもうまく機能しているのに、通常||はビット単位のOR |ではなく、2つのブール値の間に論理OR を使用するのかと思っているところです。

つまり、以下を見てください。

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

|代わりに使用できます||か？&およびと同じです&&。

あなたが使用している場合||と&&ではなく、フォーム、|および&これらの演算子の形式を、Javaは右のオペランドのみを評価するために気にしないだろう。

ほとんどの場合、評価を短絡するかどうかは問題です。

短絡の利点を説明する良い方法は、次の例を検討することです。

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

ジェレミーとピーターが述べたように、短絡のもう1つの利点はnull参照チェックです。

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

より詳しい情報

| ブール式では短絡評価を行いません。||最初のオペランドが真であるかどうかの評価を停止しますが、真で|はありません。

さらに、|byte / short / int / long値に対してビットごとのOR演算を実行するために使用できます。||できません。

したがって、例を使用して他の回答を構築するために、以下の防御チェックでは短絡が重要です。

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

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

|およびを使用すると、ここでスローされる&可能性がありNullPointerExceptionます。

論理的で||、&&必要な場合のみ右側をチェックします。|そして&両側の毎回の両方を確認してください。

例えば：

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

それを書き直してください：

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

もう一つの例：

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

それを書き直してください：

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
...

また、一般的な落とし穴に注意してください。非遅延演算子は遅延演算子よりも優先されるため、次のようになります。

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

それらを混合するときは注意してください。

短絡に加えて、覚えておかなければならないもう1つのことは、0または1以外の値にビット単位の論理演算を実行すると、条件付き論理とは非常に異なる意味を持つことです。これは通常のために同じですが|と||して、&そして&&あなたは、例えば（非常に異なる結果を得る2 & 40 /偽中です2 && 4 1 /真です）。

関数から取得するものが実際にエラーコードであり、非0かどうかをテストしている場合、これは非常に重要になります。

これは、ブール値に明示的に型キャストしたり、0などと比較したりする必要があるJavaの問題ほど多くはありませんが、同様の構文を持つ他の言語（C / C ++など）では、かなり混乱する可能性があります。

また、＆と| 整数型の値にのみ適用でき、ブールテストに相当するすべてのものには適用できません。繰り返しになりますが、Java以外の言語では、暗黙の!= 0比較でブール値として使用できるものはかなり多く（ポインター、浮動小数点数、のあるオブジェクトoperator bool()など）、ビットコンテキスト演算子はこれらのコンテキストではほとんど無意味です。

非常に単純なブール式があり、ショートカット（つまり、分岐）のコストが後の式を評価しないことによって節約する時間よりも大きい場合にのみ、|または&その代わりに、||または使用する唯一の時間です&&。

ただし、これはマイクロ最適化であり、最下位レベルのコード以外ではほとんど問題になりません。

|| は論理OR演算子です。ビットごとのor演算子です。

boolean a = true;
boolean b = false;

if (a || b) {
}

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

a | b：いずれかで bを評価する場合

|| b：a がfalseと評価された場合にのみ bを評価します

という事実に加えて| ||ビット演算子です：|| 短絡演算子です-1つの要素がfalseの場合、他の要素はチェックされません。

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

||何かが真なら|| 何かを評価しませんが、| しましょう。||を使用して、ifステートメントの変数が実際に関数呼び出しである場合 パフォーマンスを大幅に節約できる可能性があります。

| is the binary or operator

|| is the logic or operator

演算子||と&&は条件付き演算子と呼ばれ、|と&はビット演算子と呼ばれますます。彼らは異なる目的を果たします。

条件演算子はboolean、左側と右側の両方で静的に評価される式でのみ機能します。

ビット演算演算子は、任意の数値オペランドで機能します。

論理比較を実行する場合は、条件付き演算子を使用する必要があります。これは、コードに何らかのタイプセーフを追加するためです。

補足：Javaには| =がありますが、|| =はありません

||を使用しなければならない場合の例|| 最初の式が2番目の式が爆発するかどうかを確認するテストである場合です。例：単一の| 次の場合、NPEが発生する可能性があります。

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

他の答えは演算子間の機能的な違いをカバーするのに良い仕事をしましたが、答えは今日存在するほぼすべてのC派生言語に適用できます。質問はタグ付けされていますjava、そして私はJava言語について具体的かつ技術的に答えるように努めます。

&そして、|整数ビット演算子、またはブール論理演算子のいずれかになります。ビット演算子と論理演算子（§15.22）の構文は次のとおりです。

AndExpression:
  EqualityExpression 
  AndExpression & EqualityExpression

ExclusiveOrExpression:
  AndExpression 
  ExclusiveOrExpression ^ AndExpression

InclusiveOrExpression:
  ExclusiveOrExpression 
  InclusiveOrExpression | ExclusiveOrExpression

構文EqualityExpressionで定義されている§15.21必要、RelationalExpressionで定義された§15.20順番に必要、ShiftExpressionとReferenceTypeで定義された§15.19と§4.3それぞれ。§15.18で定義されているShiftExpression必要があります。これは、ドリルダウンを続け、基本的な算術、単項演算子などを定義します。型を表すさまざまな方法すべてにドリルダウンします。（ながらプリミティブ型を含まない、それらが配列のディメンションタイプであってもよいように、プリミティブ型の定義は、最終的に、必要とされるです。）AdditiveExpressionReferenceTypeReferenceTypeReferenceType

ビット演算子と論理演算子には次のプロパティがあります。

• これらの演算子の優先順位は異なり、優先順位&が最も高く、優先順位|が最も低くなります。
• これらの各演算子は構文的には左結合です（各グループは左から右へ）。
• オペランド式に副作用がない場合、各演算子は可換です。
• 各演算子は結合的です。
• ビット演算子と論理演算子を使用して、数値型の2つのオペランドまたは型の2つのオペランドを比較できますboolean。他のすべての場合は、コンパイル時エラーになります。

演算子がビット演算子として機能するか論理演算子として機能するかは、オペランドが「プリミティブ整数型に変換可能」であるか（§4.2）、または型であるbooleanかBoolean（§5.1.8）によって異なります。

オペランドが整数型の場合、2つの数値の昇格（§5.6.2）が両方のオペランドに対して実行され、両方とも演算longのsまたはints として残されます。演算のタイプは、（昇格された）オペランドのタイプになります。その時点で、&ビットごとのAND、^ビットごとの排他的OR、|ビットごとの包含ORになります。（§15.22.1）

オペランドがある場合booleanやBoolean、（必要であれば、オペランドはアンボクシング変換の対象となる5.1.8）、及び操作の種類になりますboolean。&なりtrue、両方のオペランドがある場合はtrue、^になりますtrue両方のオペランドが異なる場合、および|になりtrueどちらかのオペランドがある場合true。（§15.22.2）

対照的に、 &&は「条件付きAND演算子」（§15.23）および||「条件付きOR演算子」（§15.24）です。それらの構文は次のように定義されています。

ConditionalAndExpression:
  InclusiveOrExpression 
  ConditionalAndExpression && InclusiveOrExpression

ConditionalOrExpression:
  ConditionalAndExpression 
  ConditionalOrExpression || ConditionalAndExpression

&&は&、左のオペランドがの場合にのみ右のオペランドを評価することを除いて、に似ていtrueます。||は|、左のオペランドがの場合にのみ右のオペランドを評価することを除いて、に似ていfalseます。

条件付きおよび以下のプロパティがあります。

• 条件付きAND演算子は構文的には左結合です（左から右にグループ化されます）。
• 条件演算子ANDは、副作用と結果値の両方に関して完全に関連付けられています。すなわち、任意の式のためにa、bおよびc、式の評価は、((a) && (b)) && (c)同じ副作用が発現の評価として、同じ順序で発生して、同じ結果を生成します(a) && ((b) && (c))。
• 条件付きAND演算子の各オペランドはbooleanor 型である必要があります。そうしないとBoolean、コンパイル時エラーが発生します。
• 条件式のタイプは常に booleanです。
• 実行時には、左側のオペランド式が最初に評価されます。結果がtypeの場合、Booleanボックス化解除の対象になります（§5.1.8ます）。
• 結果の値がの場合、false条件付きAND式の値はfalse AND式あり、右側のオペランド式は評価されません。
• 左側のオペランドの値がの場合、true右側の式が評価されます。結果がtypeの場合、Booleanボックス化解除の対象になります（§5.1.8ます）。結果の値は、条件式と式の値になります。
• したがって、オペランド&&と同じ結果を計算&しbooleanます。これは、右側のオペランド式が常にではなく条件付きで評価されるという点でのみ異なります。

Conditional-Orには次のプロパティがあります。

• 条件付きOR演算子は構文的に左結合です（左から右にグループ化されます）。
• 条件付きOR演算子は、副作用と結果値の両方に関して完全に関連付けられています。すなわち、任意の式のためにa、bおよびc、式の評価は、((a) || (b)) || (c)同じ副作用が発現の評価として、同じ順序で発生して、同じ結果を生成します(a) || ((b) || (c))。
• 条件付きOR演算子の各オペランドは、タイプbooleanor Booleanでなければなりません。そうでないと、コンパイル時エラーが発生します。
• 条件式または式のタイプは常に booleanです。
• 実行時には、左側のオペランド式が最初に評価されます。結果がtypeの場合、Booleanボックス化解除の対象になります（§5.1.8）。
• 結果の値がの場合、true条件付きtrueOR式の値はであり、右側のオペランド式は評価されません。
• 左側のオペランドの値がの場合、false右側の式が評価されます。結果がtypeの場合、Booleanボックス化解除の対象になります（§5.1.8ます）。結果の値は、条件式または式の値になります。
• したがって、on またはoperands ||と同じ結果を計算します。これは、右側のオペランド式が常にではなく条件付きで評価されるという点でのみ異なります。|booleanBoolean

要するに、として@JohnMeagher繰り返しコメント欄で指摘している&と|され、実際には、あるいずれかのオペランドの特定の場合にブール演算子を非短絡booleanまたはBoolean。良い慣行（つまり、二次的影響がない）では、これは小さな違いです。ただし、オペランドがbooleansではない場合、Boolean演算子の動作は大きく異なります。ビット単位の論理演算と論理演算は、Javaプログラミングの高レベルではうまく比較できません。

1）。（expression1 | expression2）、| 演算子は、expression1の結果がtrueまたはfalseであるかどうかに関係なく、expression2を評価します。

例：

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）、|| expression1がtrueの場合、演算子はexpression2を評価しません。

例：

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;
    }
}

|| 2つの値のOR演算によってブール値を返します（そのため、LOGICALまたはとして知られています）

IE：

if (A || B) 

AまたはBのいずれかがtrueの場合はtrue、両方がfalseの場合はfalseを返します。

| 2つの値に対してビットごとの演算を実行する演算子です。ビット演算をよりよく理解するには、ここを読むことができます：

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

主な違いの1つは、|| &&は「短絡」を示すため、RHSは必要な場合にのみ評価されます。

例えば

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

上記の場合、aがtrueの場合、bはテストされず、path1が実行されます。| が使用された場合、「a」が真であっても両側が評価されます。

こちらとこちらをご覧くださいご覧ください。

お役に立てれば。

非短絡は有用かもしれません。2つの式が評価されることを確認したい場合があります。たとえば、2つの個別のリストからオブジェクトを削除するメソッドがあるとします。あなたはこのようなことをしたいかもしれません：

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));
    }
}

メソッドが代わりに条件付きオペランドを使用した場合、最初のリストがfalseを返した場合、2番目のリストからオブジェクトを削除できませんでした。

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

それは驚くほど有用ではありません、そして（ほとんどのプログラミングタスクと同様に）他の手段でそれを達成することができます。ただし、ビット単位のオペランドの使用例です。

それらの基本的な違いは、最初に値をバイナリに変換してから、ビット単位のOR演算を実行します。その間、|| データをバイナリに変換せず、元の状態に対してor式を実行するだけです。

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

続きを読む：http : //javarevisited.blogspot.com/2015/01/difference-between-bitwsie-and-logical.html#ixzz45PCxdQhk

この質問があったとき、私はこれについてのアイデアを得るためにテストコードを作成しました。

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");
     }

 }
}

この場合、aまたはbを追加したif条件の左側の値のみを変更します。

|| シナリオ、左側がtrueの場合[if（a || bool（））]

出力 "If condition executed"

|| シナリオ、左側がfalseの場合[if（b || bool（））]

出力-

Bool
If condition executed

Conclusion of || を使用する場合||、右側は左側がfalseの場合のみチェックします。

| シナリオ、左側がtrueの場合[if（a | bool（））]

出力-

Bool
If condition executed

| シナリオ、左側がfalseの場合[if（b | bool（））]

出力-

Bool
If condition executed

Conclusion of | 使用時は|、左右を確認してください。

| =ビットごと、または|| =ロジックまたは

通常、前置インクリメント演算子と後置インクリメント演算子がある場合に使用します。次のコードを見てください。

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);
    }
    }
}

出力：

iの場合は最初に印刷されます：11 xの

場合は2番目に印刷されます
：10

両方のifブロックは同じですが、結果は異なります。がある場合|、両方の条件が評価されます。しかし、それがの場合||、最初の条件はすでに真であるため、2番目の条件は評価されません。

多くのユースケースがあり、なぜでは||なくなぜ行くべきかを示唆しています|。一部のユースケースでは、|すべての条件をチェックするために演算子を使用する必要があります。

たとえば、フォームの検証を確認し、最初の無効なフィールドだけでなく、すべての無効なフィールドにエラーテキストを表示したい場合などです。

|| オペレーターは、

   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;
   }

したがって、上記のスニペットでは、ユーザーがすべての空のフィールドを含むフォームを送信するnameFieldと、エラーメッセージのみが表示されます。しかし、これを次のように変更すると、

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

true条件に関係なく、各フィールドに適切なエラーメッセージが表示されます。

|論理演算子としての使用がJavaパターンのプラクティスに準拠しているかどうかは、このトピックを注意深く読んだ後でもわかりません。

私は最近、コメントを処理するプルリクエストのコードを変更しました

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

に変更する必要がありました

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

実際に承認されたバージョンは何ですか？

Javaのドキュメントでは、論理的な非短絡OR演算子として言及されていません|。

投票に興味はありませんが、標準を見つけることにもっと興味がありますか？！どちらのコードバージョンもコンパイルされ、期待どおりに動作しています。

|| は論理ORまたは| ビットごとのORです。

Javaオペレーター

| ||ビットごと、または|| 論理的です。

を見てみましょう：

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

| ビット単位の包含ORです

|| 論理OR

| ビットごとの演算子です。|| 論理演算子です。

1つは2ビットまたはそれらを使用します。

真実（これまたはそれ）を決定します。これが真またはそれが真であれば、答えは真です。

ああ、そしておとなしい人々はこれらの質問に素早く答えます