首页 > 试题广场 >

已知String a="a",String b="b",St

[不定项选择题]
已知String a="a",String b="b",String c=a+b,String d=new String("ab") 以下操作结果为true的是 
  • (a+b).equals(c)
  • a+b==c
  • c==d
  • c.equals(d)
查看正确选项
添加回答
人余月半子头像 人余月半子

1.== 和 equals():

(1)“==” 用于比较基本数据类型时比较的是值，用于比较引用类型时比较的是引用指向的地址。
(2)Object 中的equals() 与 “==” 的作用相同，但String类重写了equals()方法，比较的是对象中的内容。
     
public boolean equals(Object anObject) {  if (this == anObject) {
      return true;    } else { if (anObject instanceof String) {
                String aString = (String)anObject;
       if (this.coder() == aString.coder()) { return this.isLatin1() ? StringLatin1.equals(this.value, aString.value) : StringUTF16.equals(this.value, aString.value); 
       }
        } return false;  }
}

2.String对象的两种创建方式:

(1)第一种方式: String str1 = "aaa";  是在常量池中获取对象("aaa" 属于字符串字面量，因此编译时期会在常量池中创建一个字符串对象，如果常量池中已经存在该字符串对象则直接引用)
(2)第二种方式: String str2 = new String("aaa") ; 一共会创建两个字符串对象一个在堆中，一个在常量池中（前提是常量池中还没有 "aaa" 象）。
        System.out.println(str1==str2);//false

3.String类型的常量池比较特殊。它的主要使用方法有两种：

(1)直接使用双引号声明出来的String对象会直接存储在常量池中。
(2)如果不是用双引号声明的String对象,可以使用 String 提供的 intern 方法。 String.intern() 是一个 Native 方法，它的作用是： 如果运行时常量池中已经包含一个等于此 String 对象内容的字符串，则返回常量池中该字符串的引用； 如果没有，则在常量池中创建与此 String 内容相同的字符串，并返回常量池中创建的字符串的引用。
    String s1 = new String("AAA");
    String s2 = s1.intern();
    String s3 = "AAA";
    System.out.println(s2);//AAA
    System.out.println(s1 == s2);//false，因为一个是堆内存中的String对象一个是常量池中的String对象，
    System.out.println(s2 == s3);//true， s1,s2指向常量池中的”AAA“

4字符串拼接：

    String a = "a";
    String b = "b";
         
    String str1 = "a" + "b";//常量池中的对象
    String str2 = a + b; //在堆上创建的新的对象     
    String str3 = "ab";//常量池中的对象
    System.out.println(str1 == str2);//false
    System.out.println(str1 == str3);//true 
    System.out.println(str2 == str3);//false

发表于 2019-10-22 16:18:23 回复(22)
IDEA2022.4.2头像 IDEA2022.4.2
a和b的值都不一样，你给我来个相等，哄鬼呢
发表于 2019-08-22 22:18:09 回复(7)
learner111111头像 learner111111
选D。A的值都不一样；B中左方和右方实质上都是new出来的新String，“==”比较地址，故B不对；C同理，而D中equals在String中被重载，相当于只比较值。
发表于 2018-12-21 17:37:02 回复(5)
lakiemod头像 lakiemod 
public class Test {
       public static void main(String args[]) {
        String a="a";
        String b="b";
        String c=a+b;
        String d=new String("ab");
        
        System.out.println(a.equals(b));
        System.out.println(a + b == c);
        System.out.println(c == d);
        System.out.println(c.equals(d));
    }
}

输出结果：

false
false
false
true

发表于 2019-03-01 17:57:26 回复(1)
闷▼*-.头像 闷▼*-.
B为什么false有人说一下吗？不是有常量池吗？
发表于 2019-08-22 17:45:30 回复(4)
Yujan头像 Yujan 

字符串拼接：
    String a = "a";
    String b = "b";

    //常量池中的对象(不会创建 StringBuilder 对象)
    String str1 = "a" + "b";
        //在堆上创建的新的对象 
    String str2 = a + b;  
        //常量池中的对象(不会创建 StringBuilder 对象)
    String str3 = "ab";
    System.out.println(str1 == str2);//false
    System.out.println(str1 == str3);//true 
    System.out.println(str2 == str3);//false

编辑于 2020-03-04 11:39:42 回复(0)
丶Berserker头像 丶Berserker
A：对，左右两边都相当于new String("ab")，String重写了equals方法，比较的是字面量。
B：错，==比较引用，左右都是相当于new String("ab")；
C：错，同上
D：对，同A

补充：字符串变量拼接底层由StringBuffer 的append()方法实现，相当于new String()。
发表于 2022-02-03 09:33:15 回复(0)
怠惰的小明同学头像 怠惰的小明同学
赋值语句中出现变量 ，就等价于 new 实例，== 不等；
发表于 2020-12-10 16:33:58 回复(0)
牛客195174081号头像 牛客195174081号
字符串拼接相当于new一个新字符串
发表于 2020-11-02 15:04:44 回复(0)
牛客520361200号头像 牛客520361200号
说一下B：a+b == c
a+b在字节码中是new StringBuilder（）.append（"a"）.append（"b"）;然后StringBuilder.toString（），toString（）方法默认是返回一个new String（）【即new String（“ab”）】，但这时串池中早已经载入"ab"。所以a+b==c中，a+b 返回的对象不是串池中的对象c。
编辑于 2022-01-21 19:24:14 回复(2)
废寝忘食小学生头像 废寝忘食小学生

只要new创建对象地址就不一样

发表于 2019-08-28 08:28:13 回复(0)
DennisLee头像 DennisLee
String的equals只比较大小； 
String c = a + b;
//在底层中相当于

String c;
StringBuilder temp = new StringBuilder();
c.append(a);
c.append(b);
c = temp.toString();
因此当
出现String c = a + b时，相当于是在底层新建了一个StringBuilder，然后转换成String，因此地址不一样
发表于 2020-04-17 22:04:39 回复(1)
LJ201903062031127头像 LJ201903062031127
D.
equals()为true的条件是:相比较的2个字符串指针相同或者值相同,所以A错误,D正确;
而"=="为true的条件是指针相同.B选项中(a+b)则在运行时就在堆重新new了一个值为"ab"的String对象,而变量c也是重新new了一个String对象,明显地址不一样,故B错,同理C也是错误的.
发表于 2019-03-12 21:08:57 回复(0)
要发财的烤冷面头像 要发财的烤冷面
引号＋引号在堆中创建 直接两个变量相加在常量池中
发表于 2023-05-03 21:40:38 回复(0)
牛客585927343号头像 牛客585927343号

1.== 和 equals():

(1)“==” 用于比较基本数据类型时比较的是值，用于比较引用类型时比较的是引用指向的地址。
(2)Object 中的equals() 与 “==” 的作用相同，但String类重写了equals()方法，比较的是对象中的内容。 
public boolean equals(Object anObject) {  if (this == anObject) {
      return true;    } else { if (anObject instanceof String) {
                String aString = (String)anObject;
       if (this.coder() == aString.coder()) { return this.isLatin1() ? StringLatin1.equals(this.value, aString.value) : StringUTF16.equals(this.value, aString.value); 
       }
        } return false;  }
}

2.String对象的两种创建方式:

(1)第一种方式: String str1 = "aaa";  是在常量池中获取对象("aaa" 属于字符串字面量，因此编译时期会在常量池中创建一个字符串对象，如果常量池中已经存在该字符串对象则直接引用)
(2)第二种方式: String str2 = new String("aaa") ; 一共会创建两个字符串对象一个在堆中，一个在常量池中（前提是常量池中还没有 "aaa" 象）。
        System.out.println(str1==str2);//false

3.String类型的常量池比较特殊。它的主要使用方法有两种：

(1)直接使用双引号声明出来的String对象会直接存储在常量池中。
(2)如果不是用双引号声明的String对象,可以使用 String 提供的 intern 方法。 String.intern() 是一个 Native 方法，它的作用是： 如果运行时常量池中已经包含一个等于此 String 对象内容的字符串，则返回常量池中该字符串的引用； 如果没有，则在常量池中创建与此 String 内容相同的字符串，并返回常量池中创建的字符串的引用。
    String s1 = new String("AAA");
    String s2 = s1.intern();
    String s3 = "AAA";
    System.out.println(s2);//AAA
    System.out.println(s1 == s2);//false，因为一个是堆内存中的String对象一个是常量池中的String对象，
    System.out.println(s2 == s3);//true， s1,s2指向常量池中的”AAA“

4字符串拼接：

    String a = "a";
    String b = "b";
    String str1 = "a" + "b";//常量池中的对象
    String str2 = a + b; //在堆上创建的新的对象     
    String str3 = "ab";//常量池中的对象
    System.out.println(str1 == str2);//false
    System.out.println(str1 == str3);//true 
    System.out.println(str2 == str3);//false
发表于 2022-08-17 17:23:11 回复(0)
嘻嘻作者哈哈头像 嘻嘻作者哈哈
  • 常量与常量的拼接，结果是常量，返回常量池中的地址；
  • 只要有一个变量，在不适用intern时，都看做变量，使用new创建对象，返回堆区地址；
  • 如果对拼接结果使用intern，则会返回常量池中的地址；
  • 如果使用final修饰，final字符串就是常量，常量与常量拼接，返回常量池中的地址； 
String s1 = "JavaEE";
String s2 = "Hadoop";
// 字面量定义，保存在常量池
String s3 = "JavaEEHadoop";
// 常量与常量的拼接
String s4 = "JavaEE" + "Hadoop";
// 对象参与拼接
String s5 = s1 + "Hadoop";
String s6 = "JavaEE" + s2;
// 拼接结果调用intern方法
String s7 = (s1 + s2).intern();

// true
System.out.println(s3 == s4);
// false
System.out.println(s3 == s5);
// false
System.out.println(s3 == s6);
// false
System.out.println(s5 == s6);
// true
System.out.println(s7 == s3);

// final修饰，变成常量
final String s8 = "JavaEE";
String s9 = s8 + "Hadoop";
// true
System.out.println(s9 == s3);
发表于 2022-05-13 21:52:51 回复(0)
牛客112591380号头像 牛客112591380号
   被a+b得出来的string搞混了，如下图，如果已经有a，再次给e复制的话e不会新建对象，所以a==e为true，但是当str+str这种情况   会在常量池中创建新的对象，所以c==d为false，同理（a+b）==c也为false    
        String a="111";
        String b="222";
        String e="111";
        String c=a+b;
        String d=a+b;
        System.out.println(d==c);
        System.out.println((a+b)==c);
        System.out.println(a==e);
结果
       false
       false
       true

发表于 2022-03-25 16:06:13 回复(0)
牛客431961210号头像 牛客431961210号
常量池中的string字符串不是同一个地址吗？
发表于 2022-02-24 08:18:25 回复(0)
大争之世_红马金枪少年郎头像 大争之世_红马金枪少年郎
发表于 2021-04-16 09:58:30 回复(0)
猪头皮·头像 猪头皮·
字符串相加会自动new一个新的字符串
发表于 2020-04-19 23:01:52 回复(0)
提交观点

问题信息

安卓工程师 测试开发工程师 测试工程师 2019 Java 360集团 Java工程师
来自：360公司-2019校...
上传者：小小
难度：
61条回答 8595浏览

热门推荐

相关试题

扫一扫，把题目装进口袋

求职之前，先上牛客

扫描二维码，进入QQ群

扫描二维码，关注牛客公众号