Método StringBuffer append() en Java con ejemplos

Requisito previo: clase StringBuffer en Java
El método java.lang.StringBuffer.append() se usa para agregar la representación de string de algún argumento a la secuencia. Hay 13 formas/formas en las que se puede usar el método append():

StringBuffer append( boolean a ) : java.lang.StringBuffer.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 StringBuffer 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 = "I love my Country" 
boolean a = true

Output: I love my Country true

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

// Java program to illustrate the
// StringBuffer append(boolean a)
import java.lang.*;
  
public class Geeks {
  
    public static void main(String[] args)
    {
  
        StringBuffer sbf1 = new StringBuffer("We are geeks and its really ");
        System.out.println("Input: " + sbf1);
  
        // Appending the boolean value
        sbf1.append(true);
        System.out.println("Output: " + sbf1);
  
        System.out.println();
  
        StringBuffer sbf2 = new StringBuffer("We are lost - ");
        System.out.println("Input: " + sbf2);
  
        // Appending the boolean value
        sbf2.append(false);
        System.out.println("Output: " + sbf2);
    }
}

Producción:

Input: We are geeks and its really 
Output: We are geeks and its really true

Input: We are lost - 
Output: We are lost - false

java.lang.StringBuffer.append( char a ) : este es un método incorporado que agrega la representación de string del argumento char a la secuencia dada. El argumento char se agrega al contenido de esta secuencia StringBuffer.

Sintaxis:

public StringBuffer 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 :
StringBuffer = I love my Country 
char a = A

Output: I love my Country A

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

// Java program to illustrate the
// java.lang.StringBuffer.append(char a)
import java.lang.*;
  
public class Geeks {
  
    public static void main(String[] args)
    {
        System.out.println("We are geeks and its really ");
        StringBuffer sbf = new StringBuffer("We are geeks and its");
  
        /* Here it appends the char argument as
         string to the string buffer */
        sbf.append('M');
        System.out.println("Result after appending = " + sbf);
  
        System.out.println("We are lost -");
        sbf = new StringBuffer("We are lost -");
  
        /* Here it appends the char argument as
         string to the string buffer */
        sbf.append('&');
        System.out.println("Result after appending = " + sbf);
    }
}

Producción:

We are geeks and its really 
Result after appending = We are geeks and itsM
We are lost -
Result after appending = We are lost -&

StringBuffer append( char[] astr ): Java.lang.StringBuffer.append ( char[] astr ) es el método incorporado que agrega la representación de string del argumento de la array de caracteres a esta secuencia de StringBuffer.

Sintaxis:

public StringBuffer 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.StringBuffer.append( char[] astr ):

// Java program to illustrate the
// java.lang.StringBuffer.append(<em>char[] astr</em>)
import java.lang.*;
  
public class Geeks {
  
    public static void main(String[] args)
    {
  
        System.out.println("We are geeks and its really ");
        StringBuffer sbf = new StringBuffer("We are geeks and its ");
  
        // Char array
        char[] astr = new char[] { 'G', 'E', 'E', 'k', 'S' };
  
        /* Here it appends string representation of char array 
        argument to this string buffer */
        sbf.append(astr);
        System.out.println("Result after appending = " + sbf);
  
        System.out.println("We are lost -");
        sbf = new StringBuffer("We are lost -");
  
        // Char array
        astr = new char[] { 'a', 'b', 'c', 'd' };
  
        /* Here it appends string representation of char array argument to
        argument to this string buffer */
        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 GEEkS
We are lost -
Result after appending = We are lost -abcd

StringBuffer 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 StringBuffer 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.StringBuffer.append(char[] cstr, int iset, int ilength).

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

Producción:

String buffer  before = Geeks
After appending string buffer = GeeksforGeeks

StringBuffer append ( doble a ): este método simplemente agrega la representación de string del argumento doble a esta secuencia de StringBuffer.

Sintaxis:

public StringBuffer append(double a)

Parámetro: El método acepta un solo parámetro a que se refiere al valor decimal cuya representación de string se va a 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
Double a = 54.82
Output: I love my Country 54.82

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

// Java program to illustrate the
// java.lang.StringBuffer.append()
import java.lang.*;
  
public class Geeks {
  
    public static void main(String[] args)
    {
  
        System.out.println("We are geeks and its really ");
        StringBuffer sbf = new StringBuffer("We are geeks and its ");
        // char array
        Double astr = new Double(636.47);
  
        /*Here it appends string representation of Double argument to 
         this string buffer*/
        sbf.append(astr);
        System.out.println("Result after appending = " + sbf);
  
        System.out.println("We are lost -");
        sbf = new StringBuffer("We are lost -");
  
        astr = new Double(827.38);
  
        /*Here it appends string representation of Double argument 
         to this string buffer*/
        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 636.47
We are lost -
Result after appending = We are lost -827.38

StringBuffer append( float f ) : este método agrega la representación de string del argumento flotante a esta secuencia.

Sintaxis:

public StringBuffer append(float a)

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

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

Ejemplos:

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

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

// Java program to illustrate the
// java.lang.StringBuffer.append()
import java.lang.*;
  
public class Geeks {
  
    public static void main(String[] args)
    {
  
        System.out.println("We are geeks and its really ");
        StringBuffer sbf = new StringBuffer("We are geeks and its ");
  
        Float astr = new Float(6.47);
  
        /* Here it appends string representation of  Float argument
         to this string buffer */
        sbf.append(astr);
        System.out.println("Result after appending = " + sbf);
  
        System.out.println("We are lost -");
        sbf = new StringBuffer("We are lost -");
  
        astr = new Float(27.38);
  
        // Here it appends string representation of Float
        // argument to this string buffer
        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

StringBuffer append( int i : ) Este método simplemente agrega la representación de string del argumento int a esta secuencia de StringBuffer.
Sintaxis:

public StringBuffer append(int a)

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

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

Ejemplos:

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

Output: I love my Country 55

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

// Java program to illustrate the
// java.lang.StringBuffer.append()
import java.lang.*;
  
public class Geeks {
  
    public static void main(String[] args)
    {
  
        System.out.println("We are geeks and its really ");
        StringBuffer sbf = new StringBuffer("We are geeks and its ");
  
        Integer astr = new Integer(827);
  
        /*Here it appends string representation of  Integer argument to
        argument to this string buffer*/
        sbf.append(astr);
        System.out.println("Result after appending = " + sbf);
  
        System.out.println("We are lost -");
        sbf = new StringBuffer("We are lost -");
  
        astr = new Integer(515);
  
        // Here it appends string representation of Integer
        // argument to this string buffer
        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

StringBuffer append( Long l ) : este método simplemente agrega la representación de string del argumento largo a esta secuencia de StringBuffer.

Sintaxis:

public StringBuffer append(Long a)

Parámetro: el método acepta un único parámetro a, 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 :
StringBuffer  = I love my Country
Long a = 591995

Output: I love my Country 591995

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

// Java program to illustrate the
// java.lang.StringBuffer.append()
import java.lang.*;
  
public class Geeks {
  
    public static void main(String[] args)
    {
  
        System.out.println("We are geeks and its really ");
        StringBuffer sbf = new StringBuffer("We are geeks and its ");
  
        Long astr = new Long(827);
  
        /* Here it appends string representation of  Long argument
         to this string buffer*/
        sbf.append(astr);
        System.out.println("Result after appending = " + sbf);
  
        System.out.println("We are lost -");
        sbf = new StringBuffer("We are lost -");
  
        astr = new Long(515);
  
        /* Here it appends string representation of Long argument
          to this string buffer*/
        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

StringBuffer append ( CharSequence a ): este método se usa para agregar la CharSequence especificada a esta secuencia.

Sintaxis:

public StringBuffer 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 :
StringBuffer  = I love my Country   
CharSequence a =  abcd

Output : I love my Countryabcd

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

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

Producción:

string buffer = Geeksfor
After append = Geeksforgeeks

StringBuffer append( CharSequence chseq, int start, int end ): este método se usa para agregar una subsecuencia de la CharSequence especificada a este StringBuffer.

Sintaxis:

StringBuffer 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 :
StringBuffer = Geeksforgeeks
CharSequence chseq = abcd1234
int start = 2
int end = 7

Output :Geeksforgeekscd123

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

// Java program to illustrate the
// java.lang.StringBuffer.append()
  
import java.lang.*;
  
public class Geeks {
  
    public static void main(String[] args)
    {
  
        StringBuffer sbf = new StringBuffer("we are the ");
        System.out.println(" string buffer = " + 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 buffer = we are the 
After append string buffer = we are the geeks

StringBuffer append( Object obj ): este método se usa para agregar la representación de string del argumento Object al StringBuffer.

Sintaxis:

StringBuffer append(Object obj)

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

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

Los siguientes programas ilustran el método java.lang.StringBuffer.append().

Programa :

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

Producción:

string buffer = Geeksfor
After appending result is = Geeksforgeeks

StringBuffer append ( String istr ): este método se usa para agregar la string especificada a este StringBuffer.
Sintaxis:

StringBuffer 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.StringBuffer.append().

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

Producción:

string buffer = Geeksfor
After appending result is = Geeksforgeeks

StringBuffer append ( StringBuffer sbf ): este método se usa para agregar el StringBuffer especificado a esta secuencia o StringBuffer.

Sintaxis:

public StringBuffer append(StringBuffer sbf)

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

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

// Java program to illustrate the
// java.lang.StringBuffer.append()
  
import java.lang.*;
  
public class Geeks {
  
    public static void main(String[] args)
    {
  
        StringBuffer sbf1 = new StringBuffer("Geeks");
        System.out.println("String buffer 1 = " + sbf1);
  
        StringBuffer sbf2 = new StringBuffer("forgeeks ");
        System.out.println("String buffer 2 = " + sbf2);
  
        // Here it appends stringbuffer2 to stringbuffer1
        sbf1.append(sbf2);
  
        System.out.println("After appending the result is = " + sbf1);
    }
}

Producción:

String buffer 1 = Geeks
String buffer 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 Cancelar la respuesta