StringBuilder agrega null como "null"

Esa es la forma como es. null se agrega como "null" . Del mismo modo, cuando imprime null con System.out.println(null) se imprime "null" .

La forma de evitar que sea el método que devuelve la cadena getString() comprueba si null :

 public String getString() { ... if (result == null) { return ""; } } 

 How come? 

Está claramente escrito en documentos

Los caracteres del argumento String se añaden, en orden, aumentando la longitud de esta secuencia por la longitud del argumento. Si str es nulo, se añaden los cuatro caracteres "null".

Así que ponga un cheque nulo antes de añadir.

Se comporta así, porque null no es una String vacía como piensas en ella. Empty String sería new String(""); . Básicamente el método append() agrega "null" si obtiene valor null como parámetro.

EDITAR
Mi respuesta anterior no reflejaba la razón apropiada para tal comportamiento de StringBuilder como fue solicitado por OP. Gracias a @Stephen C por señalar que

Espero que la adición de una cadena nula no agregará en absoluto!

Pero está agregando. La razón de este comportamiento de StringBuilder se oculta en el detalle de implementación del método append(Object obj) que nos lleva al método AbstractStringBuilder#append(String str) que se define de la siguiente manera:

 public AbstractStringBuilder append(String str) { if (str == null) str = "null"; -->(1) //....... return this; } 

Se especifica claramente que si la String entrada es nula, entonces se cambia a String literal "null" y luego procesa más.

¿Cómo puedo obtener StringBuilder.append () para aceptar, de una manera elegante, una cadena nula, y no convertirlo a la cadena literal "null".

Necesita comprobar la String dada para null explícita y luego continuar. Por ejemplo:

 String s = getString(); StringBuffer buf = new StringBuffer(); //Suppose you want "Hello "<value of s>" world" buf.append("Hello "); buf.append(s==null?" world" : s+" world"); 

AbstractStringBuilder clase AbstractStringBuilder agrega un objeto a través del String.valueOf(obj) que a su vez convierte NULL en cadena literal "null". Por lo tanto no hay un método intrínseco para ayudarlo aquí. Tienes que usar el operador ternario dentro del método append o escribir un método de utilidad para manejarlo, como otros sugieren.

Esto funcionará para usted

 public static String getString(StringBuilder sb, String str) { return sb.append(str == null ? "" : str).toString(); } 

¿Qué hay de escribir un método de utilidad como

 public static void appendString(StringBuilder sb, String st) { sb.append(st == null ? "" : st); } 

O esto el operador ternario es muy práctico.

 String nullString = null; StringBuilder sb = new StringBuilder(); sb.append("Hello"); if (nullString != null) sb.append(nullString); sb.append(" World!"); Log.d("Test", sb.toString()); 

¡Ahí! Lo hice en una línea 🙂

¿Una línea?

 sb.append((getString()!=null)?getString():""); 

hecho. Pero es inútil como tener que llamar a getString() dos veces

Como se sugirió construir comprobar en el método getString()

También puede escribir decorador para StringBuilder, que puede comprobar lo que quiera:

 class NotNullStringBuilderDecorator { private StringBuilder builder; public NotNullStringBuilderDecorator() { this.builder = new StringBuilder(); } public NotNullStringBuilderDecorator append(CharSequence charSequence) { if (charSequence != null) { builder.append(charSequence); } return this; } public NotNullStringBuilderDecorator append(char c) { builder.append(c); return this; } //Other methods if you want @Override public String toString() { return builder.toString(); } } 

Ejemplo de uso:

 NotNullStringBuilderDecorator sb = new NotNullStringBuilderDecorator(); sb.append("Hello"); sb.append((String) null); sb.append(" World!"); System.out.println(sb.toString()); 

Con esta solución no tienes que cambiar las clases POJO.