Where did the 'M' go? [duplicate]

Answer 1

There is no StringBuffer constructor that accepts a char. What happens here is that Java has made a widening primitive conversion to transform the char into an int and then a StringBuffer with initial capacity of 77 was created.

But, there is a constructor that accepts a String and you can use it to solve your problem:

StringBuffer buffer = new StringBuffer("M");

Anyway, it is also recommended that you use StringBuilder, which is designed to be faster drop-in replacement for StringBuffer in places where the string buffer was being used by a single thread.

Answer 2

Apart from the break problem, the main problem here is how you initialize your StringBuffer.

There is no constructor accepting a char as an argument, but there is one accepting an int for the capacity.

And that is the one you use...

You should do:

word = new StringBuilder(); // not StringBuffer
// switch. Then:
word.append("ain");

(also note the use of StringBuilder instead of StringBuffer; the latter is useful only in the rare case where thread-safety is required)

Answer 3

It used StringBuffer's int constructor which sets the initial buffer's capacity.

Why did it use the int constructor? It has to do with Widening Primitive Conversion.

Answer 4

The issue with your code is pretty simple:
new StringBuffer('M') doesn't do what you think it does. There exists no constructor for StringBuffer that expects a char. Instead this constructor is called: StringBuffer(int capacity), with char being implicitly converted to int.

So basically your code doesn't create a new StringBuffer containing a single character, but a StringBuffer with the capacity matching the given character.

But there are aswell some other issues, like missing break at the end of each case, so after the switch-statement, word will always be new StringBuffer('M');

The reason why this compiles is primitive widening conversion. Basically any integral data-type can be converted into another integral data-type, as long as the conversion is loss-less. Here are some links for further reading:
StringBuffer docs
Primitive Widening - JLS