相关疑难解决方法(0)

==到目前为止,我一直在我的程序中使用运算符来比较我的所有字符串.但是,我遇到了一个错误,将其中一个更改为了.equals(),并修复了该错误.

是==坏？什么时候应该不应该使用它？有什么不同？

我希望在Java中找到给定元素的索引,知道它的内容.

我尝试了以下示例,该示例不起作用:

class masi { 
    public static void main( String[] args ) { 
        char[] list = {'m', 'e', 'y'};

        // should print 1
        System.out.println(list[] == "e");                    
    } 
}

任何人都可以解释这有什么问题以及我需要做些什么来解决它？

我有两个从同一个类实例化的java对象.

MyClass myClass1 = new MyClass();
MyClass myClass2 = new MyClass();

如果我将它们的两个属性设置为完全相同的值,然后验证它们是否相同

if(myClass1 == myClass2){
   // objects match
   ...

}

if(myClass1.equals(myClass2)){
   // objects match
   ...

}

但是,这些方法都没有返回真正的价值.我检查了每个属性并匹配.

如何比较这两个对象以验证它们是否相同？

可能重复:
在Java中覆盖equals和hashCode

如果我有

class A {
    int x = 1;
}
...
A a1 = new A();
A a2 = new A();
a1.equals(a2);

如果我比较两个A的实例而没有覆盖equals方法,我会得到预期的结果吗？

我在一本书中查了一下,这本书在解释方面通常比网站更全面.

以此为例:

if (nickname == "Bob")

仅当nickname引用相同的String对象时,该条件才为真.

这是我发现令人困惑的一句话,任何人都可以解释为什么会这样:

为了提高效率,Java只为每个字符串常量生成一个字符串对象.

该书指出,组装对象"鲍勃"的方式也会影响条件是否真实,这最让我困惑.

例如:

String nickname = "Bob";
...
if (nickname == "Bob") //TRUE

但是如果从.substring()方法创建"Bob" ,则条件将为FALSE.

String name = "Robert";
String nickname = name.substring(0,3);
...
if (nickname == "Rob")//FALSE

为什么会这样？

编辑:在本书的解释结束时,我发现了一句让我困惑的句子:

因为字符串对象总是由编译器构造,所以您永远不会对是否共享两个字符串对象感兴趣.

我们编写的所有内容都不是由编译器构建的吗？

我有一堂课:

public class School {

    private String name;
    private int id;
    private boolean isOpen;

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public boolean isOpen() {
        return isOpen;
    }
    public void setOpen(boolean isOpen) {
        this.isOpen = isOpen;
    }
}

然后我创建了两个School实例,并比较了两个实例的相等性:

public static void main(String[] args) {
        //school1
        School school1 = new School();
        school1.setId(1);
        school1.setName("schoolOne");

        //school2
        School …

这是我第一次在StackOverflow上发帖,如果我的帖子格式不标准,我很抱歉,如果我的问题很愚蠢,请原谅我.

我正在对hackerrank进行挑战,目前我的问题目标如下:

您有一个空序列,您将获得N个查询.每个查询都是以下三种类型之一:

1. 将元素x推入堆栈.
2. 删除堆栈顶部的元素.
3. 打印堆栈中的最大元素.

我已经解决了,但我在讨论中看到了另一种解决方案,并考虑修改它.替代解决方案是:

public class Solution {

public static void main(String[] args) {

    Scanner inp = new Scanner(System.in);
    int n = inp.nextInt();
    Stack<Integer> S = new Stack<>();
    Stack<Integer> largest_stack = new Stack<>();
    largest_stack.push(0);

    for(int i=1; i<=n;i++) {
        int query = inp.nextInt();

        if(query==1){
            int newtop=inp.nextInt();
            S.push(newtop);

            if(S.peek()>=largest_stack.peek()){
                largest_stack.push(S.peek());     
            }
       }

        if(query==2) {
            if(S.peek()==largest_stack.peek()){
                largest_stack.pop();   
            }
            S.pop();   
        }
        if(query==3){
            System.out.println(largest_stack.peek());
        }
    }
}
}

我想在这部分用newtop替换S.peek()

            if(S.peek()>=largest_stack.peek()){
                largest_stack.push(S.peek());     
            }

所以我明白了

            if(S.peek()>=largest_stack.peek()){
                largest_stack.push(newtop);     
            }

执行此操作后,它将通过默认测试用例.但它总共失败了9/27个测试用例.以下是其中一个失败的测试用例的一小部分.有100000个查询,但我只采取了前21个.

21
1 809288903
3
1 …

我目前正在学习Java.看下面的代码:

package classtest1;

class ClassSuper
{
    public Object myObject = new Object();

    public ClassSuper(){}
}

public class ClassTest1 extends ClassSuper
{
    public ClassTest1()
    {
        System.out.println("this.myObject.equals(super.myObject) return: " + this.myObject.equals(super.myObject));
        System.out.println("this.myObject == (super.myObject) return: " + this.myObject == (super.myObject));
    }

    public static void main(String[] args)
    {
        ClassTest1 myClassTest1 = new ClassTest1();
    }

}

输出如下:

run:
this.myObject.equals(super.myObject) return: true
false
BUILD SUCCESSFUL (total time: 0 seconds)

我的问题是,为什么等于和"=="不一样？使用"=="时为什么输出false.Subclass会在内存中创建一个新的副本myObject吗？

我写了一个测试代码来检查相等性.我检查过Java doc,它说BigInteger是不可变的.检查静态工厂方法的文档,valueOf它看起来像返回已经缓存的不可变实例.那么为什么==在缓存的实例时返回false.

以下是适用valueOf于的Java文档BigInteger:

返回一个Big Integer,其值等于指定long的值.这种"静态工厂方法"优先于(长)构造函数提供,因为它允许重用常用的BigIntegers.

下面的代码将进入无限循环.

public static void main(String[] args) {
    while(true) {
        BigInteger a = BigInteger.valueOf(100);
        BigInteger c = BigInteger.valueOf(100);
        if (a == c) {
            break;
        }
 }

public class Test {
    public static void main(String[] args) {
        Object o1 = new Object();
        Object o2 = new Object();
        System.out.print((o1 == o2) + " " + (o1.equals(o2)));
    }
}

我以不同的答案阅读：

该==运营商测试两个变量是否具有相同的引用（又名指向一个内存地址）。

而该equals()方法测试两个变量是否引用具有相同状态（值）的对象。

在这里，由于 o1和o2引用了两个不同的对象，我得到了为什么 ==返回false。

但是，这两个对象都是使用Object该类的默认构造函数创建的，因此具有相同的值。为什么该equals()方法返回false？

我正在使用==运算符比较2个Java对象,有人可以解释为什么打印"b"而不是"a"？

public class punktAusfuehren {

Punkt p1 = new Punkt(19, 10);
Punkt p2 = new Punkt(5, 0);

public static void main(String[] args) {
    new punktAusfuehren();
}

public punktAusfuehren() {
    if (p1 == p2) {
        System.out.println("a");
    } else {
        System.out.println("b");
    }

    if (p1 instanceof Punkt) {
        System.out.println("c");
    } else {
        System.out.println("d");
        }

   }

 }

这是我的代码:

Object a = "1234";
Object b = new Integer("1234");

我知道这==意味着参考和equals()手段包含.

现在为什么a.equals(b)是假的？

它们中的每一个都具有相同的值.

targetPixValList是一个包含Double对象的列表,它在列表中的连续位置也包含类似的值,当我尝试使用Code_1比较两个Double值时,cnt返回零.当我使用code_2时,cnt返回值.

并且列表的类型是

为什么"=="运算符不适用于Double？

Code_1:

int cnt = 0;
    for (int i = 0; i < cs.targetPixValList.size()-1; i++) {
        if (cs.targetPixValList.get(i) == cs.targetPixValList.get(i+1))
            ++cnt;
    }

CODE_2:

 int cnt = 0;
    for (int i = 0; i < cs.targetPixValList.size()-1; i++) {
        if (cs.targetPixValList.get(i).equals(cs.targetPixValList.get(i+1)))
            ++cnt;
    }