StringBuffer doubt

[Rameshwar Soni]

I was reading about StringBuffer class and i came to know that the default capacity when using the constructor with no parameters is 16. i.e.

StringBuffer s=new StringBuffer();

Capacity of s is 16 characters. But when we add the 17th character then the capacity increases by (2 * previous capacity + 2) i.e. (2 * 16 + 2)=34. Therefore after adding the 17th character the capacity is 34.
Similarly when 35th character is added the capacity would be (2 * 34 + 2)=70.
But when i tried the below code i got the results for object sb1 correct but why not for object sb2.

class Demo_StringBuffer
{
    public static void main(String[] args)
    {
        StringBuffer sb1=new StringBuffer();
        System.out.println("Initial capacity of sb1 is " + sb1.capacity());    // capacity 16-fine
        sb1.insert(0,"123456789_1234567");    // 17 characters added
        System.out.println("After adding 17 characters capacity of sb1 is " + sb1.capacity());  // capacity 34-fine
        sb1.insert(0,"123456789_123456789_123456789_12345");   // 35 Characters added 
        System.out.println("After adding 35 characters capacity of sb1 is " + sb1.capacity());  // capacity 70-fine
        System.out.println("-------------------------------------------------------------------------------");
        StringBuffer sb2=new StringBuffer();
        System.out.println("Initial capacity of sb2 is " + sb2.capacity());    // capacity 16-fine
        sb2.insert(0,"123456789_123456789_123456789_12345");      // 35 Characters added
        System.out.println("After adding 35 characters capacity of sb2 is " + sb2.capacity());    // capacity 35-HOW?
    }
}
        

Thanks in advance.

[Raymond Tong]

You may have missed part of the code which I have attached below

    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);
    }

If needed capacity (minimumCapacity) > calculated new capacity (newCapacity),
it would set the final new capacity to minimumCapacity.

i.e. 35 > 34, set the capacity to 35

[Chiranjeevi Kanthraj]

Hi Rameshwar

i think the capacity calculation is diffrent when i saw the code for AbstractStringBuilder the Capcity will be calculated like this

 
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);
    }

Where insert or any append code call this method

	int len = str.length();
	int newCount = count + len;
	if (newCount > value.length)
	    expandCapacity(newCount);

where str is 35chars, so len = 35
and count =0, newcount =35
when call expandCapacity(35)
newCapacity = (0+1)*2 = 2
35>2
newCapacity =35

value.length = 35

public synchronized int capacity() {
	return value.length;
    }

I think this will solve our doudt

[Rameshwar Soni]

Thanks Raymond and Chiranjeevi for your replies. But i haven't yet understood, sorry i am not that good in Java.

Chiranjeevi Kanthraj wrote:

i think the capacity calculation is diffrent when i saw the code for AbstractStringBuilder the Capcity will be calculated like this

AbstractStringBuilder ? But it was StringBuffer.

Chiranjeevi Kanthraj wrote:

 
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);
    }

What is value.length ?

Chiranjeevi Kanthraj wrote:
Where insert or any append code call this method

	int len = str.length();
	int newCount = count + len;
	if (newCount > value.length)
	    expandCapacity(newCount);

where str is 35chars, so len = 35
and count =0, newcount =35
when call expandCapacity(35)
newCapacity = (0+1)*2 = 2
35>2
newCapacity =35

value.length = 35

[code=java]

How count=0 ?

[Chiranjeevi Kanthraj]

AbstractStringBuilder ? But it was StringBuffer.

AbstractStringBuilder is the super class of the StringBuffer

What is value.length ?

value is the char[] which holds the chars of the StringBuffer

How count=0

if you see the insert method implementation you will come to know. count is the inital length of the value.

[Rameshwar Soni]

Thanks for your reply. But when i did the calculation using the method which you gave, sometimes the calculation comes right and sometimes not.
For the below code the calculation is incorrect

StringBuffer sb1=new StringBuffer();  
        System.out.println("Initial capacity of sb1 is " + sb1.capacity());    // capacity 16-fine  
        sb1.insert(0,"123456789_1234567");    // 17 characters added  
        System.out.println("After adding 17 characters capacity of sb1 is " + sb1.capacity());  // capacity 34-fine  
        sb1.insert(0,"123456789_123456789_123456789_12345");   // 35 Characters added   
        System.out.println("After adding 35 characters capacity of sb1 is " + sb1.capacity());  // capacity 70-fine 

Here you can see after adding 35 characters the capacity is 70
Whereas for the below code

StringBuffer sb2=new StringBuffer();  
        System.out.println("Initial capacity of sb2 is " + sb2.capacity());    // capacity 16-fine  
        sb2.insert(0,"123456789_123456789_123456789_12345");      // 35 Characters added  
        System.out.println("After adding 35 characters capacity of sb2 is " + sb2.capacity());    // capacity 35-HOW?

Here after 35 characters the capacity is 35 which is correct according to your method.
Why that difference?

[Chiranjeevi Kanthraj]

Sorry for the last reply count is not length of the value means not 0, its 17 or length of the String which we inserting

 public AbstractStringBuilder insert(int offset, String str) {
	if ((offset < 0) || (offset > length()))
	    throw new StringIndexOutOfBoundsException(offset);
	if (str == null)
	    str = "null";
	[b]int len = str.length();[/b]	
                int newCount = count + len;
	if (newCount > value.length)
	    expandCapacity(newCount);
	System.arraycopy(value, offset, value, offset + len, count - offset);
	str.getChars(value, offset);
	count = newCount;
	return this;
    }

[Raymond Tong]

To simplify the logic in few words,
when doubling the current size (+2) is enough for storage, expand it with this size.
Otherwise, add the size with the additional String's length.

[Rameshwar Soni]

I think its getting really though for ME. I am not getting my calculation correctly.
My question is Why capacity is 70 when 35 characters were added

StringBuffer sb1=new StringBuffer();  
        System.out.println("Initial capacity of sb1 is " + sb1.capacity());    // capacity 16-fine  
        sb1.insert(0,"123456789_1234567");    // 17 characters added  
        System.out.println("After adding 17 characters capacity of sb1 is " + sb1.capacity());  // capacity 34-fine  
        sb1.insert(0,"123456789_123456789_123456789_12345");   // 35 Characters added   
        System.out.println("After adding 35 characters capacity of sb1 is " + sb1.capacity());  // capacity 70-fine 

Why capacity is 35 when 35 characters were added

StringBuffer sb2=new StringBuffer();  
        System.out.println("Initial capacity of sb2 is " + sb2.capacity());    // capacity 16-fine  
        sb2.insert(0,"123456789_123456789_123456789_12345");      // 35 Characters added  
        System.out.println("After adding 35 characters capacity of sb2 is " + sb2.capacity());    // capacity 35-HOW?

[Rameshwar Soni]

Raymond Tong wrote:
when doubling the current size (+2) is enough for storage, expand it with this size.

How would we know that ? I mean to say 35 characters could be easily stored in an capacity of 35 or its double 70. ??

[Raymond Tong]

Rameshwar Soni wrote:

    public static void main(String[] args)
    {
        StringBuffer sb1=new StringBuffer();
        System.out.println("Initial capacity of sb1 is " + sb1.capacity());    // capacity 16-fine
        sb1.insert(0,"123456789_1234567");    // 17 characters added
/** original capacity = 16, new String's length = 17. 
Calculated Capacity (16*2+2 = 34) > 17. New Capacity = 34 **/
        System.out.println("After adding 17 characters capacity of sb1 is " + sb1.capacity());  // capacity 34-fine
        sb1.insert(0,"123456789_123456789_123456789_12345");   // 35 Characters added 
/** original capacity = 34, new String's length = 35. 
Calculated Capacity (34*2+2 = 70) > 35. New Capacity = 70 **/
        System.out.println("After adding 35 characters capacity of sb1 is " + sb1.capacity());  // capacity 70-fine
        System.out.println("-------------------------------------------------------------------------------");
        StringBuffer sb2=new StringBuffer();
        System.out.println("Initial capacity of sb2 is " + sb2.capacity());    // capacity 16-fine
        sb2.insert(0,"123456789_123456789_123456789_12345");      // 35 Characters added
/** original capacity = 16, new String's length = 35. 
Calculated Capacity (16*2+2 = 34) < 35. New Capacity = 35 **/
        System.out.println("After adding 35 characters capacity of sb2 is " + sb2.capacity());    // capacity 35-HOW?
    }
}

See the comment above.

[Rameshwar Soni]

Hi Raymond, thanks for your reply. I think you might be getting furious on me because i still have doubt because i tried the below code and applied your way of calculation
and i got wrong answer

class abc
{
	public static void main(String...q)
	{
		StringBuffer s1=new StringBuffer();
		System.out.println("s1=" +s1.capacity());  // 16
		s1.insert(0,"123456789_123456789_123456789_12345");  // 35 characters
		System.out.println("s1=" +s1.capacity());  //35 fine by your formula (16*2 + 2)= 34 and (34< length of string i.e. 35) therefore answer is 35
		s1.insert(0,"123456789_123456789_123456789_12345679_123456789_123456789_123456789_123456789_123456789_"); // 90 characters
		System.out.println("s1=" +s1.capacity());  // (35 * 2 + 2)=72 and (72 < length of string i.e. 90) therefore answer must be 90 but it is 124
		s1.insert(0,"123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_"); // 80 characters
		System.out.println("s1=" +s1.capacity());  // similarly here answer is 250
		
		
			
	
	}
}

i am really sorry.

[Raymond Tong]

Rameshwar Soni wrote:

class abc
{
	public static void main(String...q)
	{
		StringBuffer s1=new StringBuffer();
		System.out.println("s1=" +s1.capacity());  // 16
		s1.insert(0,"123456789_123456789_123456789_12345");  // 35 characters
// NewCapacity=Math.max(  OrgSize+AddSize,  (OrgSize+1)*2   )
// OrgCapacity=16, OrgSize=0, AddSize=35, NewCapacity = max(35,2) = 35
		System.out.println("s1=" +s1.capacity());  //35 fine by your formula (16*2 + 2)= 34 and (34< length of string i.e. 35) therefore answer is 35
		s1.insert(0,"123456789_123456789_123456789_12345679_123456789_123456789_123456789_123456789_123456789_"); // 90 characters (89 not 90)
// OrgCapacity=35, OrgSize=35, AddSize=89, NewCapacity = max(124,72) = 124
		System.out.println("s1=" +s1.capacity());  // (35 * 2 + 2)=72 and (72 < length of string i.e. 90) therefore answer must be 90 but it is 124
		s1.insert(0,"123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_"); // 80 characters
// OrgCapacity=124, OrgSize=124, AddSize=80, NewCapacity = max(204,250) = 250
		System.out.println("s1=" +s1.capacity());  // similarly here answer is 250
	}
}

I didn't make the calculation very clear.
Check the detailed calculation above.

Why would you interested about the logic of StringBuffer?

[Rameshwar Soni]

Thank you very much Raymond Tong for your reply. Your detailed calculation was very helpful.
This calculation was never there in Java documentation, it was your calculation which helped me.

[Campbell Ritchie]

Rameshwar Soni wrote: . . . This calculation was never there in Java documentation, . . .

You don't need that calculation. You only need to know the public interface of a class, not its implementation details. You can easily work out that the largest array possible is 2147483647 code points, but you will probably run out of JVM memory before you get that large.
And why does everybody use StringBuffer when StringBuilder gives better performance? By the way: that last StringBuilder link will give you its default capacity.

[Campbell Ritchie]

Not a "beginning" question. Moving thread.

[Rameshwar Soni]

Campbell Ritchie wrote:You only need to know the public interface of a class, not its implementation details.

What do you mean by that? Can you give an example.

Campbell Ritchie wrote: You can easily work out that the largest array possible is 2147483647 code points, but you will probably run out of JVM memory before you get that large.

Yes that was great, i never knew that. So basically what would be the largest size array that we can make? Does that differ as per the JVM ?
Thanks for your reply.

[fred rosenberger]

Rameshwar Soni wrote:

Campbell Ritchie wrote:You only need to know the public interface of a class, not its implementation details.

What do you mean by that? Can you give an example.

If I get a collection reference, and want the third item in it, all I should need to know is to call:

myObject = myCollection.getItem(3);

I don't need to know if the collection is an array and has direct access to the third item, or if it is a linked list and they jump from node to node to node, or a map and they use the 3 as the key to pull it out.

All I need to know is that I call the getItem, pass it a positive integer, and it returns the item I want.

[Campbell Ritchie]

Rameshwar Soni wrote: . . what would be the largest size array that we can make? Does that differ as per the JVM ? . . .

Try here, and you can see the sort of thing you can try. It probably differs with the amount of memory available, which you can alter with the options for the java tool when you start the JVM.

[Rameshwar Soni]

Thanks fred and campbell

[Campbell Ritchie]

You're welcome