Método StringBuilder append() en Java con ejemplos

Posted on by Rudeus Greyrat

El método java.lang.StringBuilder.append() se usa para agregar la representación de string de algún argumento a la secuencia. Hay 13 formas/formas en las que el método append() se puede usar pasando varios tipos de argumentos:

  1. StringBuilder append ( boolean a ): Java.lang.StringBuilder.append ( boolean a ) es un método incorporado en Java que se usa para agregar la representación de string del argumento booleano a una secuencia dada.

    Sintaxis:

    public StringBuilder append(boolean a)

    Parámetro: este método acepta un solo parámetro a de tipo booleano y se refiere al valor booleano que se agregará.

    Valor devuelto: el método devuelve una referencia a este objeto.

    Ejemplos:

    Input: 
string_buffer = "We are Indians" 
boolean a = true

Output: We are Indians true

    El siguiente programa ilustra el método java.lang.StringBuilder.append():

    // Java program to illustrate the
    // StringBuilder append(boolean a)
    import java.lang.*;
      
    public class Geeks {
      
        public static void main(String[] args)
        {
      
            StringBuilder sb1 = new 
                          StringBuilder("Welcome to Geeksforgeeks ");
            System.out.println("Input: " + sb1);
      
            // Appending the boolean value
            sb1.append(true);
            System.out.println("Output: " + sb1);
      
            System.out.println();
      
            StringBuilder sb2 = new StringBuilder("We fail- ");
            System.out.println("Input: " + sb2);
      
            // Appending the boolean value
            sb2.append(false);
            System.out.println("Output: " + sb2);
        }
    }
    Producción:

    Input: Welcome to Geeksforgeeks 
Output: Welcome to Geeksforgeeks true

Input: We fail- 
Output: We fail- false
  2. java.lang.StringBuilder.append( char a ): este es un método incorporado en Java que se usa para agregar la representación de string del argumento char a la secuencia dada. El argumento char se agrega al contenido de esta secuencia de StringBuilder.

    Sintaxis:

    public StringBuilder append(char a)

    Parámetro: el método acepta un solo parámetro a que es el valor Char cuya representación de string se agregará.

    Valor de retorno: el método devuelve un objeto de string después de realizar la operación de agregar.
    Ejemplos:

    Input :
StringBuilder = I love my Country 
char a = A

Output: I love my Country A

    Los siguientes programas ilustran el método java.lang.StringBuilder.append(char a).

    // Java program to illustrate the
    // java.lang.StringBuilder.append(char a)
    import java.lang.*;
      
    public class Geeks {
      
        public static void main(String[] args)
        {
              
            StringBuilder sbf = new 
                           StringBuilder("Welcome geeks!");
                    System.out.println( sbf);
      
            /* Here it appends the char argument as
            string to the StringBuilder */
            sbf.append('T');
            System.out.println("Result after"+
                                     " appending = " + sbf);
      
          
            sbf = new StringBuilder("hello world-");
                    System.out.println(sbf);
            /* Here it appends the char argument as
            string to the String Builder */
            sbf.append('#');
            System.out.println("Result after appending = " 
                                                             + sbf);
        }
    }
    Producción:

    Welcome geeks!
Result after appending = Welcome geeks!T
hello world-
Result after appending = hello world-#
  3. StringBuilder append( char[] astr ): java.lang.StringBuilder.append( char[] astr ) es el método incorporado que agrega la representación de string del argumento de la array char a esta secuencia de StringBuilder.

    Sintaxis:

    public StringBuilder append(char[] astr)

    Parámetro: el método acepta un solo parámetro astr que es la secuencia Char cuya representación de string se agregará.

    Valor de retorno: el método devuelve un objeto de string después de realizar la operación de agregar.
    Ejemplos:

    Input :
StringBuffer  = I love my Country   
char[] astr = 'I', 'N', 'D', 'I', 'A'

Output: I love my Country INDIA

    El siguiente programa ilustra el método java.lang.StringBuilder.append( char[] astr ):

    // Java program to illustrate the
    // java.lang.StringBuilder.append(<em>char[] astr</em>)
    import java.lang.*;
      
    public class Geeks {
      
        public static void main(String[] args)
        {
      
              
            StringBuilder sbf = new 
                          StringBuilder("We are geeks  ");
            System.out.println(sbf);
      
            // Char array
            char[] astr = new char[] 
                              { 'G', 'E', 'E', 'k', 'S' };
      
            /* Appends string representation of char
                       array to this String Builder */
            sbf.append(astr);
        System.out.println("Result after"+
                                " appending = " + sbf);
              
            sbf = new StringBuilder("We are  -");
                    System.out.println(sbf);
      
            // Char array
            astr = new char[] { 'a', 'b', 'c', 'd' };
      
            /* Appends string representation of char 
                       array to this StringBuilder */
            sbf.append(astr);
            System.out.println("Result after appending = " + sbf);
        }
    }
    Producción:

    We are geeks  
Result after appending = We are geeks  GEEkS
We are  -
Result after appending = We are  -abcd
  4. StringBuilder append( char[] cstr, int iset, int ilength ) : este método agrega la representación de string de un subarreglo del argumento del arreglo char a esta secuencia. Los caracteres de la array char cstr, comenzando en el índice iset, se agregan, en orden, al contenido de esta secuencia. La longitud de esta secuencia aumenta por el valor de ilength.

    Sintaxis:

    public StringBuilder append(char[] cstr, int iset, int ilenght)

    Parámetro: este método acepta tres parámetros:

    • cstr : se refiere a la secuencia Char.
    • iset : se refiere al índice del primer carácter que se agrega.
    • ilenght : se refiere a la cantidad de caracteres que se agregarán.

    Valor de retorno: el método devuelve un objeto de string después de realizar la operación de agregar.
    El siguiente programa ilustra el método java.lang.StringBuilder.append(char[] cstr, int iset, int ilength).

    // Java program to illustrate the
    // append(char[] cstr, int iset, int ilength)
    import java.lang.*;
      
    public class Geeks {
      
        public static void main(String[] args)
        {
      
            StringBuilder sb = new 
                                  StringBuilder("Geeks");
            System.out.println("String Builder "+
                                       "before = " + sb);
      
            char[] cstr = new char[] 
              { 'f', 'o', 'r', 'G', 'e', 'e', 'k', 's','q','q' };
      
            /* appends the string representation of char array 
               argument to this String Builder with offset initially 
               at index 0 and length as 8 */
            sb.append(cstr, 0, 8);
      
            // Print the String Builder after appending
            System.out.println("After appending String Builder = " + sb);
        }
    }
    Producción:

    String Builder before = Geeks
After appending String Builder = GeeksforGeeks
  5. StringBuilder append ( doble a ): este método simplemente agrega la representación de string del argumento doble a esta secuencia de StringBuilder.

    Sintaxis:

    public StringBuilder append(double val)

    Parámetro: el método acepta un solo parámetro val que se refiere al valor decimal cuya representación de string se agregará.

    Valor de retorno: el método devuelve un objeto de string después de realizar la operación de agregar.
    Ejemplos:

    Input :
StringBuffer = my Country
Double a = 54.82

Output: my Country 54.82

    El siguiente programa ilustra el método java.lang.StringBuilder.append(double val).

    // Java program to illustrate the
    // java.lang.StringBuilder.append()
    import java.lang.*;
      
    public class Geeks {
      
        public static void main(String[] args)
        {
      
            System.out.println("We are geeks and its really ");
            StringBuilder sbf = new 
                  StringBuilder("We are geeks and its ");
      
            // Char array
            Double astr = new Double(36.47);
      
            /* Here it appends string representation of Double 
               argument to this StringBuilder*/
            sbf.append(astr);
            System.out.println("Result after appending = " + sbf);
      
            System.out.println("We are lost -");
            sbf = new StringBuilder("We are lost -");
      
            astr = new Double(27.38);
      
            /* Here it appends string representation of Double  
               argument to this StringBuilder*/
            sbf.append(astr);
            System.out.println("Result after appending = " + sbf);
        }
    }
    Producción:

    We are geeks and its really 
Result after appending = We are geeks and its 36.47
We are lost -
Result after appending = We are lost -27.38
  6. StringBuilder append( float val ): este método agrega la representación de string del argumento flotante a esta secuencia.

    Sintaxis:

    public StringBuilder append(float val)

    Parámetro: el método acepta un solo parámetro val , que es el valor flotante cuya representación de string se agregará.

    Valor devuelto: el método StringBuilder.append( float val ) devuelve una referencia al objeto de string después de realizar la operación.

    Ejemplos:

    Input : 
StringBuilder  = I love my Country 
float a = 5.2
 
Output: I love my Country 5.2

    El siguiente programa ilustra el método java.lang.StringBuilder.append().

    // Java program to illustrate the
    // java.lang.StringBuilder.append()
    import java.lang.*;
      
    public class Geeks {
      
        public static void main(String[] args)
        {
      
            System.out.println("We are geeks and its really ");
            StringBuilder sbf = new 
                        StringBuilder("We are geeks and its ");
      
            Float astr = new Float(6.47);
      
            /* Here it appends string representation of 
               Float argument to this StringBuilder */
            sbf.append(astr);
            System.out.println("Result after appending = "+sbf);
      
            System.out.println("We are lost -");
            sbf = new StringBuilder("We are lost -");
      
            astr = new Float(27.38);
      
            // Here it appends string representation of Float
            // argument to this String Builder
            sbf.append(astr);
            System.out.println("Result after appending = "+sbf);
        }
    }
    Producción:

    We are geeks and its really 
Result after appending = We are geeks and its 6.47
We are lost -
Result after appending = We are lost -27.38
  7. StringBuilder append( int val ) Este método simplemente agrega la representación de string del argumento int a esta secuencia de StringBuilder.
    Sintaxis: 
    public StringBuilder append(int val)

    Parámetro: el método acepta un único parámetro val , que es un valor entero sobre el que se supone que debe realizarse la operación.

    Valor devuelto: el método devuelve una referencia a este objeto.

    Ejemplos:

    Input :
StringBuilder = I love my Country  
int a = 55

Output: I love my Country 55

    El siguiente programa ilustra el método java.lang.StringBuilder.append().

    // Java program to illustrate the
    // java.lang.StringBuilder.append()
    import java.lang.*;
      
    public class Geeks {
      
        public static void main(String[] args)
        {
      
            System.out.println("We are geeks and its really ");
            StringBuilder sbf = new 
                        StringBuilder("We are geeks and its ");
      
            Integer astr = new Integer(827);
      
            /* Here it appends string representation of 
               Integer argument to this StringBuilder*/
            sbf.append(astr);
            System.out.println("Result after appending = "+sbf);
      
            System.out.println("We are lost -");
            sbf = new StringBuilder("We are lost -");
      
            astr = new Integer(515);
      
            // Here it appends string representation of Integer
            // argument to this StringBuilder
            sbf.append(astr);
            System.out.println("Result after appending = "+sbf);
        }
    }
    Producción:

    We are geeks and its really 
Result after appending = We are geeks and its 827
We are lost -
Result after appending = We are lost -515
  8. StringBuilder append (Valor largo ): este método simplemente agrega la representación de string del argumento largo a esta secuencia de StringBuilder.

    Sintaxis:

    public StringBuilder append(Long val)

    Parámetro: El método acepta un solo parámetro val que es el valor largo.

    Valor de retorno: el método devuelve un objeto de string después de realizar la operación de agregar.
    Ejemplos:

    Input :
StringBuilder  = I love my Country
Long a = 591995

Output: I love my Country 591995

    El siguiente programa ilustra el método java.lang.StringBuilder.append().

    // Java program to illustrate the
    // java.lang.StringBuilder.append()
    import java.lang.*;
      
    public class Geeks {
      
        public static void main(String[] args)
        {
      
            System.out.println("We are geeks and its really ");
            StringBuilder sbf = new 
                        StringBuilder("We are geeks and its ");
      
            Long astr = new Long(827);
      
            /* Here it appends string representation of 
               Long argument to this StringBuilder*/
            sbf.append(astr);
            System.out.println("Result after appending = "+sbf);
      
            System.out.println("We are lost -");
            sbf = new StringBuilder("We are lost -");
      
            astr = new Long(515);
      
            /* Here it appends string representation of Long 
               argument to this StringBuilder*/
            sbf.append(astr);
            System.out.println("Result after appending = "+sbf);
        }
    }
    Producción:

    We are geeks and its really 
Result after appending = We are geeks and its 827
We are lost -
Result after appending = We are lost -515
  9. StringBuilder append ( CharSequence a ): este método se usa para agregar la CharSequence especificada a esta secuencia.

    Sintaxis:

    public StringBuilder append(CharSequence a)

    Parámetro: el método acepta un solo parámetro a que es el valor de CharSequence.

    Valor de retorno: el método devuelve un objeto de string después de realizar la operación de agregar.

    Ejemplos:

    Input :
StringBuilder  = "I love my Country" 
CharSequence a = " India"

Output : I love my Country India

    El siguiente programa ilustra el método java.lang.StringBuilder.append().

    // Java program to illustrate the
    // java.lang.StringBuilder.append()
    import java.lang.*;
      
    public class Geeks {
      
        public static void main(String[] args)
        {
      
            StringBuilder sbf = new StringBuilder("Geeksfor");
            System.out.println("String Builder = " + sbf);
      
            CharSequence chSeq = "geeks";
      
            // Appends the CharSequence
            sbf.append(chSeq);
      
            // Print the String Builder after appending
            System.out.println("After append = " + sbf);
        }
    }
    Producción:

    String Builder = Geeksfor
After append = Geeksforgeeks
  10. StringBuilder append ( CharSequence chseq, int start, int end ): este método se usa para agregar una subsecuencia de la CharSequence especificada a este StringBuilder.

    Sintaxis:

    StringBuilder append(CharSequence chseq, int start, int end)

    Parámetro: El método acepta tres parámetros:

    • chseq (CharSequence): Esto se refiere al valor de CharSequence.
    • inicio (Entero): Esto se refiere al índice de inicio de la subsecuencia que se agregará.
    • end (Integer): Esto se refiere al índice final de la subsecuencia que se agregará.

    Valor de retorno: el método devuelve la string después de realizar la operación de agregar.

    Ejemplos:

    Input :
StringBuilder = Geeksforgeeks
CharSequence chseq = abcd1234
int start = 2
int end = 7

Output :Geeksforgeekscd123

    El siguiente programa ilustra el método java.lang.StringBuilder.append():

    // Java program to illustrate the
    // java.lang.StringBuilder.append()
      
    import java.lang.*;
      
    public class Geeks {
      
        public static void main(String[] args)
        {
      
            StringBuilder sbf = new 
                  StringBuilder("We are the ");
            System.out.println("String builder= "
                                          + sbf);
      
            CharSequence chSeq = "wegeekss";
      
            /* It appends the CharSequence with  
               start index 2 and end index 4 */
            sbf.append(chSeq, 2, 7);
      
            System.out.println("After append string"+
                                 " buffer = " + sbf);
        }
    }
    Producción:

    String builder= We are the 
After append string buffer = We are the geeks
  11. StringBuilder append( Object obj ): este método se usa para agregar la representación de string del argumento Object al StringBuilder.

    Sintaxis:

    StringBuilder append(Object obj)

    Parámetro: el método acepta un solo parámetro obj que se refiere al objeto que se necesita agregar.

    Valor de retorno: el método devuelve la string después de realizar la operación de agregar.

    El siguiente programa ilustra el método java.lang.StringBuilder.append().

    // Java program to illustrate the
    // java.lang.StringBuilder.append()
      
    import java.lang.*;
      
    public class Geeks {
      
        public static void main(String[] args)
        {
      
            StringBuilder sbf = new StringBuilder("Geeksfor");
            System.out.println("String Builder = " + sbf);
      
            Object objectvalue = "geeks";
      
            // Here it appends the Object value
            sbf.append(objectvalue);
      
            System.out.println("After appending result is = "+sbf);
        }
    }
    Producción:

    String Builder = Geeksfor
After appending result is = Geeksforgeeks
  12. StringBuilder append ( String istr ): este método se usa para agregar la string especificada a este StringBuilder.
    Sintaxis: 
    StringBuilder append(String istr)

    Parámetro: El método acepta un solo parámetro istr de tipo String que se refiere al valor que se agregará.

    Valor devuelto: el método devuelve una string especificada a esta secuencia de caracteres.
    El siguiente programa ilustra el método java.lang.StringBuilder.append().

    // Java program to illustrate the
    // java.lang.StringBuilder.append()
      
    import java.lang.*;
      
    public class Geeks {
      
        public static void main(String[] args)
        {
      
            StringBuilder sbf = new StringBuilder("Geeksfor");
            System.out.println("String Builder = " + sbf);
      
            String strvalue = "geeks";
      
            // Here it appends the Object value
            sbf.append(strvalue);
      
            System.out.println("After appending result is = "+sbf);
        }
    }
    Producción:

    String Builder = Geeksfor
After appending result is = Geeksforgeeks
  13. StringBuilder append ( StringBuilder sbf ): este método se usa para agregar el StringBuilder especificado a esta secuencia o StringBuilder.

    Sintaxis:

    public StringBuilder append(StringBuilder sbf)

    Parámetro: El método acepta un solo parámetro sbf se refiere al StringBuilder para agregar.

    Valor devuelto: el método devuelve StringBuilder a esta secuencia.
    El siguiente programa ilustra el método java.lang.StringBuilder.append().

    // Java program to illustrate the
    // java.lang.StringBuilder.append()
      
    import java.lang.*;
      
    public class Geeks {
      
        public static void main(String[] args)
        {
      
            StringBuilder sbf1 = new StringBuilder("Geeks");
            System.out.println("String Builder 1 = " + sbf1);
      
            StringBuilder sbf2 = new StringBuilder("forgeeks ");
            System.out.println("String Builder 2 = " + sbf2);
      
            // Here it appends String Builder2 to String Builder1
            sbf1.append(sbf2);
      
            System.out.println("After appending the result is = "+sbf1);
        }
    }
    Producción:

    String Builder 1 = Geeks
String Builder 2 = forgeeks 
After appending the result is = Geeksforgeeks

Publicación traducida automáticamente

Artículo escrito por ankita_chowrasia y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *