java中的判断语法与逻辑运算符汇总

public boolean equals(Object obj) {
        if (obj instanceof Boolean) {
            return value == ((Boolean)obj).booleanValue();
        }
        return false;
    }

简单的草稿，仅供自己简单记录，切勿盲目参考！

java中的判断语法

if else：最常见的判断语法，示例如下：

int a = 1;
        //if是当判断为真，只执行一次
        if (a==1){
            System.out.println("吃包子");
        }else if (a==2){
            System.out.println("吃馒头");
        }else {
            System.out.println("随便吃");
        }

上面的判断语法中，如果判断依据为ture，那么就执行一次大括号里面的代码，那如果想要在满足条件时执行多次呢，那么就要用while循环了：

while (a==14){
            System.out.print("吃火锅");
        }

这样只要满足条件，执行完这一次还会进行一次又一次的循环，每循环一次就判断一次，可以将while看成是if和for的结合体。

如果想要先执行循环，再进行判断，那么就要使用do{}while();了：

do {
    a = 1;
    System.out.println("吃水饺");
}while (a==1);

总结：

运算符

运算符的优先级由高到低排序：（）、！、算术运算符、关系运算符、逻辑运算符、赋值运算符 

!= 和 !==的区别

两个都是用来比较的，在比较过程中会有差别。

!= 在比较时，若类型不同，会尝试转换类型之后再比较。

!== 在在进行比较之前会进行判断，如果不是相同类型，则不会比较。因此，只有相同类型才会比较。

同样道理：

==代表相同， ===代表严格相同。

== 在进行比较的时候，若类型不同，会尝试转换类型之后再比较。

===在进行比较的时候，若类型不同，就直接不相等了。

判断一个值是否是NaN,只能通过isNaN()来进行判断

这里记录一个常用的表达式，这个表达式适用于java、JavaScript等等（可以自己探索一下）：

A ？B : C

A为布尔表达式（真/假）,B 和C为执行语句，如果A为真执行B，否则执行C

Java中的使用

return data != null ? data.eatApple() : null;
//data不为空，返回data.eatApple()，如果data为空，则返回null。

上面的语句相当于：

if(data != null){
    return data.eatApple();
}else{
    return null;
}

在HTML中的使用：

<el-table-column>
    <template slot-scope="scope">                 
        {{foodMap[scope.row.foodid] != null ? repairStatusMap[scope.row.foodid] : "异常"}}
    </template>
</el-table-column>

3*0.1 == 0.3 将会返回什么？true 还是 false？

false，因为有些浮点数不能完全精确的表示出来。

==：

== 是比较运算符，如果进行比较的都是基本数据类型（byte、short、int、long、float、double、boolean、char），即使他们的数据类型不相同,只要他们的值相等,也都将返回true；如果比较的都是引用数据类型（Byte、Short、Integer、Long、Float、Double、Boolean、Character、String、Object等等），那么只有当两个引用变量的类型具有父子关系时才可以比较，这里本质上比较的是存储对象的地址，即这两个引用必须指向同一个对象，才会返回true.(在这里我们可以理解成==比较的是两个变量的内存地址)，这里注意Integer是有范围限制的，-128~127之间如果新建多个对象拥有相同的值，不会新建内存，在这之外的范围才会重新开辟内存，当然如果使用new的话是肯定开辟新内存的。一句话总结，== 是java提供的等于比较运算符，用来比较两个变量对象指向的内存地址是否相同。

equals：

“a==b”和”a.equals(b)”有什么区别？

如果 a 和 b 都是对象，则 a==b 是比较两个对象的引用，只有当 a 和 b 指向的是堆中的同一个对象才会返回 true，而 a.equals(b) 是进行逻辑比较，所以通常需要重写该方法来提供逻辑一致性的比较。例如，String 类重写 equals() 方法，所以可以用于两个不同对象，但是包含的字母相同的比较。

equals()方法是Object类的方法,在Object类中的equals()方法体内实际上返回的就是使用==进行比较的结果.但是我们知道所有的类都继承Object,而且Object中的equals()方法没有使用final关键字修饰,那么当我们使用equal()方法进行比较的时候,我们需要关注的就是这个类有没有重写Object中的equals()方法，但是equals()可以被重写,所以我们在具体使用的时候需要关注equals()方法有没有被重写。

例题1：

public static void main(String[] args) {
        //-128 ~ +127 之间
        Integer a = 5;
        Integer b = 5;
        System.out.println(a == b);

        //-128 ~ +127 之外
        a = 128;
        d = 128;
        System.out.println(a == b);
    }

结果：true、false

原因分析：给Integer类型赋值的时候,如果没有调用new关键字,并且值在-128与+127之间,包括-128和+127,那么指向的都是同一个内存位置。只有在-128~127之外的数才新建地址去储存这些对象。

例题2：

public class ObjectDemo{
    public static void main(String[] args) {
        String s1 = "Hello";
        String s2 = new String("Hello");
        s2 = s2.intern();
        System.out.println(s1 == s2);       //  true
        System.out.println(s1.equals(s2));  //  true
    }
}

分析：上述代码的第5行中，java.lang.String的intern()方法"abc".intern()方法的返回值还是字符串"abc"，表面上看起来好像这个方法没什么用处。但实际上，它做了个小动作：检查字符串池里是否存在"abc"这么一个字符串，如果存在，就返回池里的字符串；如果不存在，该方法会 把"abc"添加到字符串池中，然后再返回它的引用。

例题3（拓展）：

关于int类型以及equals比较的问题

先来看下面的一段程序：

Object value1=0;
Integer value2=0;
Long value3=new Long(0);
System.out.println(value1.equals(value2));
System.out.println(value1.equals(value3));

输出：

true
false

 为什么是这样的输出，这里面有两点内容：

1、Object value1=0;这样写的话，默认value1的类型就是Integer类型的，各位可以这样输出一下：

System.out.println(value1.getClass());

 输出会是：

class java.lang.Integer

 2、我们都知道equals比较的是两个对象的内容是否相同，但是要明确一点，这两个对象的类型是要相同的。

根据上面两点的分析，就不难得出上面的输出结果了。

Object value1=0;

 如果没做特殊的说明，会默认value1是Integer类型的，也就是说value1的取值不能超过Integer的最大值，在MyEclipse中直接书写，超过Integer的最大取值编译是通不过的，会报out of range错误：

但是我这样书写：

Object value1=Integer.MAX_VALUE+200;

有输出： -2147483449

Integer类中重写了equals()方法,使用equals()方法进行比较的时候,实际上比较的内存中最终指向的值的内存位置,不是直接比较变量的内存位置，重写的equals()方法

 public boolean equals(Object obj) {
        if (obj instanceof Integer) {
            return value == ((Integer)obj).intValue();
        }
        return false;
    }

String.java中的equals方法：

public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;
        }
        if (anObject instanceof String) {
            String anotherString = (String)anObject;
            int n = value.length;
            if (n == anotherString.value.length) {
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }

Byte.java中的equals方法：

public boolean equals(Object obj) {
        if (obj instanceof Byte) {
            return value == ((Byte)obj).byteValue();
        }
        return false;
    }

Short.java中的equals方法：

public boolean equals(Object obj) {
        if (obj instanceof Short) {
            return value == ((Short)obj).shortValue();
        }
        return false;
    }

Integer.java中的equals方法： 

public boolean equals(Object obj) {
        if (obj instanceof Integer) {
            return value == ((Integer)obj).intValue();
        }
        return false;
    }

Long.java中的equals方法：  

public boolean equals(Object obj) {
        if (obj instanceof Long) {
            return value == ((Long)obj).longValue();
        }
        return false;
    }

Float.java中的equals方法：  

public boolean equals(Object obj) {
        return (obj instanceof Float)
               && (floatToIntBits(((Float)obj).value) == floatToIntBits(value));
    }

Double.java中的equals方法： 

public boolean equals(Object obj) {
        return (obj instanceof Double)
               && (doubleToLongBits(((Double)obj).value) ==
                      doubleToLongBits(value));
    }

Boolean.java中的equals方法： 

public boolean equals(Object obj) {
        if (obj instanceof Boolean) {
            return value == ((Boolean)obj).booleanValue();
        }
        return false;
    }

Character.java中的equals方法：  

public boolean equals(Object obj) {
        if (obj instanceof Character) {
            return value == ((Character)obj).charValue();
        }
        return false;
    }

由上边的源码就可以看出，equals方法不能作用于基本数据类型的变量，equals方法作用的是对象，也就是只能比较对象，所以语法上就直接报错：

public static void main(String[] args) {
        int a = 2;
        int b = 2;
        System.out.println(a.equals(b));  //语法直接会报错
    }
}

报错：

&和&&的区别

逻辑与运算符	&&	当运算符左右两边的表达式都为 true，才返回 true。同时具有短路性，如果第一个表达式为 false，则直接返回 false。所在通常使用逻辑与运算符都会使用 &&
	&	逻辑与运算符，不具有短路性
按位与运算符		用于二进制的计算，只有对应的两个二进位均为1时，结果位才为1 ，否则为0。（& 更多的适用于位运算）