JAVA中数组问题

Question

我直接写内容；
int a[]= new int[4];
int b[]= new int[4];
a.equals(b);   false????   第一个不懂为什么是FALSE
int a[]= new int[]{1,2,3,4};
int b[]= new int[]{1,2,3,4};
a.equals(b);   false ????  还是不懂为什么是FALSE
帮帮的谢谢了

Answer 1

equal不是只在String中才用到的吗？

Answer 2

    equals 比较的值，a和b又不是一个值怎么比较啊？当然是false

Answer 3

new 出来的东西都是堆里 重新创建的，
你觉得会是一个东西吗？

Answer 4

  int a[]= new int[4]; 
  int b[]= new int[4];
  初始化一个int数组将引用赋予a,b
 a.equal(b)实际上比较的a,b数组的引用，也就是比较它们在堆内存的位置
   int a[]= new int[]{1,2,3,4}; 
   int b[]= new int[]{1,2,3,4}; 
道理也是一致的，只是初始化了数组里每个元素的值
  

Answer 5

Object中equals方法
public boolean equals(Object obj) {
return (this == obj);
}
因为a ！= b 所以false

Answer 6

a.equals(b);
 
没有重写过equals（）方法的时候，它的含义是比较两个变量是否指向同一个对象的。

Answer 7

equals除了比较值，还要比较hashCode.

Answer 8

equals只是比较字符串的值 吧

Answer 9

又不是同一对象。。当然是false

Answer 10

第一个False，比较的也不是原始类型啊，数组是引用类型吧，所以用==比较后是false吧。
第二个equals是对字符串的比较啊。

Answer 11

指向的内存对象都是不一样的，你new了，重新创建对象了，怎么可能一样！！

Answer 12

类创建的两个对象是不同的。建议楼主看一下equals（）和equalsIgnoreCase（）这两个方法的区别

Answer 13

在String类中重写了equals方法。而其他类并未对equals方法做任何处理。

Answer 14

int a[] = new int[4];
int b[] = new int[4];
// a.equals(b); false???? 第一个不懂为什么是FALSE
int a1[] = new int[] { 1, 2, 3, 4 };
int b1[] = new int[] { 1, 2, 3, 4 };
// 因为它们都是不同的对象，如果需要进行数组的比较需要用到Arrays.equals()方法
System.out.println(Arrays.equals(a, b));
System.out.println(Arrays.equals(a1, b1));

Answer 15

int a[]= new int[4]; 
int b[]= new int[4]; 
a.equals(b);  false????  第一个不懂为什么是FALSE //equals不适用于基本类型，即int,float之类的，你可以用Integer，String等创建对象。
int a[]= new int[]{1,2,3,4}; 
int b[]= new int[]{1,2,3,4}; 
a.equals(b);  false ????  还是不懂为什么是FALSE //同上

Answer 16

很好，我再加一点
首先看hashcode是否相等，如果不相等就是false,否则再看是否是同一个内存对象（这里是没有重写的情况）

Answer 17

源代码中Object的equals方法并没有比较hashcode啊？
为什么楼上这么多人说有呢？
    /**
     * Indicates whether some other object is "equal to" this one.
     * <p>
     * The <code>equals</code> method implements an equivalence relation
     * on non-null object references:
     * <ul>
     * <li>It is <i>reflexive</i>: for any non-null reference value
     *     <code>x</code>, <code>x.equals(x)</code> should return
     *     <code>true</code>.
     * <li>It is <i>symmetric</i>: for any non-null reference values
     *     <code>x</code> and <code>y</code>, <code>x.equals(y)</code>
     *     should return <code>true</code> if and only if
     *     <code>y.equals(x)</code> returns <code>true</code>.
     * <li>It is <i>transitive</i>: for any non-null reference values
     *     <code>x</code>, <code>y</code>, and <code>z</code>, if
     *     <code>x.equals(y)</code> returns <code>true</code> and
     *     <code>y.equals(z)</code> returns <code>true</code>, then
     *     <code>x.equals(z)</code> should return <code>true</code>.
     * <li>It is <i>consistent</i>: for any non-null reference values
     *     <code>x</code> and <code>y</code>, multiple invocations of
     *     <tt>x.equals(y)</tt> consistently return <code>true</code>
     *     or consistently return <code>false</code>, provided no
     *     information used in <code>equals</code> comparisons on the
     *     objects is modified.
     * <li>For any non-null reference value <code>x</code>,
     *     <code>x.equals(null)</code> should return <code>false</code>.
     * </ul>
     * <p>
     * The <tt>equals</tt> method for class <code>Object</code> implements 
     * the most discriminating possible equivalence relation on objects; 
     * that is, for any non-null reference values <code>x</code> and
     * <code>y</code>, this method returns <code>true</code> if and only
     * if <code>x</code> and <code>y</code> refer to the same object
     * (<code>x == y</code> has the value <code>true</code>).
     * <p>
     * Note that it is generally necessary to override the <tt>hashCode</tt>
     * method whenever this method is overridden, so as to maintain the
     * general contract for the <tt>hashCode</tt> method, which states
     * that equal objects must have equal hash codes. 
     *
     * @param   obj   the reference object with which to compare.
     * @return  <code>true</code> if this object is the same as the obj
     *          argument; <code>false</code> otherwise.
     * @see     #hashCode()
     * @see     java.util.Hashtable
     */
    public boolean equals(Object obj) {
 return (this == obj);
    }

Answer 18

数组是引用数据类型，而引用数据类型每new一次就说明是不同对象，而equals比较的是对象的地址，不同对象在堆内存地址不一样，所以结果为false...除非重写equals方法。

Answer 19

1、数组是一个Object对象，所以直接使用数组的equals()方法，普遍符合是使用Object类的equals()方法。
2、Object类的equals()方法，实质上还是使用==比较对象。
3、JDK中很多类重写了equals()方法，包括java.lang.String类和java.util.Arrays类。
4、所以，当你比较两个字符串的时候，它使用的是String类下的equals()方法，这个方法比较的是对象值。
5、同样的道理，如果需要比较两个数组的值，就需要使用Arrays类中的equals()方法。
6、代码示例：int[] a = new int[]{1,2,3};
int[] b = new int[]{1,2,3};
System.out.println(Arrays.equals(a , b));结果返回true。

Answer 20

equals在比较数量是比较内存里开辟的地址是不是一样。

Answer 21

你new的这两个数组是个什么对象就不清楚了，但肯定是没有覆盖Object的equals方法的，所以返回值是false,因为Object的equals方法始终返回false.可以看看Object的源代码。。

Answer 22

你调用的equals是基类Object中的，比较的是两个对象的引用，两个不同的对象引用当然不同
所以两个比较结果都是false
数组的equals不像字符串那样重写过基类的equals，你可以用Arrays.equals(a , b)比较数组的内容

Answer 23

总结大家的回帖：1.Object的equals比较的是对象在内存中的地址，效果同"=="
2.String和Arrays类的equals是重写（overridden）过的，比较的是内容，而不是地址

Answer 24

第一个错误在于 ：int a[]= new int[4];  是在内存中连续分配4个int（一个int在java占4个字节）的内存空间,a指该连续空间的首地址。 两个地址怎能相等。
第二个错误也一样。

Answer 25

所有Java的类的父类 Object类里就有equals 方法。string类只不过重写了父类里的equals方法。
就是STRING 类的equals方法比较的是内容，而其他的没有重写的就是比较的应用地址。你的a和b在内存中存放的地址不一样（不管值是否一样），当然就是FALSE了，

Answer 26

应为比较的是两个对象的分配空间 而不是不比较空间里的直
 两个对象的空间不同所以是FALSE
  如果比较的是里面的值就是true

Answer 27

数组的equals方法比较的是传进方法体里的对象而不是对象的内容a【4】和b【4】虽然初始化后内容一样都为零但他们的地址不一样，也就是他们不是同一个对象所以是false。至于第二个false，你自己赋值和数组初始化赋值效果一样所以原理如上。足以这类比用到了equals或是contains等方法一般不重写方法的话比较的都是对象而不是对象的内容！！！

Answer 28

19楼 和25楼说的对
这是Object下的equals：
boolean equals(Object obj) 
          指示其他某个对象是否与此对象“相等”。 
这是Arrays下的equals：
static boolean equals(boolean[] a, boolean[] a2) 
          如果两个指定的 boolean 型数组彼此相等，则返回 true。 
static boolean equals(byte[] a, byte[] a2) 
          如果两个指定的 byte 型数组彼此相等，则返回 true。 
static boolean equals(char[] a, char[] a2) 
          如果两个指定的 char 型数组彼此相等，则返回 true。 
static boolean equals(double[] a, double[] a2) 
          如果两个指定的 double 型数组彼此相等，则返回 true。 
static boolean equals(float[] a, float[] a2) 
          如果两个指定的 float 型数组彼此相等，则返回 true。 
static boolean equals(int[] a, int[] a2) 
          如果两个指定的 int 型数组彼此相等，则返回 true。 
static boolean equals(long[] a, long[] a2) 
          如果两个指定的 long 型数组彼此相等，则返回 true。 
static boolean equals(Object[] a, Object[] a2) 
          如果两个指定的 Objects 数组彼此相等，则返回 true。 
static boolean equals(short[] a, short[] a2) 
          如果两个指定的 short 型数组彼此相等，则返回 true。 
是不一样的。

Answer 29

数组中存放的是内存地址吧，因为 new了2次 所以内存地址不同

Answer 30

int a[] = new int[4];
        int b[] = new int[4];
        // a.equals(b); false???? 第一个不懂为什么是FALSE
        int a1[] = new int[] { 1, 2, 3, 4 };
        int b1[] = new int[] { 1, 2, 3, 4 };
        // 因为它们都是不同的对象，如果需要进行数组的比较需要用到Arrays.equals()方法
        System.out.println(Arrays.equals(a, b));
        System.out.println(Arrays.equals(a1, b1));
这个事正确的，因为你用了2个new创建了2个数组a和b，a.equals(b)是指这2个数组的内存地址相同，有点像c中指向同一地址的指针，Arrays.equals(a, b)是指你创建的数组a和b数值是否相等，返回的是Boolean型变量

Answer 31

equals比较的是内存地址， ==比较的是值

Answer 32

String的equals之所以比较的是内容而不是地址 是因为重写了这个方法
如果没有重写 依然比较的是地址

Answer 33

我的理解这个问题很简单的 就是比较hashcodepublic class Demo1 {
public static void main(String[] args) { int a[]= new int[]{1,2,3,4}; 
int b[]= new int[]{1,2,3,4}; 

System.out.println("a.hashCode()"+a.hashCode());

System.out.println("b.hashCode()"+b.hashCode());

}}
用这段代码自己测试一下就行了 
hashcode是不一样的！

Answer 34

数组的概念与equals没有什么关联
想比较 需要，根据自己的需要自己写就重写  equals   和  hashCode 方法

Answer 35

基础的东西，JAVA中数组不和字符串一样，它属于基础数据类型，根本就没有方法可以调用，要比较？用循环吧

Answer 36

我得到的value是 ‘Can not call any method on arrays.’

Answer 37

Arrays.equals(byte[]a,byteb);

Answer 38

Arrays.equals(byte[]a,byte[] b);

Answer 39

数组中有个属性，是length，用来求数组长度的，注意是没括号的，字符串的是length(),是方法，不要搞错了，数组不是对象，不可能有方法可以调用

Answer 40

class test{
public static void main(String[] args){
int a[]= new int[]{1,2,3,4}; 
int b[]= new int[]{1,2,3,4}; 

System.out.println(a.equals(b));
System.out.println(a.equals(b));

System.out.println(a);
System.out.println(b);
}
}
执行一下就知道了

Answer 41

equals方法原始就是比较引用是否一样，怎么有人扯到hashCode()了，hashCode是在进行HashMap，HashSet等操作时，需要取得对象的hash码时才用到的。
如果重写了equals方法，没有重写hashCode方法，就会出现两个相同的对象，却具有不同的hash码的矛盾，所以重写了equals方法，一般都要重写hashCode方法，但不是一定要重写的，如果这个对象根本用不到hash码，就没必要重写。
equals方法返回false，hashCode的值有可能一样，也有可能不一样，但equals方法如果返回true，hashCode方法一定也要返回相同的值

Answer 42

你好好看看api，你调用的equals方法是继承于object的，默认的是比较两个引用的内存地址，当然是false了，要是true就坏了，呵呵，你要是想比较值需要重构equals方法。

Answer 43

equals（）是比较的数组的引用，也就是第一个元素的首地址！所以，两个都是FALSE！

Answer 44

两个比较都是地址,当然是false了

Answer 45

重新想了下，你的类方法用的不对，我知道你是想用数组的比较，对吧！
在java中数组的比较是java.util.Arrays中的类方法，你应该吧你的代码改成如下的才对int a[]= new int[4];
int b[]= new int[4];
boolen frag=Arrays.equals(a,b);
int a[]= new int[]{1,2,3,4};
int b[]= new int[]{1,2,3,4};
boolen frag=Arrays.equals(a,b);这个才是比较数组的数值是否相等，你用的是比较内存地址是否相等

Answer 46

Object 类的 equals 方法实现对象上差别可能性最大的相等关系；即，对于任何非空引用值 x 和 y，当且仅当 x 和 y 引用同一个对象时，此方法才返回 true（x == y 具有值 true）。 注意：当此方法被重写时，通常有必要重写 hashCode 方法，以维护 hashCode 方法的常规协定，该协定声明相等对象必须具有相等的哈希码。
所有对象默认继承Object类，在没有重写equals方法时，执行的是Object对象的equals方法，String类重写了equals比较的是字符串内容。

Answer 47

String：equals比较的是值；
Other： equals比较的是内存地址。

Answer 48

因为a,b两数组动态创建，在存储中a,b位于两块不同的内存区域。故而 a!=b

Answer 49

a和b是两个对象实例，引用的东西不一样，所以用equal就会是false值

Answer 50

在编写程序时一定要注意数组地址和元素的区别，equals只能用于字符串，a和b都是首地址，在内存中的地址当然不一样。

Answer 51

今天刚好看了String中equals的方法的介绍，书上说是比较内容而非地址("=="才是比较地址）。
原来object的equals是等同于==的。学习了~

Answer 52

a和b只是数组的地址，而equals比较的是数值，你这样写，即表示你要比较a和b的地址值，那当然不同了