java 面试

Question

String s = "a" + "b" + "c" + "d" + "e"; 问此语句共创建了几个对象请给出分析过程

Answer 1

应该是6吧。堆上有a,b,c,d,e,s  我刚学，坐等高人

Answer 2

真是艹蛋，只会创建一个对象，在常量池中String s = "a" + "b" + "c" + "d" + "e";引号中都是常量，在编译的时候已经变成String s = "abcde";了，若有不信者，可以编译后在反编译.class文件因为没有new，所以只在常量池中有一个

Answer 3

月经贴
只有一个对象。String s

Answer 4

这还用说，当然是一个了，JAVA具有自动合并已知常量的功能，这里只是在String 缓冲池里创建了一个"abcde"的对象.

Answer 5

这还用说，当然是一个了，JAVA具有自动合并已知常量的功能

Answer 6

咋还是觉得是6个呢？
按照顺序 = 号最后  前面都是每个String 相加啊哎！！
坐等高手解答

Answer 7

下了个反编译工具看了下却实是哈
源码这是：
package com.string;public class test {
public static void main(String[] args) {
String s = "a"+"b"+"c"+"d"+"e";
}
}
这是反编译后的代码// Decompiled by DJ v3.7.7.81 Copyright 2004 Atanas Neshkov  Date: 2010-8-15 上午 10:56:49
// Home Page : http://members.fortunecity.com/neshkov/dj.html  - Check often for new version!
// Decompiler options: packimports(3) 
// Source File Name:   test.javapackage com.string;
public class test
{    public test()
    {
    }    public static void main(String args[])
    {
        String s = "abcde";
    }
}

Answer 8

下了个反编译工具看了下却实是哈
源码这是：
package com.string;public class test {
public static void main(String[] args) {
String s = "a"+"b"+"c"+"d"+"e";
}
}
这是反编译后的代码// Decompiled by DJ v3.7.7.81 Copyright 2004 Atanas Neshkov Date: 2010-8-15 上午 10:56:49
// Home Page : http://members.fortunecity.com/neshkov/dj.html - Check often for new version!
// Decompiler options: packimports(3)  
// Source File Name: test.javapackage com.string;
public class test
{  public test()
  {
  }  public static void main(String args[])
  {
  String s = "abcde";
  }
}
支持啊！！要动手

Answer 9

8个吧
String s = "a" + "b" + "c" + "d" + "e"; 
相当于
String s = new String("a") + new String("b") + new String("c") + new String("d") + new String("e");
 

Answer 10

就创建了一个 
String s = "a" + "b" + "c" + "d" + "e"; 
赋值符号右边的"a"、"b"、"c"、"d"、"e"都是常量 
对于常量，编译时就直接存储它们的字面值而不是它们的引用 
在编译时就直接讲它们连接的结果提取出来变成了"abcde" 
该语句在class文件中就相当于String s = "abcde" 
然后当JVM执行到这一句的时候， 就在String pool里找 
如果没有这个字符串，就会产生一个 

Answer 11

但是如果改成 String s = a+b+c+d+e; 
呢 又是几个了。 就是说上面是一个是因为 "a"、"b"、"c"、"d"、"e"都是常量 
但如果是变量呢？ 我的答案是3个对象，但只有一个String对象：由于编译器的优化，最终代码为通过StringBuilder完成：
StringBuilder builder = new StringBuilder(); 
builder.append(a); 
builder.append(b); 
builder.append(c); 
builder.append(d); 
builder.append(e); 
String s = builder.toString(); 
我们先看看StringBuilder的构造器
    public StringBuilder() {
      super(16);
    }
看下去
    AbstractStringBuilder(int capacity) {
        value = new char[capacity];
    }
可见，分配了一个16自己长度的char数组我们看看append的整个过程(注意，源代码我从各个类进行了整合，他们实际上不在一个类里面的)  public StringBuilder append(String str) {
    super.append(str);
    return this;
  }  public AbstractStringBuilder append(String str) {
    if (str == null)
      str = "null";
    int len = str.length();
    if (len == 0)
      return this;
    int newCount = count + len;
    if (newCount > value.length)
      expandCapacity(newCount);
    str.getChars(0, len, value, count);
    count = newCount;
    return this;
  }  public void getChars(int srcBegin, int srcEnd, char dst[], int dstBegin) {
    if (srcBegin < 0) {
      throw new StringIndexOutOfBoundsException(srcBegin);
    }
    if (srcEnd > count) {
      throw new StringIndexOutOfBoundsException(srcEnd);
    }
    if (srcBegin > srcEnd) {
      throw new StringIndexOutOfBoundsException(srcEnd - srcBegin);
    }
    System
        .arraycopy(value, offset + srcBegin, dst, dstBegin, srcEnd - srcBegin);
  }
可见，我们的代码不会超过16个，所以不会出现扩展value的情况。
而append里面使用了arraycopy的复制方式，也没有产生新的对象。最后，我们再看StringBuilder的 toString()方法： 
 public String toString() {
    // Create a copy, don't share the array
    return new String(value, 0, count);
  }
这里通过前面的数组生成了一个新的String。大家注意那个默认的16容量，如果题目出现了总长度超过16，则会出现如下的再次分配的情况
  void expandCapacity(int minimumCapacity) {
    int newCapacity = (value.length + 1) * 2;
    if (newCapacity < 0) {
      newCapacity = Integer.MAX_VALUE;
    } else if (minimumCapacity > newCapacity) {
      newCapacity = minimumCapacity;
    }
    value = Arrays.copyOf(value, newCapacity);
  }  public static char[] copyOf(char[] original, int newLength) {
    char[] copy = new char[newLength];
    System
        .arraycopy(original, 0, copy, 0, Math.min(original.length, newLength));
    return copy;
  }
可见，expand容量时，增加为当前(长度+1)*2。
注意这里用了Arrays的方法，注意不是前面的 System.arraycopy方法哦。这里产生了一个新的
copy的char数组，长度为新的长度
总结：三个对象分别为
1 StringBuilder
2 new char[capacity]
3 new String(value,0,count);如果说String对象，则为1个。

Answer 12

"builder.append(a);  
builder.append(b);  
builder.append(c);  
builder.append(d);  
builder.append(e);"
请问你这个a,b,c,d,e变量所指的不是5个String对象？

Answer 13

Java中不是号称一切都是对象吗？所以引用啊，字符串常量啊都应该算对象吧，哈哈。

Answer 14

应该是6个吧。string a= "a";这样创建了2个。
String a = new String();
a = "a";
那么"a" + "b" + "c" + "d" + "e"; 数一下

Answer 15

引用不是对象，OK？，英文文献中叫Reference，Not Object

Answer 16

String a = new String("a") //两个
String a = "a" //一个
不过我感觉讨论这没什么意义啊

Answer 17

经过昨天的实验 我还是觉得是两个对象String s  一个   a+b+c+d+e  一个

Answer 18

25楼说的StringBuild是JDK1.5及以上才有的额、
那1.3、1.4是什么原理呢

Answer 19

这么算的话String里面也有char数组对象，每个类型还关联一个String.class对象……
继续关联下去，n多对象

Answer 20

怎么说都对，JAVA 内库中总的来说是1- n2 个

Answer 21

正解：9个
a,b,c,d,e,ab,abc,abcd,abcde

Answer 22

"a","b","c","d","e"每个都是一个对象
"a"+"b"=ab一个
"ab"+"c"=abc一个
"abc"+"d"=abcd一个
"abcd"+"e"=abcde一个一共创建了9个对象，String是一个final类；如果这里用StringBuffer那就是创建一个，因为StringBuffer有append方法实现字符的串联。

Answer 23

.
String s = "abcde";
老师教我的是 应该二个对像啊？ 怎么回事，求解答。

Answer 24

只有一个对象，如果是
String a =“a”；
String b = “b”；
.......
a + b 将是产生2个对象，依次类推。

Answer 25

Java的这个东西好像跟C++很不一样。
由于Java编译器的优化，这个东西应该在编译器就被优化过了。
等号右侧全是常量，创建了一个对象。

Answer 26

只有一个对象，String s=""创建一个对象并开辟一个内存空间，里面放的是abcde,“”+“”这里的加号是连接的作用

Answer 27

1个呗！相当于建了个常量，s的值为abcde