javastringappend

Ⅰ java如何定義類似append().append()......這類的方法

方法內部業務處理完後返回對象本身，如下：

publicclassTest{

privateStringvalue;

publicTest(Stringvalue){
this.value=value;
}

publicTestappend(Stringstring){
value+=string;
returnthis;
}

@Override
publicStringtoString(){
returnvalue;
}

publicstaticvoidmain(String[]args){
Testtest=newTest("a").append("b").append("c").append("d");

System.out.println(test.toString());
}
}

Ⅱ Java解惑之String的"+"一定差於StringBuilder的append嗎

不一定。
JAVA編譯器對與+號的字元串會進行編譯優化，優化後也是用StringBuilder的append方法。
但是編譯優化是有局限的比如
String str = "";
for(int i =0; i < 1000; i++){
str = str + i;

}

這種它優化後的結果是
String str = "";
for(int i =0; i < 1000; i++){
StringBuilder sb = new StringBuilder ();
sb.append(str).append(i);
}

而我們期望的是

String str = "";
StringBuilder sb = new StringBuilder ();
for(int i =0; i < 1000; i++){
sb.append(i);
}

Ⅲ 為什麼在Java中查詢資料庫時推薦使用stringBuffer的append方法，一次寫完不行嗎

因為String每次創建都會重新開辟一塊內存空間，佔用大量的內存。而stringBuffer是初始化創建一次，之後每次在後面追加內容，不需要重新開辟內存空間，提高代碼執行效率。

Ⅳ 請詳細說一下java中append()的方法.

Java中的append( )方法其實是創建了一個新的數組，擴大了長度，將需要添加的字元串給復制到這個新的數組中。

JAVA中Stringbuffer有append( )方法：

而Stringbuffer是動態字元串數組，append( )是往動態字元串數組添加，跟「xxxx」+「yyyy」相當『+』號。

跟String不同的是Stringbuffer是放一起的，String1+String2和Stringbuffer1.append("yyyy")雖然列印效果一樣，但在內存中表示卻不一樣、

String1+String2 存在於不同的兩個地址內存，Stringbuffer1.append(Stringbuffer2)放再一起。

StringBuffer是線程安全的，多用於多線程。

(4)javastringappend擴展閱讀

查看StringBuffer的append()方法

如圖所示代碼：

1、進入append方法

@Override

public synchronized StringBuffer append(String str) {

toStringCache = null;

super.append(str);

return this;

}

其中toStringCache是Cleared whenever the StringBuffer is modified.

2、進入AbstractStringBuilder的append()方法

public AbstractStringBuilder append(String str) {

if (str == null)

return appendNull();

int len = str.length();

ensureCapacityInternal(count + len);

str.getChars(0, len, value, count);

count += len;

return this;

}

如果參數str為空返回appendNull(); 該方法最終返回return this.

3、進入ensureCapacityInternal()方法

private void ensureCapacityInternal(int minimumCapacity) {

// overflow-conscious code

if (minimumCapacity - value.length > 0) {

value = Arrays.Of(value,

newCapacity(minimumCapacity));

}

}

Of(char[] original, int newLength)的方法查JDK幫助文檔可知：復制指定的數組，復制具有指定的長度。

4、進入String的getChars()方法

public void getChars(int srcBegin, int srcEnd, char dst[], int dstBegin) {//0,len=5,value=[hello],count=5

if (srcBegin < 0) {

throw new (srcBegin);

}

if (srcEnd > value.length) {

throw new (srcEnd);

}

if (srcBegin > srcEnd) {

throw new (srcEnd - srcBegin);

}

System.array(value, srcBegin, dst, dstBegin, srcEnd - srcBegin);

}

5、最終調用的是System.array的方法:

public static void array(Object src,

int srcPos,

Object dest,

int destPos,

int length)

/*src - 源數組。

srcPos - 源數組中的起始位置。

dest - 目標數組。

destPos - 目的地數據中的起始位置。

length - 要復制的數組元素的數量。

*/

System.array([world], 0, [hello], 5, 5);

將指定源數組中的數組從指定位置復制到目標數組的指定位置。

Ⅳ Java的StringBuilder里的append方法要怎麼用

append方法就是將字元串追加到當前StringBuilder實例的結尾。
導入java.lang.StringBuilder類。
StringBuilder sb=new StringBuilder("abc");
sb.append("123");
System.out.println(sb);//輸出abc123

Ⅵ Java中StringBuffer類append方法的使用

Java中append方法的作用是在一個StringBuffer對象後面追加字元串。

例如StringBuffer s = new StringBuffer("Hello");s.append("World");

則s的內容是HelloWorld。

「拓展資料」：

當對字元串進行修改的時候，需要使用 StringBuffer 和 StringBuilder 類。

和 String 類不同的是，StringBuffer 和 StringBuilder 類的對象能夠被多次的修改，並且不產生新的未使用對象。

StringBuilder 類在 Java 5 中被提出，它和 StringBuffer 之間的最大不同在於 StringBuilder 的方法不是線程安全的（不能同步訪問）。

由於 StringBuilder 相較於 StringBuffer 有速度優勢，所以多數情況下建議使用 StringBuilder 類。然而在應用程序要求線程安全的情況下，則必須使用 StringBuffer 類。

Ⅶ Java的StringBuffer類中insert和append方法的區別

從意思中也看的出來，insert --插入；append---添加，一個在任意位置加新內容，一個在末尾。prepend就是在前面加了。

Ⅷ jave語言的string字元串有哪些特點

以主流的 JDK 版本 1.8 來說，String 內部實際存儲結構為 char 數組，源碼如下：

publicfinalclassString
implementsjava.io.Serializable,Comparable<String>,CharSequence{
//用於存儲字元串的值privatefinalcharvalue[];
//緩存字元串的hashcodeprivateinthash;//Defaultto0
//......其他內容}

String源碼中包含下面幾個重要的方法。

1. 多構造方法

String 字元串有以下 4 個重要的構造方法：

//String為參數的構造方法publicString(Stringoriginal){
this.value=original.value;
this.hash=original.hash;
}//char[]為參數構造方法publicString(charvalue[]){
this.value=Arrays.Of(value,value.length);
}//StringBuffer為參數的構造方法publicString(StringBufferbuffer){
synchronized(buffer){
this.value=Arrays.Of(buffer.getValue(),buffer.length());
}
}//StringBuilder為參數的構造方法publicString(StringBuilderbuilder){
this.value=Arrays.Of(builder.getValue(),builder.length());
}

其中，比較容易被我們忽略的是以 StringBuffer 和 StringBuilder 為參數的構造函數，因為這三種數據類型，我們通常都是單獨使用的，所以這個小細節我們需要特別留意一下。

2. equals() 比較兩個字元串是否相等，源碼如下：

publicbooleanequals(ObjectanObject){
//對象引用相同直接返回trueif(this==anObject){
returntrue;
}
//判斷需要對比的值是否為String類型，如果不是則直接返回falseif(anObjectinstanceofString){
StringanotherString=(String)anObject;
intn=value.length;
if(n==anotherString.value.length){
//把兩個字元串都轉換為char數組對比charv1[]=value;
charv2[]=anotherString.value;
inti=0;
//循環比對兩個字元串的每一個字元while(n--!=0){
//如果其中有一個字元不相等就truefalse，否則繼續對比if(v1[i]!=v2[i])
returnfalse;
i++;
}
returntrue;
}
}
returnfalse;
}

String 類型重寫了 Object 中的 equals() 方法，equals() 方法需要傳遞一個 Object 類型的參數值，在比較時會先通過 instanceof 判斷是否為 String 類型，如果不是則會直接返回 false，instanceof 的使用如下：

ObjectoString="123";
ObjectoInt=123;
System.out.println(oStringinstanceofString);//返回trueSystem.out.println(oIntinstanceofString);//返回false

當判斷參數為 String類型之後，會循環對比兩個字元串中的每一個字元，當所有字元都相等時返回true，否則則返回 false。

還有一個和equals()比較類似的方法 equalsIgnoreCase()，它是用於忽略字元串的大小寫之後進行字元串對比。

3. compareTo() 比較兩個字元串

compareTo()方法用於比較兩個字元串，返回的結果為int類型的值，源碼如下：

publicintcompareTo(StringanotherString){
intlen1=value.length;
intlen2=anotherString.value.length;
//獲取到兩個字元串長度最短的那個int值intlim=Math.min(len1,len2);
charv1[]=value;
charv2[]=anotherString.value;
intk=0;
//對比每一個字元while(k<lim){
charc1=v1[k];
charc2=v2[k];
if(c1!=c2){
//有字元不相等就返回差值returnc1-c2;
}
k++;
}
returnlen1-len2;
}

從源碼中可以看出，compareTo()方法會循環對比所有的字元，當兩個字元串中有任意一個字元不相同時，則 returnchar1-char2。比如，兩個字元串分別存儲的是 1和 2，返回的值是 -1；如果存儲的是 1和 1，則返回的值是 0 ，如果存儲的是 2和 1，則返回的值是 1。

還有一個和compareTo()比較類似的方法 compareToIgnoreCase()，用於忽略大小寫後比較兩個字元串。

可以看出compareTo()方法和equals()方法都是用於比較兩個字元串的，但它們有兩點不同：

equals()可以接收一個 Object類型的參數，而 compareTo()只能接收一個String類型的參數；
equals()返回值為Boolean，而compareTo()的返回值則為int。
它們都可以用於兩個字元串的比較，當equals()方法返回true時，或者是compareTo()方法返回 0時，則表示兩個字元串完全相同。

4.其他重要方法

indexOf()：查詢字元串首次出現的下標位置
lastIndexOf()：查詢字元串最後出現的下標位置
contains()：查詢字元串中是否包含另一個字元串
toLowerCase()：把字元串全部轉換成小寫
toUpperCase()：把字元串全部轉換成大寫
length()：查詢字元串的長度
trim()：去掉字元串首尾空格
replace()：替換字元串中的某些字元
split()：把字元串分割並返回字元串數組
join()：把字元串數組轉為字元串

知識擴展

1.== 和equals的區別

== 對於基本數據類型來說，是用於比較 「值」是否相等的；而對於引用類型來說，是用於比較引用地址是否相同的。

查看源碼我們可以知道 Object 中也有equals() 方法，源碼如下：

publicbooleanequals(Objectobj){
return(this==obj);
}

可以看出，Object 中的 equals() 方法其實就是 ==，而 String 重寫了 equals() 方法把它修改成比較兩個字元串的值是否相等。

publicbooleanequals(ObjectanObject){
//對象引用相同直接返回trueif(this==anObject){
returntrue;
}
//判斷需要對比的值是否為String類型，如果不是則直接返回falseif(anObjectinstanceofString){
StringanotherString=(String)anObject;
intn=value.length;
if(n==anotherString.value.length){
//把兩個字元串都轉換為char數組對比charv1[]=value;
charv2[]=anotherString.value;
inti=0;
//循環比對兩個字元串的每一個字元while(n--!=0){
//如果其中有一個字元不相等就truefalse，否則繼續對比if(v1[i]!=v2[i])
returnfalse;
i++;
}
returntrue;
}
}
returnfalse;
}

2.final修飾的好處

從String類的源碼我們可以看出String是被final修飾的不可繼承類，源碼如下：

publicfinalclassString implementsjava.io.Serializable,Comparable<String>,CharSequence{//......}

那這樣設計有什麼好處呢？他會更傾向於使用 final，因為它能夠緩存結果，當你在傳參時不需要考慮誰會修改它的值；如果是可變類的話，則有可能需要重新拷貝出來一個新值進行傳參，這樣在性能上就會有一定的損失。

String 類設計成不可變的另一個原因是安全，當你在調用其他方法時，比如調用一些系統級操作指令之前，可能會有一系列校驗，如果是可變類的話，可能在你校驗過後，它的內部的值又被改變了，這樣有可能會引起嚴重的系統崩潰問題，這是迫使 String 類設計成不可變類的一個重要原因。

總結來說，使用 final 修飾的第一個好處是安全；第二個好處是高效，以 JVM 中的字元串常量池來舉例，如下兩個變數：

Strings1="java";
Strings2="java";

只有字元串是不可變時，我們才能實現字元串常量池，字元串常量池可以為我們緩存字元串，提高程序的運行效率，如下圖所示：

除此之外編譯器還會對String字元串做一些優化，例如以下代碼：

Strings1="Ja"+"va";
Strings2="Java";
System.out.println(s1==s2);

雖然s1拼接了多個字元串，但對比的結果卻是true，我們使用反編譯工具，看到的結果如下：

Compiledfrom"StringExample.java"publicclasscom.lagou.interview.StringExample{
publiccom.lagou.interview.StringExample();
Code:
0:aload_0
1:invokespecial#1//Methodjava/lang/Object."<init>":()V4:returnLineNumberTable:
line3:0publicstaticvoidmain(java.lang.String[]);
Code:
0:ldc#2//StringJava2:astore_1
3:ldc#2//StringJava5:astore_2
6:getstatic#3//Fieldjava/lang/System.out:Ljava/io/PrintStream;9:aload_1
10:aload_2
11:if_acmpne1814:iconst_1
15:goto1918:iconst_0
19:invokevirtual#4//Methodjava/io/PrintStream.println:(Z)V22:returnLineNumberTable:
line5:0line6:3line7:6line8:22}

從編譯代碼 #2 可以看出，代碼 "Ja"+"va" 被直接編譯成了 "Java" ，因此 s1==s2 的結果才是 true，這就是編譯器對字元串優化的結果。

Ⅸ Java中的append()方是任何類都有的嗎

你好！
不是每個類都有。
常用的類中，只有StringBuffer才有。
你可以下載JDK的API幫助，查看一下就知道了。
Object是所有類的父類，只有是Object的公共方法，所有類才有。append()方法並不是Object的方法。
如果對你有幫助，望採納。

Ⅹ java語言：String類的concat方法與StringBuffer類的append方法區別內存狀態

首先我們先看幾個概念：

1：在java內部是對+進行了重載，在處理String的過程中要創建一個StringBuffer對象，用StringBuffer對象的append方法對字元串進行連接，最後調用toString方法返回String字元串。

2： +和concat操作，是先開辟一個要拼接的字元串的空間，在和老字元串一起拼接成一個新的字元串，所以在堆內存中是創建了三塊空間的；

然後先來說1和2的區別：line1: 用的是+，+在底層是通過StringBuffer對象的append方法對字元串進行連接，但是他也並不是直接添加的，我們看看他開辟了幾塊空間？「abc」「def」「ghi」,剛開始開辟了三塊堆內存空間，執行一次+,「abcdef」這是第四塊內存空間，最後是最終結果「abcdefghi」開辟了第五塊堆內存空間，然後其餘的被回收。

line2:同樣也是開辟了五塊堆內存空間，concat()和+號的區別我們可以看下concat()源代碼：

publicStringconcat(Stringstr){
intotherLen=str.length();
if(otherLen==0){
returnthis;
}
intlen=value.length;
/*Of數組復制,Of()的第二個自變數指定要建立的新數組長度，
如果新數組的長度超過原數組的長度，則保留為默認值null或0*/
charbuf[]=Arrays.Of(value,len+otherLen);
//將字元從此字元串復制到目標字元數組,len為數組中的起始偏移量
str.getChars(buf,len);
returnnewString(buf,true);
}

我們可以看到concat()方法是通過Of(),和getChars();兩個方法來拼接數組的。+在底層是通過StringBuffer對象的append方法對字元串進行連接。

最後是StringBuffer：StringBuffer使用時，只會開辟一塊內存空間，使用append添加或delete刪除其內容時，也是在這一塊內存空間中並不會生成多餘的空間。所以速度是比較快的而String 每次生成對象都會對系統性能產生影響，特別當內存中無引用對象多了以後， JVM 的 GC 就會開始工作，對速度的影響一定是相當大的。