首页 > 试题广场 >

关于下面的一段代码，以下哪些说法是正确的： public

[不定项选择题]
关于下面的一段代码，以下哪些说法是正确的：

public static void main(String[] args) {
    String a = new String("myString");
    String b = "myString";
    String c = "my" + "String";
    String d = c;
    System.out.print(a == b);
    System.out.print(a == c);
    System.out.print(b == c);
    System.out.print(b == d);
}

  • System.out.print(a == b)打印出来的是false
  • System.out.print(a == c)打印出来的是true
  • System.out.print(b == c)打印出来的是false
  • System.out.print(b == d)打印出来的是true
查看正确选项
添加回答
🍰201808081332196头像 🍰201808081332196
A：a指向堆内存，b指向常量池，因此地址不相等，false
B：java有常量优化机制，c也指向常量池，且与b指向同一个，则a与c地址不相等,false；
C：b与c地址相等，true
D：d是c的副本，地址相同，所以b与d地址相等，true
发表于 2019-08-28 09:50:49 回复(6)
眉毛密过发头像 眉毛密过发
a是运行时动态加载的，此时会在堆内存中生成一个myString字符串，指向堆内存字符串地址
b是编译时静态加载的，此时会在常量池中存放一个myString字符串，指向常量池字符串地址
c会在编译时对"my" + "String"进行拼接成myString字符串，再去常量池查找，找到之后指向该字符串地址
d是c的脚本，地址相同
最后：Sting的==比较的是地址值是否相同
发表于 2019-09-28 12:57:42 回复(3)
左手201809131222262头像 左手201809131222262
关于字符串的拼接问题我想讲一下： 
class StringJoin{
    public static void main(String[] args){
        String s1="a";
        String s2="b";
        String s6="ab";
        
        String s3="a"+"b";
        
        String s4=s1+s2;
        
        String s5=s1+"b";
        
        //常量拼接与常量比较
        System.out.println(s6==s3);
        
        //常量与变量拼接与常量比较
        System.out.println(s6==s5);
        
        //变量拼接与常量比较
        System.out.println(s6==s4);
        
    }
}
运行结果：

总结：
字符串的拼接与常量比较的问题（前提是字符串拼接之后的内容与常量相同），若拼接字符串的+两边存在变量，则会在堆上new一个新的对象，此时与常量的==结果为false；
若拼接字符串的+两边均是常量，由于java的常量优化机制，拼接的结果是指向常量池的，与常量==的结果是true；

如有错误之处欢迎指出！

发表于 2020-01-21 10:34:44 回复(7)
不知道取名字头像 不知道取名字
String b="mystring"的时候在方法区new了一个空间进行存储，当String c="my"+"string"的时候又new了两个空间分别存储my与string,当my与string两者进行结合时，方法区已经存在了mystring，所以直接用mystring赋值给c,而不是重新new一个空间存储“mystring”
发表于 2019-08-21 11:27:46 回复(5)
Princejin_King头像 Princejin_King
题目显示不全
发表于 2021-04-07 08:24:22 回复(1)
黎客头像 黎客
a是创建在堆中，b是创建在字符串常量池中，c在创建时会先去字符串常量池中寻找，发现b已经创建过了，会直接引用。补充 a和c应该是不会主动在字符串常量池中创建，都是建立在堆中。如有不对还请指正
发表于 2022-04-13 08:25:56 回复(1)
哈哈哈1998.头像 哈哈哈1998.
@Test
    public void  StringStest(){
        
        //堆内存中生成一个myString字符串，指向堆内存字符串地址
        String a = new String("myString");
        //此时会在常量池中存放一个myString字符串，指向常量池字符串地址
         String b = "myString";
        //c会在编译时对"my" + "String"进行拼接成myString字符串，
         //再去常量池查找，找到之后指向该字符串地址
            String c = "my" + "String";
            
            //d是c的脚本，地址相同
            String d = c;
            
            //false
            System.out.print(a == b);
            System.out.print(a == c);
            //true
            System.out.print(b == c);
            System.out.print(b == d);
            System.out.print(c==d);
            
           // String的==比较的是地址值是否相同
    }
发表于 2022-01-17 16:01:45 回复(0)
Eilot头像 Eilot
字符串以非new形式创建时，会先在常量池寻找是否有相同字符；若有，则引用，若没有，则创建后引用。

发表于 2022-05-14 21:06:34 回复(0)
刘泽博头像 刘泽博
A：a指向堆内存，b指向常量池，因此地址不相等，false
B：java有常量优化机制，c也指向常量池，且与b指向同一个，则a与c地址不相等,false；
C：b与c地址相等，true
D：d是c的副本，地址相同，所以b与d地址相等，true
发表于 2022-05-07 16:38:14 回复(1)
玉树临风的java程序员头像 玉树临风的java程序员
New 堆内存 直接定义常量池
发表于 2021-04-30 14:02:37 回复(1)
可不否头像 可不否
a指向的是堆内存，b指向的是常量池，c和d也是。而且==比较的是地址
编辑于 2020-05-26 21:44:02 回复(0)
PersieLin头像 PersieLin
new 返回的是一个对象的引用
发表于 2019-06-03 19:27:54 回复(0)
双城08头像 双城08
b和c是常量池里面找,所以是true！c和d的地址是一样的，所以b，c，d==比较的话都是true

编辑于 2022-03-08 15:40:27 回复(0)
怎么不被卷飞头像 怎么不被卷飞

  • 字符串 变量 拼接的原理是StringBuilder 最终在堆内存中

  • 字符串 常量 拼接的原理是编译器优化  最终在串池中    如 ：String c = "my" + "String";
  • 直接 new 出来的对象也在串池中
发表于 2021-09-30 15:01:53 回复(0)
马尔科🍍队长头像 马尔科🍍队长
public static void main(String[] args) {
  String a = "1";
  String b = "2";
  String c = "12";
  String d = "1"+"2";
  String e = a+b;
  String f = a+"2";
  
  System.out.println(c==d);
  System.out.println(c==e);
  System.out.println(c==f);
 }
输出结果：
true
false
false
如果+两边有变量，都会new一个对象，地址肯定不同。
发表于 2020-10-18 17:06:52 回复(0)
KaneLiam头像 KaneLiam
这个程序的主要目的是考察Java中字符串的比较方式以及字符串常量池的工作机制。下面我会逐行解释程序运行的结果：

### 1. 创建字符串对象
```java
String a = new String("myString");
```
这一行代码使用 `new` 关键字创建了一个新的 `String` 对象，因此字符串 `"myString"` 被存储在堆（heap）中，**不是**从字符串常量池中获取的。这意味着即使内容相同，`a` 引用的字符串对象在内存中与其他字符串对象是不同的。

```java
String b = "myString";
```
这一行直接用字符串字面量 `"myString"` 赋值给 `b`。在Java中，字符串字面量会被放入**字符串常量池**中。如果常量池中已经有这个值，`b` 将直接引用常量池中的 `"myString"`。

```java
String c = "my" + "String";
```
这里用字符串拼接的方式创建了 `c`，但由于 `"my"` 和 `"String"` 都是编译时已知的常量，因此 Java 编译器在编译时会优化这段代码，把它转换为：
```java
String c = "myString";
```
因此，`c` 引用的也是常量池中的 `"myString"`。

```java
String d = c;
```
这一行代码只是简单地将 `c` 的引用赋值给 `d`，因此 `d` 和 `c` 引用同一个字符串对象，即常量池中的 `"myString"`。

### 2. 比较结果输出
接下来代码使用 `==` 运算符来比较不同字符串的引用。

```java
System.out.print(a == b);
```
**结果：`false`**

`a` 是通过 `new` 创建的，它指向的是堆中的一个对象；而 `b` 引用的是常量池中的字符串对象，尽管两者内容相同，但由于它们引用的是不同的内存地址，因此结果为 `false`。

```java
System.out.print(a == c);
```
**结果：`false`**

与上一个比较类似，`a` 仍然指向堆中的一个对象，而 `c` 引用的是常量池中的对象，因此这两个对象的内存地址不同，结果仍为 `false`。

```java
System.out.print(b == c);
```
**结果：`true`**

`b` 和 `c` 都引用了常量池中的 `"myString"`，所以它们引用的是同一个内存地址，结果为 `true`。

```java
System.out.print(b == d);
```
**结果：`true`**

由于 `d` 是直接引用了 `c`，而 `c` 和 `b` 都指向常量池中的同一个字符串，因此 `b` 和 `d` 引用的是同一个内存地址，结果为 `true`。

### 3. 总结
程序输出的结果是：
```
falsefalsetruetrue
```

- `a` 是通过 `new` 关键字创建的，指向堆内存中的一个独立的对象。
- `b` 和 `c` 是直接使用字符串字面量创建的，它们引用的是常量池中的同一个字符串对象。
- 字符串在Java中是不可变的，并且为了优化内存使用，字符串字面量会被存储在常量池中，多个相同的字符串字面量会引用同一个对象。

这个程序的运行结果充分说明了在Java中使用 `==` 比较字符串时，比较的是引用而不是内容。要比较字符串的内容是否相同，应该使用 `equals()` 方法。
发表于 2024-10-10 23:36:30 回复(0)
啾啾阿咻头像 啾啾阿咻
java中只要是new了，就是把本身对象放到堆中，然后让其他变量来指向堆中的它。比如：
 String a = new String("myString");等号右边就是一个放在堆中的对象，而本题的a因为是在方法中的变量，所以a就放在了栈中，而a就指向了堆中的那个对象。同时因为出现了"myString"，所以堆中的常量池就会创建了一个对象。注意：这里的对象和堆中的哪个对象地址是不同的。

因此， String b = "myString";栈中的b指向的是常量池中的“myString”。

String c = "my" + "String";两个字符串直接相加，这种连接在编译时就已经被处理了，称为字符串常量折叠，和“myString”等价，所以栈中的c指向的是常量池中的“myString”。

String d = c; 因为栈中存储的是变量的引用，而不是实际的对象，所以就是将c指向的地址给d，因此，c和d都指向了常量池中的”myString”。
发表于 2024-06-07 16:52:32 回复(0)
leolz头像 leolz
做些补充：如果是字符串拼接操作，则为false，如下： 
String b = "myString";
String c = "my";
String e = "String";
String d = c + e;
System.out.print(b == d);
会在堆中创建一个新的 String 对象，d 指向该 String 对象。
发表于 2024-05-17 16:03:10 回复(0)
WT冲啊头像 WT冲啊
mark
发表于 2022-07-17 13:44:08 回复(0)
牛客278321533号头像 牛客278321533号
bcd都是赋值了myString,放到了常量池当中，地址相同。而a创建了对象，开辟了新地址，地址与bcd不同。 输出中的==比较的就是地址，所以a与bcd比较输出的都是false，bcd之间相互比较结果都是true
发表于 2022-07-08 17:30:46 回复(0)
提交观点

问题信息

安卓工程师 小米集团 2019 Java
来自：小米2019秋招安卓开...
上传者：小小
难度：
39条回答 4860浏览

热门推荐

相关试题

扫一扫，把题目装进口袋

求职之前，先上牛客

扫描二维码，进入QQ群

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