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 就会开始工作，对速度的影响一定是相当大的。