main(){
Integer i1 = 500;
Integer i2 = 500;
System.out.println(i1 == i2); // O/P is "**false**"
String s1 = "Hello";
String s2 = "Hello";
System.out.println(s1 == s2); // O/P is "**true**"
} // End of main.
我无法弄清楚为什么输出不同.据我所知s1,s2将指向堆上的同一个对象.所以他们的参考地址是一样的.同样地,我认为整数也是一样的.但事实并非如此.它为什么不同？
class Demo{
public static void main(String[] args) {
Integer i = Integer.valueOf(127);
Integer j = Integer.valueOf(127);
System.out.println(i==j);
Integer k = Integer.valueOf(128);
Integer l = Integer.valueOf(128);
System.out.println(k==l);
}
}
第一个print语句打印为true,而第二个打印语句打印为false.为什么？请详细解释.
当数值比较运算符用于比较 Java 中的 2 个整数对象时，我试图了解以下代码的行为。
Integer i1 = new Integer(1);
Integer i2 = new Integer(1);
System.out.println(i1 == i2);
System.out.println(i1 > i2);
System.out.println(i1 >= i2);
上面代码的输出是：
false
false
true
我理解在第一种情况下发生的事情（对象实例的比较是这样的，这就是它给出错误的原因）。但是为什么第二个和第三个场景不同，它究竟是如何工作的呢？
该程序将使用for循环计算4个考试的平均成绩,方法是一次一个地提示用户输入考试成绩,然后计算平均值并显示结果.
public class ExamsFor4 {
public static void main(String[] arguments) {
int inputNumber; // One of the exams input by the user.
int sum = 0; // The sum of the exams.
int i; // Number of exams.
Double Avg; // The average of the exams.
TextIO.put("Please enter the first exam: "); // get the first exam.
inputNumber = TextIO.getlnInt();
for ( i = 1; i <= 4; i++ ) {
sum += inputNumber; // Add inputNumber to running sum. …我知道我正在比较参考,而我正在使用==这不是一个好主意,但我不明白为什么会发生这种情况.
Integer a=100;
Integer b=100;
Integer c=500;
Integer d=500;
System.out.println(a == b); //true
System.out.println(a.equals(b)); //true
System.out.println(c == d); //false
System.out.println(c.equals(d)); //true
如何从列表中获取特定元素？
Double[] weightArray = {240.0, 220d, 230.0, 240.0, 250.0,220.0, 215.0, 220.0,215d,223d};
Double[] pulseArray= {72.0,74.0,75.0,76.0,72.0,78.0,62.0,78.0,76.0,73.0,73.0,79.0};
Double[] sysArray={120.0,120.0,120.0,120.0,120.0,120.0,120.0,120.0,120.0,120.0};
Double[] diaArray={80.0,80.0,80.0,80.0,80.0,80.0,80.0,80.0,80.0,80.0};
List<double[]> values = new ArrayList<double[]>();
for(int i=0; i<weightArray.length; i++){
values.add(new double[] {weightArray[0], weightArray[1], weightArray[2], weightArray[3], weightArray[4], weightArray[5], weightArray[6], weightArray[7],weightArray[8], weightArray[9] });
values.add(new double[] {pulseArray[0],pulseArray[1],pulseArray[2],pulseArray[3],pulseArray[4],
pulseArray[5],pulseArray[6],pulseArray[7],pulseArray[8],pulseArray[9] });
values.add(new double[] {sysArray[0],sysArray[1],sysArray[2],sysArray[3],sysArray[4],
sysArray[5],sysArray[6],sysArray[7],sysArray[8],sysArray[9] });
values.add(new double[] {diaArray[0],diaArray[1],diaArray[2],diaArray[3],diaArray[4],
diaArray[5],diaArray[6],diaArray[7],diaArray[8],diaArray[9] });
}
// Does not work
//Object element =values.get(3,2);
//String s= element.toString();
//Toast.makeText(context, s.toString() , Toast.LENGTH_SHORT).show();
例如,我想得到值元素3,2,(diaArrray [1])
我有个问题.我不知道这有什么意义,但我真的需要一个答案
当我使用"=="作为
Integer i1 =10;
Integer i2 = 10;
if(i1 == i2) {System.out.println("same object")}
output =同一个对象
但是,如果我使用"=="
String obj1 = new String("xyz");
String obj2 = new String("xyz");
if(obj1 == obj2)
System.out.println("obj1==obj2 is TRUE");
else
System.out.println("obj1==obj2 is FALSE");
输出= FALSE
我知道"=="运算符会查找对象的内存位置.但是在第一个例子中发生了什么 i1和i2不是不同的对象？
为什么这个程序在第一个print语句中打印为false而在print语句中为true.i和i1是两个不同的对象,因此第一个语句必须打印"true",这是预期的,但第二个print语句打印"false",这会产生混淆.
public static void main(String[] args) {
Integer i = new Integer(10);
Integer i1 = new Integer(10);
System.out.println(i == i1); //printing false
i++;
i1++;
System.out.println(i == i1);//printing true
}
在jvm imgui中，我正在使用
System.identityHashCode(i++)
哪里
var i = 0
为每个帧始终为给定对象生成一个常数id（因此
可以对其进行跟踪）
但是，一个用户案例只是告诉我，这仅对中的值有效[0, 125]
尝试调试并查找错误，我结束了这段简短的代码测试：
var i = 0
val A = Array(256, { System.identityHashCode(i++) })
i = 0
val B = Array(256, { System.identityHashCode(i++) })
repeat(256) {
if (A[it] != B[it])
println("[$it] different, A ${A[it]}, B ${B[it]}")
}
还有：
这是为什么？
我是否可以安全地假设这种行为在其他平台上也能保持一致？
我正在编写一个算法问题，下面的代码不能通过大小写
public void pop() {
if (s1.pollFirst() == minStack.peekFirst())
minStack.pollFirst();
}
但是下面可以，
public void pop() {
int tmp = s1.pollFirst() ;
if (tmp == minStack.peekFirst())
minStack.pollFirst();
}
唯一的区别是我如何使用 s1,pollFirst() 返回结果。我无法弄清楚这里的真正区别。谢谢
请有人解释一下,为什么答案是真的和错误的
public class IntegerTest {
public static void main(String[] args) {
Integer x = 1000;
long y = 1000;
Integer z = 1000;
System.out.println(x == y);
System.out.println(x == z);
}
}
当我比较具有相同值的两个双基元类型时,为什么等于方法是错误的？但整数不是
public class EqualMethod {
public static void main(String[] args) {
Double value1 = 6.2;
Double value2 = 6.2;
System.out.println(value1 == value2);
Integer number1 = 2;
Integer number2 = 2;
System.out.println(number1 == number2);
}
}
下面是链表的简单实现.我刚刚添加了相关代码.首先,我在列表中添加了一些值,10,990和10000.当我搜索相同的值时,我得到key = 10,但是对于key = 990和key = 10000则为false,尽管它应该是真的.此外,如果我将第二个值从990更改为99并搜索key = 99,这次我得到一个真实的.
我不确定使用泛型类型.我想我在那里做错了什么.因为如果我用int替换泛型类型,我会得到正确的行为.请建议.
public class LinkedListTest {
public static void main(String[] args) {
LinkedList<Integer> num = new LinkedList<Integer>();
num.add(10);
num.add(990);
num.add(10000);
int key = 10;
System.out.println("Key " + key + " found ?" + num.findValue(key));
key = 990; //also checked for Integer key = 990
System.out.println("Key " + key + " found ?" + num.findValue(key));
key = 10000;
System.out.println("Key " + key + " found ?" + num.findValue(key));
}
}
class LinkedList<T>{
private …