明朝那些事儿 下载:华为的一道面试题目，请帮忙看看

呵呵，今天去搞到华为给的官方解释了～～～～～～

public static StringBuffer countStr(int count)
{
StringBuffer str = new StringBuffer("");
char ch = 'A';

for(int i = 0; i < count; i++)
str.append(ch);

return str;

}

上面最大的性能问题出现在String对象的不可变性上,在原程序中,str+=ch会在每次循环中复制出2个新的String对象,对系统资源造成极大浪费,而在资源紧张的设备中,这样的操作是致命的,所以改成下面的方式就可以大大优化这一过程.

public static String countStr(int count)
{
char ch = 'A';
StringBuffertemp = newStringBuffer();

for(int i = 0; i < count; i++)
temp.append(ch);

return temp.toString();
}

BTW:
华为的面试题目?难道是招收手机开发人员?呵呵,很基础的题目.我的同事曾经碰到的是:如何实现字符串连接?要求,最少的资源,最优的算法~

首先批评 鬼火狼烟 的答案

java里针对String的 + += 编译器会自动将String转化成StringBuffer

《java编程思想 第2版》里 附录A：对象的传递和返回

中文版759页
英文版1054页

重载后的“+” 以及StringBuffer 小节里说

String 类的对象被设计为恒常的，并使用了前面介绍的伴随类技术。如果查看 JDK 文档中
的 String 类（稍后会对此进行总结），你会发现，类中每个设计修改 String 的方法，在
修改的过程中，确实生成并返回了一批新的 String 对象。最初的 String 并没有受到影响。
C++的 const 提供由编译器支持的对象恒常性，Java 没有这样的功能。想要获得恒常对
象，你必须自己动手，就像 String 那样。

由于 String 对象是恒常的，对某个 String 可以随意取多个别名。因为它是只读的，任何
引用也不可能修改该对象，也就不会影响其他引用。所以，只读对象很好地解决了别名问
题。

这似乎可以解决所有问题。每当需要修改对象时，就创建一堆修改过的新版对象，如同
String那样。然而，对某些操作而言，这太没有效率了。String的重载操作符’+’就是个重
要的例子。重载是指，对特定的类，’+’被赋予额外的含义。（为String重载的’+’和’+=’，
是Java唯一重载的操作符，而且Java不允许程序员重载其他操作符。）

使用 String 对象时，’+’用来连接 String 对象：

String s = "abc" + foo + "def" + Integer.toString(47);

你可以想象它是如何工作的。String “abc”可能有一个 append()方法，它生成了一个连接
了”abc”和 foo 的新的 String 对象。新的 String 连接”def”之后，生成另一个新的 String，
依此类推。

C++允许程序员任意重载操作符。因为这通常是很复杂的过程，Java设计者认为这是“糟糕的”功能，
不应该包括在Java

中。它其实并没有那么糟糕，具有讽刺意味的是，比起C++来，在Java中使用操作符重载容易多了。

这当然可以运行，但它需要大量的中间 String 对象，才能生成最终的新 String，而那些中
间结果需要作垃圾回收。我怀疑 Java 的设计者起先就是这么做的（这是软件设计中的一个
教训，你无法知道所有事情，直到形成代码，并运作起来）。我猜他们发现了这种做法有
着难以忍受的低效率。

解决之道是可变的伴随类，类似前面演示的例子。String 的伴随类称作 StringBuffer，在
计算某些表达式，特别是 String 对象使用重载过的’+’和’+=’时，编译器会自动创建
StringBuffer。下面的例子说明其中发生了什么：

//: appendixa:ImmutableStrings.java
// Demonstrating StringBuffer.
import com.bruceeckel.simpletest.*;

public class ImmutableStrings {
private static Test monitor = new Test();
public static void main(String[] args) {
String foo = "foo";
String s = "abc" + foo + "def" + Integer.toString(47);
System.out.println(s);
// The "equivalent" using StringBuffer:
StringBuffer sb =
new StringBuffer("abc"); // Creates String!
sb.append(foo);
sb.append("def"); // Creates String!
sb.append(Integer.toString(47));
System.out.println(sb);
monitor.expect(new String[] {
"abcfoodef47",
"abcfoodef47"
});
}
} ///:~

在生成 String s 的过程中，编译器使用 sb 执行了大致与下面的工作等价的代码：创建一
个 StringBuffer，使用 append()向此 StringBuffer 对象直接添加新的字符串（而不是每
次制作一个新的副本）。虽然这种方法更高效，但是对于引号括起的字符串，例如”abc”
和”def”，它并不起作用，编译器会将其转为 String 对象。所以，尽管 StringBuffer 提供
了更好的效率，可能仍会产生超出你预期数量的对象。

String 和 StringBuffer 类

下面总结了 String 与 StringBuffer 都可用的方法，你可以感受到与它们交互的方式。表
中并未包含所有方法，只包含了与本讨论相关的重要方法。重载的方法被置于单独一列。

首先是 String 类：

方法 参数，重载 用途

Constructor 重载: 缺省、空参数、 创建 String 对象。
String、StringBuffer、
char 数组、byte 数组.

length( ) String 的字符数。

charAt( ) int 索引 在 String 中指定位置的
字符。

getChars( ), 复制源的起点与终点、 复 复制 char 或 byte 到外部
getBytes( ) 制的目标数组、目标数组的 数组。
索引。

toCharArray( ) 生成 char[]，包含 String
的所有字符。

equals( ), 做比较的 String 两个 String 的等价测试。
equals-IgnoreCase( )

compareTo( ) 做比较的 String 根据词典顺序比较 String
与参数，结果为负值、零、
或正值。大小写有别。

indexOf( ), 重载： char、char 和起 如果当前 String 中不包含
lastIndexOf( ) 始索引、String、String 参数，返回－1，否则返回参
和起始索引. 数在 String 中的位置索引。
LastIndexOf()由末端反
向搜索。

substring( ) 重载: 起始索引、起始索引 返回新的 String 对象，包
和终止索引 含特定的字符集。

concat( ) 要连接的 String 返回新 String 对象，在原
String 后追加参数字符。

replace( ) 搜索的旧字符，用来替代的 返回指定字符被替换后的新
新字符 String 对象。如果没有发生
替换，返回原 String。

成一个且仅生成一个 String
引用。

可以看到，当必须修改字符串的内容时，String的每个方法都会谨慎地返回一个新的String
对象。还要注意，如果内容不需要修改，方法会返回指向源 String 的引用。这节省了存储
空间与开销。

以下是 StringBuffer 类：

方法 参数, 重载 用途

Constructor 重载: 空参数、要创建的缓冲区 创建新的 StringBuffer
长度、String 的来源. 对象。

toString( ) 由此 StringBuffer 生成
String。

length( ) StringBuffer 中的字符
个数。

setLength( ) 代表缓冲区中字符串长度的整数 截短或扩展原本的字符串。
如果扩展，以 null 填充新
增的空间。

charAt( ) 代表所需元素位置的整数。 返回 char 在缓冲区中的
位置。

setCharAt( ) 代表所需元素位置的整数，和新 修改某位置上的值。
的 char 值

getChars( ) 复制源的起点与终点、复制的目 复制 char 到外围数组。没
的端数组、目的端数组的索引。 有 String 中的
getBytes( ) 。

append( ) 重载: Object、String、 参数转为字符串，然后追加

char[]、char[] 和偏移和长 到当前缓冲区的末端，如果
度、boolean、char、int、 必要，缓冲区会扩大。
long、float、double.

insert( ) 被重载过，第一个参数为插入起 第二个参数转为字符串，插
始点的偏移值: Object、 入到当前缓冲区的指定位
String、char[]、boolean、置。如果必要，缓冲区会扩
char、int、long、float、 大。
double.

最常用的方法是 append()，当计算包含’+’和’+=’操作符的 String 表达式时，编译器会使
用它。Insert()方法有类似的形式，这两个方法都会在缓冲区中进行大量操作，而不需创建
新对象。

String 是特殊的

到目前为止，你已经看到了，String 类不同于 Java 中一般的类。 String 有很多特殊之处，
它不仅仅只是一个 Java 内置的类，它已经成为 Java 的基础。而且事实上，双引号括起的
字符串都被编译器转换为 String 对象，还有专门重载的’+’和’+=’操作符。在本附录中，
你还能看到其他特殊之处：使用伴随类 StringBuffer 精心建构的恒常性，以及编译器中的
一些额外的魔幻式的功能。

/**********
对象操作效率低下
况且java的对象都在堆里
原文对对象重复进行操作
纯粹是傻瓜蛋行为
**********/
// **********************************************************

public static String countStr(int count)
{
char ch [ ] = new char[count];

for(int i = 0; i < count; i++)
ch [i] = 'A';

String str = new String(ch);

return str;
}

// **********************************************************

呵呵,如果是我,我会改成

class Hw
{
// *之内的部分存在潜在的性能威胁，请说明并加以优化
// *********************************************************
public static String countStr(int count)
{
char ch = 'A';
char[] chbuf = new char[count];

for(int i = 0; i < count; i++)
chbuf[i] = ch;

return ((new StringBuffer()).append(chbuf)).toString();
}
// **********************************************************
public static void main(String[] args)
{
Hw f = new Hw();
String s = f.countStr(10);

System.out.println(s);
}
}