Java中的StringBuilder append（）方法及其示例-yiteyi-C++库

这个 JAVA朗，StringBuilder。附加（） 方法用于将某个参数的字符串表示形式附加到序列中。有13种方式/形式可以通过传递各种类型的参数来使用append（）方法：

null

StringBuilder附加( 布尔a ) : 爪哇。朗，StringBuilder。附加( 布尔a )是Java中的一个内置方法，用于将布尔参数的字符串表示形式附加到给定序列。

语法：

public StringBuilder append(boolean a)

参数： 这个方法只接受一个参数 A. 属于布尔类型，指要追加的布尔值。

返回值： 该方法返回对此对象的引用。

例如：

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

Output: We are Indians true

下面的程序演示了java。朗，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);                       
                                                 }                       
                         }                       

输出：

Input: Welcome to Geeksforgeeks 
Output: Welcome to Geeksforgeeks true

Input: We fail- 
Output: We fail- false

JAVA朗，StringBuilder。附加( 查拉 ): 这是Java中的一个内置方法，用于将char参数的字符串表示形式附加到给定序列。char参数被追加到此StringBuilder序列的内容中。

语法：

public StringBuilder append(char a)

参数： 该方法只接受一个参数 A. 这是要附加其字符串表示形式的Char值。

返回值： 执行追加操作后，该方法返回一个字符串对象。 例如：

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

Output: I love my Country A

下面的程序演示了java。朗，StringBuilder。append（char）方法。

                         // 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);                       
                                                 }                       
                         }                       

输出：

Welcome geeks!
Result after appending = Welcome geeks!T
hello world-
Result after appending = hello world-#

StringBuilder附加( char[]astr ): 爪哇。朗，StringBuilder。附加( char[]astr )是将char数组参数的字符串表示形式附加到此StringBuilder序列的内置方法。

语法：

public StringBuilder append(char[] astr)

参数： 该方法只接受一个参数 应科院 这是要追加其字符串表示形式的字符序列。

返回值： 执行追加操作后，该方法返回一个字符串对象。 例如：

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

Output: I love my Country INDIA

下面的程序演示了java。朗，StringBuilder。附加( 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);                       
                                                 }                       
                         }                       

输出：

We are geeks  
Result after appending = We are geeks  GEEkS
We are  -
Result after appending = We are  -abcd

StringBuilder附加( 字符[]cstr，整数iset，整数长度 ) : 此方法将char数组参数的子数组的字符串表示形式附加到此序列。从索引iset开始的字符数组cstr的字符按顺序追加到此序列的内容。这个序列的长度增加了ilength的值。

语法：

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

参数： 此方法接受三个参数：

cstr –这是指字符序列。
伊塞特 –这是指要附加的第一个字符的索引。
伊伦赫特 –这是指要附加的字符数。

返回值： 执行追加操作后，该方法返回一个字符串对象。下面的程序演示了java。朗，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);                       
                                                 }                       
                         }                       

输出：

String Builder before = Geeks
After appending String Builder = GeeksforGeeks

StringBuilder附加( 双a ): 此方法只是将双参数的字符串表示形式附加到此StringBuilder序列。

语法：

public StringBuilder append(double val)

参数： 该方法只接受一个参数瓦尔它指的是要附加其字符串表示形式的十进制值。

返回值： 执行追加操作后，该方法返回一个字符串对象。 例如：

Input :
StringBuffer = my Country
Double a = 54.82

Output: my Country 54.82

下面的程序演示了java。朗，StringBuilder。追加（双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);                       
                                                 }                       
                         }                       

输出：

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

StringBuilder附加( 浮动瓦尔 ): 此方法将浮点参数的字符串表示形式附加到此序列。

语法：

public StringBuilder append(float val)

参数： 该方法只接受一个参数瓦尔它是要附加其字符串表示形式的浮点值。

返回值： StringBuilder。附加( 浮动瓦尔 )方法在执行操作后返回对字符串对象的引用。

例如：

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

下面的程序演示了java。朗，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);                       
                                                 }                       
                         }                       

输出：

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

StringBuilder附加( int val ) 此方法只是将int参数的字符串表示形式附加到此StringBuilder序列。 语法：

public StringBuilder append(int val)

参数： 该方法只接受一个参数瓦尔这是一个整数值，应该对其执行操作。

返回值： 该方法返回对此对象的引用。

例如：

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

Output: I love my Country 55

下面的程序演示了java。朗，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);                       
                                                 }                       
                         }                       

输出：

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

StringBuilder附加( 朗瓦尔 ) : 此方法只是将长参数的字符串表示形式附加到此StringBuilder序列。

语法：

public StringBuilder append(Long val)

参数： 该方法只接受一个参数瓦尔这就是长期价值。

返回值： 执行追加操作后，该方法返回一个字符串对象。 例如：

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

Output: I love my Country 591995

下面的程序演示了java。朗，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);                       
                                                 }                       
                         }                       

输出：

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

StringBuilder附加( CharSequence a ): 此方法用于将指定的CharSequence追加到此序列。

语法：

public StringBuilder append(CharSequence a)

参数： 该方法只接受一个参数 A. 这是CharSequence值。

返回值： 执行追加操作后，该方法返回一个字符串对象。

例如：

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

Output : I love my Country India

下面的程序演示了java。朗，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);                       
                                                 }                       
                         }                       

输出：

String Builder = Geeksfor
After append = Geeksforgeeks

StringBuilder附加( 字符序列chseq，整数开始，整数结束 ) : 此方法用于将指定字符序列的子序列附加到此StringBuilder。

语法：

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

参数： 该方法接受三个参数：

chseq （CharSequence）：这是指CharSequence值。
开始（整数）：指要追加的子序列的起始索引。。
终止（整数）：指要追加的子序列的结束索引。

返回值： 该方法在执行追加操作后返回字符串。

例如：

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

Output :Geeksforgeekscd123

下面的程序演示了java。朗，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);                       
                                                 }                       
                         }                       

输出：

String builder= We are the 
After append string buffer = We are the geeks

StringBuilder附加( 对象对象对象 ) : 此方法用于将对象参数的字符串表示形式附加到StringBuilder。

语法：

StringBuilder append(Object obj)

参数： 该方法只接受一个参数 obj 它指的是需要附加的对象。

返回值： 该方法在执行追加操作后返回字符串。

下面的程序演示了java。朗，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);                       
                                                 }                       
                         }                       

输出：

String Builder = Geeksfor
After appending result is = Geeksforgeeks

StringBuilder附加( 字符串istr ) : 此方法用于将指定的字符串附加到此StringBuilder。 语法：

StringBuilder append(String istr)

参数： 该方法只接受一个参数 istr 指要追加的值的字符串类型。

返回值： 该方法将指定的字符串返回到此字符序列。下面的程序演示了java。朗，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);                       
                                                 }                       
                         }                       

输出：

String Builder = Geeksfor
After appending result is = Geeksforgeeks

StringBuilder附加( StringBuilder sbf ) : 此方法用于将指定的StringBuilder附加到此序列或StringBuilder。

语法：

public StringBuilder append(StringBuilder sbf)

参数： 该方法只接受一个参数 sbf 指要附加的StringBuilder。

返回值： 该方法将StringBuilder返回到此序列。下面的程序演示了java。朗，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);                       
                                                 }                       
                         }                       

输出：

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

文章版权归作者所有，未经允许请勿转载。

THE END

Java