相关疑难解决方法(0)

我想澄清一下我是否理解正确:

• == - >是参考比较,即两个对象都指向相同的内存位置
• .equals() - >计算对象中值的比较

我的理解是正确的吗？

据我所知,每次输入字符串文字时"",字符串池中都会引用相同的String对象.

但是为什么String API不包含a public static final String Empty = "";,所以我可以使用引用String.Empty？

它至少可以节省编译时间,因为编译器会知道引用现有的String,而不必检查它是否已经被创建以供重用,对吧？我个人认为,在许多情况下,字符串文字的扩散,尤其是小字符串,是一种"代码味道".

那么,没有String.Empty背后有一个大设计理由,还是语言创作者根本没有分享我的观点？

根据String #intern(),intern如果在String池中找到String,则该方法应该从String池返回String,否则将在String池中添加新的字符串对象并返回此String的引用.

所以我试过这个:

String s1 = "Rakesh";
String s2 = "Rakesh";
String s3 = "Rakesh".intern();

if ( s1 == s2 ){
    System.out.println("s1 and s2 are same");  // 1.
}

if ( s1 == s3 ){
    System.out.println("s1 and s3 are same" );  // 2.
}

我期待s1 and s3 are same将被打印为s3被实习,并且s1 and s2 are same不会被打印.但结果是:两行都打印出来.这意味着,默认情况下,字符串常量被实现.但如果是这样,那么为什么我们需要这种intern方法呢？换句话说,我们什么时候应该使用这种方法？

你用StringUtils.EMPTY而不是""吗？

我的意思是作为返回值或者如果设置String变量的值.我不是要比较,因为我们使用StringUtils.isEmpty()

我无法理解Java Constant Pool for Integer的工作原理.

我理解字符串的行为,因此能够证明自己与Integer Constants的情况相同.

所以,对于整数

Integer i1 = 127;
Integer i2 = 127;
System.out.println(i1==i2); // True

&

Integer i1 = new Integer(127);
Integer i2 = new Integer(127);
System.out.println(i1==i2); // False

直到这里,一切都在我的脑海里.

我无法消化的是,当我从127增加整数时,它的行为有所不同.这种行为在127之后发生变化,下面是代码片段

Integer i1 = 128;
Integer i2 = 128;
System.out.println(i1==i2); // False. WHY?????

有人可以帮我理解吗？

考虑：

String s1 = new StringBuilder("Cattie").append(" & Doggie").toString();
System.out.println(s1.intern() == s1); // true why?
System.out.println(s1 == "Cattie & Doggie"); // true another why?

String s2 = new StringBuilder("ja").append("va").toString();
System.out.println(s2.intern() == s2); // false

String s3 = new String("Cattie & Doggie");
System.out.println(s3.intern() == s3); // false
System.out.println(s3 == "Cattie & Doggie"); // false

我糊涂了，为什么它们是由不同产生的返回值的String.intern()其中说：

调用intern方法时，如果池已经包含等于equals（Object）方法确定的此String对象的字符串，则返回池中的字符串。否则，将此String对象添加到池中，并返回对此String对象的引用。

特别是经过以下两个测试：

assertFalse("new String() should create a new instance", new String("jav") == "jav");
assertFalse("new StringBuilder() should create a new instance",
    new StringBuilder("jav").toString() == …

我可以创建一个只使用=运算符实例化的String类,就像类一样吗？或者这是StringJava中特定于类的功能？

public static void main(String[] args) {
    String str1 = new StringBuilder("???").append("??").toString();
    System.out.println(str1.intern() == str1);
    String str2 = new StringBuffer("ja").append("va").toString();
    System.out.println(str2.intern() == str2);
}

结果:

 true
 false   

第一个打印true,第二个打印false.为什么结果不同？

public class Child{

    public static void main(String[] args){
        String x = new String("ABC");
        String y = x.toUpperCase();

        System.out.println(x == y);
    }
}

输出: true

因此,没有toUpperCase()始终创建一个新的对象？

我正试图找到这个问题的第三个解决方案.

我不明白为什么这不打印false.

public class MyClass {

    public MyClass() {
        try {
            Field f = String.class.getDeclaredField("value");
            f.setAccessible(true);
            f.set("true", f.get("false"));
        } catch (Exception e) {
        }
    }

    public static void main(String[] args) {
        MyClass m = new MyClass();
        System.out.println(m.equals(m));
    }
}

当然,由于字符串实习,"true"被修改的实例与print方法中使用的实例完全相同PrintStream？

public void print(boolean b) {
    write(b ? "true" : "false");
}

我错过了什么？

编辑

@yshavit的一个有趣的观点是,如果你添加这条线

System.out.println(true);

之前try,输出是

true
false