equals java（java里 equals和== 区别）

本文目录

• java里 equals和== 区别
• java中的equals怎么用
• Java中==和equal有什么区别
• java，equals是等于，那不等于怎么表达
• JAVA中的equal方法的格式和用法
• java对象为空的判断
• java中equals使用方法
• java 程序 关于equals的用法

java里 equals和== 区别

==是一个比较运算符，基本数据类型比较的是值，引用数据类型比较的是地址值。

（比较地址值即是指是否为同一个对象的引用）

equals()是一个方法，只能比较引用数据类型。重写前比较的是地址值，重写后比一般是比较对象的属性。

扩展资料：

java中的数据类型，可分为两类：

1.基本数据类型，也称原始数据类型。

byte,short,char,int,long,float,double,boolean，他们之间的比较，应用双等号（==）,比较的是他们的值。

2.复合数据类型。

当他们用（==）进行比较的时候，比较的是他们在内存中的存放地址，所以，除非是同一个new出来的对象，他们的比较后的结果为true，否则比较后结果为false。

JAVA当中所有的类都是继承于Object这个基类的，在Object中的基类中定义了一个equals的方法，这个方法的初始行为是比较对象的内存地址。

但在一些类库当中这个方法被覆盖掉了，如String,Integer,Date在这些类当中equals有其自身的实现，而不再是比较类在堆内存中的存放地址了。

对于复合数据类型之间进行equals比较，在没有覆写equals方法的情况下，他们之间的比较还是基于他们在内存中的存放位置的地址值的，因为Object的equals方法也是用双等号（==）进行比较的，所以比较后的结果跟双等号（==）的结果相同。

java中的equals怎么用

equals 方法是String类从它的超类Object中继承的, 被用来检测两个对象是否相等，即两个对象的内容是否相等，区分大小写。

例子:

Java中==和equal有什么区别

Java中==和equal的区别为:

1、== 表示 判断2个变量或对象实例是否指向同一个内存空间，equals()表示 判断2个变量或对象实例所指向的内存空间的值是否相同。

2、== 表示 对内存地址进行比较，equals()表示 对字符串的内容进行比较。

3、== 表示引用是否相同，equals() 表示值是否相同。

扩展资料:

Java compareTo() 方法用于两种方式的比较：

(1) 字符串与对象进行比较。

(2) 按字典顺序比较两个字符串。

代码示例:

public class Test {

public static void main(String args) {

String str1 = “Strings“;

String str2 = “Strings“;

String str3 = “Strings123“;

int result = str1.compareTo( str2 );

System.out.println(result);

result = str2.compareTo( str3 );

System.out.println(result);

result = str3.compareTo( str1 );

System.out.println(result);

} }

以上程序执行结果为：0, -3, 3

参考资料来源: Java官方文档-Class Object-equals()

java，equals是等于，那不等于怎么表达

java中equals()返回boolean值，true表示相等，false表示不相等。不等于就是对上面的结果取反，！a.equals(b)。

Java中equals的区别。

1. 可用于基本类型和引用类型：当用于基本类型时候，是比较值是否相同；当用于引用类型的时候，是比较对象是否相同。

2. 对于String a = “a”; Integer b = 1;这种类型的特有对象创建方式，==的时候值是相同的

3. 基本类型没有equals方法，equals只比较值（对象中的内容）是否相同（相同返回true）。

4. 一个类如果没有定义equals方法，它将默认继承Object中的equals方法，返回值与==方法相同。

JAVA中的equal方法的格式和用法

java中的是equals，没有equal，equals比较的是内容,只要值相同就是true。
如：
String str = new String(“aaa“);
String str1 = new String(“aaa“);
boolean bl = str.equals(str1);
结果就是：true。
备注：但是如果比较的是str==str1，这个结果就是false（地址引用不同）。

java对象为空的判断

/** 
     * 判断对象或对象数组中每一个对象是否为空: 对象为null，字符序列长度为0，集合类、Map为empty 
     *  
     * @param obj 
     * @return 
     */  
    public static boolean isNullOrEmpty(Object obj) {  
        if (obj == null)  
            return true;  
  
        if (obj instanceof CharSequence)  
            return ((CharSequence) obj).length() == 0;  
  
        if (obj instanceof Collection)  
            return ((Collection) obj).isEmpty();  
  
        if (obj instanceof Map)  
            return ((Map) obj).isEmpty();  
  
        if (obj instanceof Object) {  
            Object object = (Object) obj;  
            if (object.length == 0) {  
                return true;  
            }  
            boolean empty = true;  
            for (int i = 0; i 《 object.length; i++) {  
                if (!isNullOrEmpty(object[i])) {  
                    empty = false;  
                    break;  
                }  
            }  
            return empty;  
        }  
        return false;  
    }  
应用场景：
读取excel文件，转化为一个二维数组：Object arrays
但是excel中有空行，所以需要过滤Object arrays中的空的一维数组：
Java代码  
/*** 
     * 过滤数组中的空元素 
     *  
     *  
     * @param arrays 
     * @return 
     */  
    public static Object filterEmpty(Object arrays) {  
        int sumNotNull = 0;  
        /*** 
         * 统计非空元素的总个数 
         */  
        for (int i = 0; i 《 arrays.length; i++) {  
            Object object = arrays[i];  
            if (!ValueWidget.isNullOrEmpty(object)  
                    && !SystemUtil.isNullOrEmpty((Object) object)) {// 判断元素是否为空  
                sumNotNull = sumNotNull + 1;  
            }  
        }  
        Object filtedObjs = new Object[sumNotNull];  
        int index = 0;  
        for (int i = 0; i 《 arrays.length; i++) {  
            Object object_tmp = arrays[i];  
            if (!ValueWidget.isNullOrEmpty(object_tmp)  
                    && !SystemUtil.isNullOrEmpty((Object) object_tmp)) {// 判断元素是否为空  
                filtedObjs[index++] = object_tmp;  
            }  
        }  
        return filtedObjs;  
    }  
判断对象的所有成员变量是否为空
Java代码  
/*** 
     * Determine whether the object’s fields are empty 
     *  
     * @param obj 
     * @param isExcludeZero  :true:数值类型的值为0,则当做为空;----false:数值类型的值为0,则不为空 
     *  
     * @return 
     * @throws SecurityException 
     * @throws IllegalArgumentException 
     * @throws NoSuchFieldException 
     * @throws IllegalAccessException 
     */  
    public static boolean isNullObject(Object obj, boolean isExcludeZero)  
            throws SecurityException, IllegalArgumentException,  
            NoSuchFieldException, IllegalAccessException {  
        if(ValueWidget.isNullOrEmpty(obj)){//对象本身就为null  
            return true;  
        }  
        List《Field》 fieldList = ReflectHWUtils.getAllFieldList(obj.getClass());  
        boolean isNull = true;  
        for (int i = 0; i 《 fieldList.size(); i++) {  
            Field f = fieldList.get(i);  
            Object propertyValue = null;  
            try {  
                propertyValue = getObjectValue(obj, f);  
            } catch (NoSuchFieldException e) {  
                e.printStackTrace();  
            }  
  
            if (!ValueWidget.isNullOrEmpty(propertyValue)) {// 字段不为空  
                if (propertyValue instanceof Integer) {// 是数字  
                    if (!((Integer) propertyValue == 0 && isExcludeZero)) {  
                        isNull = false;  
                        break;  
                    }  
                } else if (propertyValue instanceof Double) {// 是数字  
                    if (!((Double) propertyValue == 0 && isExcludeZero)) {  
                        isNull = false;  
                        break;  
                    }  
                }else if (propertyValue instanceof Float) {// 是数字  
                    if (!((Float) propertyValue == 0 && isExcludeZero)) {  
                        isNull = false;  
                        break;  
                    }  
                }else if (propertyValue instanceof Short) {// 是数字  
                    if (!((Short) propertyValue == 0 && isExcludeZero)) {  
                        isNull = false;  
                        break;  
                    }  
                }else {  
                    isNull = false;  
                    break;  
                }  
            }  
        }  
        return isNull;  
    }  
 测试:
Java代码  
@Test  
    public void test_isNullObject() throws SecurityException,  
            IllegalArgumentException, NoSuchFieldException,  
            IllegalAccessException {  
        Person2 p = new Person2();  
        Assert.assertEquals(true, ReflectHWUtils.isNullObject(p, true));  
        Assert.assertEquals(false, ReflectHWUtils.isNullObject(p, false));  
  
        p.setAddress(“beijing“);  
        Assert.assertEquals(false, ReflectHWUtils.isNullObject(p, true));  
        Assert.assertEquals(false, ReflectHWUtils.isNullObject(p, false));  
  
        p.setAddress(null);  
        p.setId(0);  
        Assert.assertEquals(true, ReflectHWUtils.isNullObject(p, true));  
        Assert.assertEquals(false, ReflectHWUtils.isNullObject(p, false));  
  
    }  
 Person2 源代码(省略getter,setter方法):
Java代码  
import java.sql.Timestamp;  
  
public class Person2 {  
    private int id;  
    private int age;  
    private double weight;  
    private String personName;  
    private Timestamp birthdate;  
    public String identitify;  
    protected String address;  
    String phone;  
      
}

java中equals使用方法

java中equals使用方法：

1. equals 方法是String类从它的超类Object中继承的, 被用来检测两个对象是否相等，即两个对象的内容是否相等，区分大小写。

   对于字符串变量来说，使用“==”和“equals()”方法比较字符串时，其比较方法不同。“==”比较两个变量本身的值，即两个对象在内存中的首地址。“equals()”比较字符串中所包含的内容是否相同。 例如：

2. s1 = new String(“abc“);
   s2 = new String(“abc“);s1.equals(s2) 是 true

   3.对于非字符串变量来说，“==“和“equals“方法的作用是相同的都是用来比较其对象在堆内存的首地址，即用来比较两个引用变量是否指向同一个对象。

java 程序 关于equals的用法

String类对equals()方法进行了覆盖，只要引用指向的对象的内容是一样的就认为他们相等。你可以看一下String的equals()的源码：《pre t=“code“ l=“java“》 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;
}
而Object类默认的equals()方法就是比较两个引用指向的对象本身，如果指向同一个对象，那就认为他们是相等的，否则不相等，除非你像String类那样对其进行覆盖重写。