首页 > 试题广场 >

定义有StringBuffer s1=new StringB

[单选题]

定义有StringBuffer s1=new StringBuffer(10);s1.append(“1234”)，则s1.length()和s1.capacity()分别是多少?

```
4   10
```
```
4   4
```
```
10  10
```
```
10  4
```

查看答案及解析

推荐

dp_sp不是缩写是2b倒写切记

length 返回当前长度

如果字符串长度没有初始化长度大，capacity返回初始化的长度

如果append后的字符串长度超过初始化长度，capacity返回增长后的长度

编辑于 2015-02-03 10:19:07 回复(7)

Wednesss

StringBuffer s = new StringBuffer(x); x为初始化容量长度

s.append("Y"); "Y"表示长度为y的字符串

length始终返回当前长度即y；

对于s.capacity()：

1.当y<x时，值为x

以下情况，容器容量需要扩展

2.当x<y<2*x+2时，值为 2*x+2

3.当y>2*x+2时，值为y

编辑于 2016-10-25 22:05:25 回复(12)

smartleon

length 返回当前长度

如果字符串长度没有初始化长度大，capacity返回初始化的长度

如果append后的字符串长度超过初始化长度，capacity返回增长后的长度

PS:

StringBuffer和StringBuilder的默认大小为16

ArrayList和LinkedList的默认大小10

发表于 2015-10-27 16:47:30 回复(9)

北辰1

楼上说法不正确，length()返回的是当前的元素个数数值。

而capacity()返回的是初始化字节数。（字节！！！）

发表于 2016-06-07 16:05:27 回复(11)

谓所无

StringBuffer sb = new StringBuffer("abcd");
StringBuffer buffer1 = new StringBuffer(10);
StringBuffer buffer2= new StringBuffer(3);
StringBuffer buffer3= new StringBuffer(1);
buffer1.append("abcd");
buffer2.append("abcd");//扩容的长度为原来的2倍+2
buffer3.append("abcd");//2*1<4  扩容长度为4
System.out.println(buffer1.length()+" && "+buffer2.length() +" && "+buffer3.length() +" && "+sb.length());
System.out.println(buffer1.capacity()+" && "+buffer2.capacity()+" && "+buffer3.length() +" && "+sb.capacity());

输出结果：
4 && 4 && 4 && 4
10 && 8 && 4 && 20

如果你初始化的长度StringBuffer sb = new StringBuffer(x);

sb.append(str);//x无法满足str的长度时，需要扩容
扩容规则：if(str.length>2*x+2) capacity = str.length;
else capacity = 2*x+2;
具体还是参照源码;写一下测试案例

编辑于 2016-09-05 14:45:52 回复(1)

Lemuria

发表于 2016-09-20 14:05:33 回复(7)

隔三岔五的小幸福

length()代表的是其中的内容的长度，capacity()代表的是容器的大小。

当设置StringBuffer的容量

1、小于当前容量时，容量不变，默认为16。
2、大于当前容量，并且小于(当前容量+1)*2，则容量变为(当前容量+1)*2。

3、大于当前容量，并且大于(当前容量+1)*2，则容量变为用户所设置的容量。

例如本题中如果 StringBuffer s1=new StringBuffer(1)；s1.append("12345")；则 s1.capacity()=5

ArrayList默认大小为10，默认扩充为原来的1.5倍。

编辑于 2016-09-05 10:31:30 回复(0)

大河儿马

StringBuffer和StringBuilder的默认大小为16

ArrayList和LinkedList的默认大小10

发表于 2015-10-08 09:58:21 回复(0)

牧野伶优

public class Demo {  
    public static void main(String [] args){  

         StringBuffer sb1 = new StringBuffer(10);//构造一个不带字符，但具有指定初始容量的字符串缓冲区。
         System.out.println(sb1.length());//0
         System.out.println(sb1.capacity());//10,指定了长度
        
         System.out.println("============");
         sb1.append("abcd");
         System.out.println(sb1.length());//4
         System.out.println(sb1.capacity());//10
        
         System.out.println("============");
         sb1.append("efghij");
         System.out.println(sb1.length());//10
         System.out.println(sb1.capacity());//10
        
         System.out.println("============");
         sb1.append("k");
         System.out.println(sb1.length());//11
         System.out.println(sb1.capacity());//22,当length>capacity时，capacity=(原capacity+1)*2
        
         System.out.println("============");
         sb1.append("abcdefghijk");
         System.out.println(sb1.length());//22
         System.out.println(sb1.capacity());//22,length==capacity
        
         System.out.println("============");
         sb1.append("abcdefghijkabcdefghijkabcdefghijkabcdefghijk");//相当于6段"abcdefghijk"
         System.out.println(sb1.length());//66
         System.out.println(sb1.capacity());//66,(22+1)*2=46,仍小于66。干脆和length同步 
        
        
        
         System.out.println("====================================================================");
         System.out.println("============");
         StringBuffer sb2 = new StringBuffer();//构造一个其中不带字符的字符串缓冲区，其初始容量为 16 
         sb2.append("hello");
         System.out.println(sb2.length());//5
         System.out.println(sb2.capacity());//16
         
         System.out.println("============");
         sb2.append("6789abcdefg");
         System.out.println(sb2.length());//16
         System.out.println(sb2.capacity());//16,length==capacity
         
         System.out.println("============");
         sb2.append("h");
         System.out.println(sb2.length());//17
         System.out.println(sb2.capacity());//34,当length>capacity,capacity=(原capacity+1)*2
         
         System.out.println("============");
         sb2.append("hello6789abcdefghhello6789abcdefghhello6789abcdefghhello6789abcdefgh");
         System.out.println(sb2.length());//17*5=85 复制5次“hello6789abcdefgh”
         System.out.println(sb2.capacity());//85,(34+1)*2=70,即使加1倍增，仍无法满足，干脆直接和length同步
         
         
         System.out.println("==========================================================");
         StringBuffer sb3 = new StringBuffer("hello");//构造一个字符串缓冲区，它包含与指定的字符。该字符串缓冲区的初始容量为 16加上参数的长度。 
         System.out.println(sb3.length());//5
         System.out.println(sb3.capacity());//StringBuffer的的初始大小为(16+初始字符串长度);5+16=21
          
         System.out.println("============");
         sb3.append("6789abcdefghijkL");
         System.out.println(sb3.length());//21
         System.out.println(sb3.capacity());//21
          
         System.out.println("============");
         sb3.append("M");
         System.out.println(sb3.length());//22
         System.out.println(sb3.capacity());//44,(原capacity+1)*2
          
         System.out.println("============");
         sb3.append("hello6789abcdefghijkLMhello6789abcdefghijkLMhello6789abcdefghijkLMhello6789abcdefghijkLM");//相当于5段“hello6789abcdefghijkLM”
         System.out.println(sb3.length());//110
         System.out.println(sb3.capacity());//110,与length同步了;
   
      
    }  
}

看其他人的解释，都是有什么跨界倍增，作为补充我将三种构造全展示了。

本题就是直接构造一个指定容量大小为10的StringBuffer s1;然后向里面添加“1234”字符串，

s1.length()就是表示当前字符串的长度，就是4.

s1.capacity() 表示s1的底层容量大小，在定义s1的时候已经指定了，所以就是10；

发表于 2018-12-11 13:37:05 回复(0)

牛客382781号

public StringBuffer(int capacity) {

super(capacity);

}

super即为AbstractStringBuilder

AbstractStringBuilder(int capacity) {

value = new char[capacity];

}

/**

* Returns the length (character count).

*length即为字符的个数

* @return the length of the sequence of characters currently

* represented by this object

public int length() {

return count;

}

发表于 2015-10-09 15:43:35 回复(0)

＆智慧(波)№

对于楼上的一些解析，再做一些补充。

1.length 返回当前长度

2.如果字符串长度没有初始化长度大，capacity返回初始化的长度

以上两点没有问题。

对于第三点：3.如果append后的字符串长度超过初始化长度，capacity返回增长后的长度

这个观点不够完整，我作一些小小的补充。

首先，我们先看源码。我们看StringBuffer 的 append的操作后，对capacity的影响是怎样的

首先，我们可以看到，如果append后的字符串长度超过初始化长度，它会先将初始化的容量翻倍再+2.

如图： int newCapacity = value.length * 2 + 2 ;

在初始化容量增长过一次之后，仍然不够用的话，就会用 append后的字符串长度作为新的容量。

编辑于 2017-05-03 09:20:37 回复(0)

焰石

String对项内容是不可改变的，StringBuffer是可以改变的，且高效。

发表于 2014-11-21 22:10:57 回复(0)

调皮的小蜗牛破防了

stringbuffer扩容机制: （1）如果加入新字符串后，字符串小于当前容量时，容量不变。不设置容量的情况下，默认容量为16。（2）加入新字符串后，字符串大于当前容量，并且小于(当前容量+1)*2，则容量变为(当前容量+1)*2。（3）加入新字符串后，字符串大于当前容量，并且大于(当前容量+1)*2，则容量变为字符串长度。 arraylist和linkedlist的默认初始容量为10，每次扩容为1.5倍

发表于 2021-10-16 18:49:48 回复(0)

内推荐秒回

如果minimumCapacity（新添加的数据长度和已有数据长度的和）小于当前容量Capacity，则添加数据后容量Capacity不变；如果minimumCapacity（新添加的数据长度和已有数据长度的和）大于当前容量Capacity，但minimumCapacity**小于**当前容量Capacity的2倍加2，则添加数据后容量Capacity变为上次容量的2倍加2；如果minimumCapacity（新添加的数据长度和已有数据长度的和）大于当前容量Capacity的2倍加2，则添加数据后容量Capacity即为minimumCapacity（新添加的数据长度和已有数据长度的和）。初始值原容量 < 总内容 <= 2 * 原容量 + 2 总内容 > 2 * 原容量 + 2 16 2 * 原容量 + 2 内容总长度

发表于 2020-04-05 20:52:22 回复(0)

Buffoon丶果

length始终返回当前长度；

capacity返回初始化的长度，若append后的字符串长度超过初始化长度，则capacity返回增长后的长度

发表于 2019-02-22 10:16:33 回复(0)

荒漠

capacity n. 能力；容量；资格，地位；生产力

看到这个应该就知道怎么选了

发表于 2018-12-08 18:39:34 回复(0)

NoFunkTalk

StringBuffer s1=new StringBuffer(10);//初始化容量为10（默认为16） s1.append(“1234”)//添加字符串1234，长度不超过初始化容量，length为4，capacity为10

发表于 2018-08-08 21:36:19 回复(0)

༺既༒合༻

length

public int length()

返回长度（字符数）。指定者： 接口CharSequence中的length返回：此对象表示的当前字符序列的长度。

capacity

public int capacity()

返回当前容量。容量指可用于最新插入的字符的存储量，超过这一容量就需要再次进行分配。返回： 当前容量。

发表于 2018-05-03 21:35:44 回复(0)

kesen

StringBuffer (int capacity)

构造一个不带字符，但具有指定初始容量的字符串缓冲区。
则：
StringBuffer s1=new StringBuffer(10);
capacity为10。

length

public int length()

返回长度（字符数）。

指定者： 接口CharSequence中的length返回：此对象表示的当前字符序列的长度。

capacity

public int capacity()

返回当前容量。容量指可用于最新插入的字符的存储量，超过这一容量就需要再次进行分配。

返回： 当前容量。

s1.append(“1234”) ；
可知： s1.length(); 为4
s1. capacity() ; 为10

发表于 2017-06-15 15:12:37 回复(0)

6qianyu

首先要明确扩容的规则，如果一个StringBuffer的初始容量不够用了需要扩容，

最小需要扩到的容量为当前字符串长度加上附加串长度，也就是下面的minimumCapacity

然后跑一个例子来理解

只有当newCapacity不够的时候，newCapacity才会变成旧串加新串的长度，否则capacity是（2*旧串长度）+2。

就这样。

发表于 2016-11-09 11:14:09 回复(0)

牛客159296号whx

发表于 2016-09-19 10:01:37 回复(0)

提交观点

问题信息

Java

上传者：小小

难度：

74条回答 4786收藏 10938浏览

定义有StringBuffer s1=new StringB

length

capacity

length

capacity

问题信息

热门推荐

相关试题