Comportamiento de la declaración de devolución en catch y finalmente

Question

public class J { 

    public Integer method(Integer x) 
     { 
      Integer val = x; 
      try 
      { 

        return val; 
      } 
      finally 
      { 
        val = x + x; 
      } 
     } 
     public static void main(String[] args) 
     { 
      J littleFuzzy = new J(); 
      System.out.println(littleFuzzy.method(new Integer(10))); 
     } 

} 

Devolverá "10".

Ahora solo reemplazo el Tipo de Retorno Integer a StringBuilder y la Salida ha cambiado.

public class I { 

    public StringBuilder method(StringBuilder x) 
     { 
      StringBuilder val = x; 
      try 
      { 

        return val; 
      } 
      finally 
      { 
        val = x.append("aaa"); 
      } 
     } 
     public static void main(String[] args) 
     { 
      I littleFuzzy = new I(); 
      System.out.println(littleFuzzy.method(new StringBuilder("abc"))); 
     } 


} 

salida es "abcaaa"

Por lo tanto, cualquiera puede explicarme en detalle.? ¿Cuáles son las diferencias?

Answer 1

Sólo porque número entero en immutable así que después de método devuelve incluso si se cambia el valor en el método que no refleja, y refleja en StringBuilder Objeto

EDIT:

public class J { 
    public String method(String x) { 
     String val = x; 
     try { 
      return val; 
     } finally { 
      val = x + x; 
     } 
    } 

    public static void main(String[] args) { 
     J littleFuzzy = new J(); 
     System.out.println(littleFuzzy.method("abc")); 
    } 
} 

Answer 2

Las principales operaciones en un StringBuilder son los métodos de agregar e insertar, que están sobrecargados para aceptar datos de cualquier tipo. Cada uno efectivamente convierte un dato dado en una cadena y luego agrega o inserta los caracteres de esa cadena al generador de cadenas. El método de agregar siempre agrega estos caracteres al final del constructor; el método de inserción agrega los caracteres en un punto específico.

Por ejemplo, si z se refiere a un objeto generador de cadenas cuyo contenido actual es "inicio", entonces el método llamado z.append ("le") provocará que el generador de cadenas contenga "startle", mientras que z.insert (4, "le") alteraría el generador de cadenas para que contenga "estrella".

En general, si sb se refiere a una instancia de un StringBuilder, entonces sb.append (x) tiene el mismo efecto que sb.insert (sb.length(), x). Cada generador de cadenas tiene una capacidad. Siempre que la longitud de la secuencia de caracteres contenida en el generador de cadenas no exceda la capacidad, no es necesario asignar un nuevo búfer interno. Si el buffer interno se desborda, se hace automáticamente más grande.

Las instancias de StringBuilder no son seguras para el uso de varios subprocesos. Si se requiere dicha sincronización, se recomienda utilizar StringBuffer.

En el método anterior, finalmente el bloque está llamando cada vez.

Answer 3

Cuando un objeto se pasa, se pasa la copia de su referencia y puede cambiar el contenido si es mutable.