StringBuilder的用法
String 对象是不可改变的。
每次使用System.String 类中的方法之一时，都要在内存中创建一个新的字符串对象，这就需要为该新对象分配新的空间。
在需要对字符串执行重复修改的情况下，与创建新的String 对象相关的系统开销可能会非常昂贵。
如果要修改字符串而不创建新的对象，则可以使用System.Text.StringBuilder 类。
例如，当在一个循环中将许多字符串连接在一起时，使用StringBuilder 类可以提升性能。
通过用一个重载的构造函数方法初始化变量，可以创建StringBuilder 类的新实例，正如以下示例中所阐释的那样。
StringBuilder MyStringBuilder = new StringBuilder("Hello World!");
(一)设置容量和长度
虽然StringBuilder 对象是动态对象，允许扩充它所封装的字符串中字符的数量，但是您可以为它可容纳的最大字符数指定一个值。
此值称为该对象的容量，不应将它与当前StringBuilder 对象容纳的字符串长度混淆在一起。
例如，可以创建StringBuilder 类的带有字符串“Hello”（长度为5）的一个新实例，同时可以指定该对象的最大容量为25。
当修改StringBuilder 时，在达到容量之前，它不会为其自己重新分配空间。
当达到容量时，将自动分配新的空间且容量翻倍。
可以使用重载的构造函数之一来指定StringBuilder 类的容量。
以下代码示例指定可以将MyStringBuilder 对象扩充到最大25 个空白。
StringBuilder MyStringBuilder = new StringBuilder("Hello World!", 25);
另外，可以使用读/写Capacity 属性来设置对象的最大长度。
以下代码示例使用Capacity 属性来定义对象的最大长度。
MyStringBuilder.Capacity = 25;
(二)下面列出了此类的几个常用方法：
(1)Append 方法可用来将文本或对象的字符串表示形式添加到由当前StringBuilder 对象表示的字符串的结尾处。
以下示例将一个StringBuilder 对象初始化为“Hello World”，然后将一些文本追加到该对象的结尾处。
将根据需要自动分配空间。
StringBuilder MyStringBuilder = new StringBuilder("Hello World!");
MyStringBuilder.Append(" What a beautiful day.");
Console.WriteLine(MyStringBuilder);
此示例将Hello World! What a beautiful day. 显示到控制台。
(2)AppendFormat 方法将文本添加到StringBuilder 的结尾处，而且实现了IFormattable 接口，因此可接受格式化部分中描述的标准格式字符串。
可以使用此方法来自定义变量的格式并将这些值追加到StringBuilder 的后面。
以下示例使用AppendFormat 方法将一个设置为货币值格式的整数值放置到StringBuilder 的结尾。
int MyInt = 25;
StringBuilder MyStringBuilder = new StringBuilder("Your total is ");
MyStringBuilder.AppendFormat("{0:C} ", MyInt);
Console.WriteLine(MyStringBuilder);
此示例将Your total is $25.00 显示到控制台。
(3)Insert 方法将字符串或对象添加到当前StringBuilder 中的指定位置。
以下示例使用此方
法将一个单词插入到StringBuilder 的第六个位置。
StringBuilder MyStringBuilder = new StringBuilder("Hello World!");
MyStringBuilder.Insert(6,"Beautiful ");
Console.WriteLine(MyStringBuilder);
此示例将Hello Beautiful World! 显示到控制台。
(4)可以使用Remove 方法从当前StringBuilder 中移除指定数量的字符，移除过程从指定的从零开始的索引处开始。
以下示例使用Remove 方法缩短StringBuilder。
StringBuilder MyStringBuilder = new StringBuilder("Hello World!");
MyStringBuilder.Remove(5,7);
Console.WriteLine(MyStringBuilder);
此示例将Hello 显示到控制台。
(5)使用Replace 方法，可以用另一个指定的字符来替换StringBuilder 对象内的字符。
以下示例使用Replace 方法来搜索StringBuilder 对象，查找所有的感叹号字符(!)，并用问号字符(?) 来替换它们。
StringBuilder MyStringBuilder = new StringBuilder("Hello World!");
MyStringBuilder.Replace('!', '?');
Console.WriteLine(MyStringBuilder);
此示例将Hello World? 显示到控制台。
java连接字符串的方法
java连接字符串的方法Java连接字符串的方法很多，下面介绍几种常用的：1. 使用加号 + 连接字符串可以使用加号 + 连接多个字符串，例如：String str1 = 'Hello';String str2 = 'World';String result = str1 + ' ' + str2;System.out.println(result);这段代码将输出结果为：Hello World。
2. 使用 StringBuilder 或 StringBuffer 连接字符串StringBuilder 和 StringBuffer 都可以用来构建字符串，它们的主要区别在于线程安全性和执行速度。
StringBuilder 是非线程安全的，执行速度较快；StringBuffer 是线程安全的，执行速度较慢。
使用 StringBuilder 或 StringBuffer 连接字符串的示例代码如下：StringBuilder sb = new StringBuilder();sb.append('Hello');sb.append(' ');sb.append('World');String result = sb.toString();System.out.println(result);这段代码将输出结果为：Hello World。
3. 使用 StringJoiner 连接字符串StringJoiner 是 Java 8 新增的一个类，可以用来连接多个字符串，并且可以指定分隔符和前缀后缀等信息。
示例代码如下：StringJoiner sj = new StringJoiner(' ');sj.add('Hello');sj.add('World');String result = sj.toString();System.out.println(result);这段代码将输出结果为：Hello World。
JAVA 学习笔记
Java学习笔记关于StringBuilder方法总结：1.用法：new StringBuilder.方法名或创建一个新的对象对象.方法名灵活运用返回值StringBuilder append(参数)追加内容到当前stringbuilder对象的末尾StringBuilder insert(位置，参数)将内容插入到StringBuilder对象的指定位置String toString()将StringBuilder对象转换为String对象int length()获取字符串的长度关于字符串：1.字符串对象创建后是不可修改的，所谓的修改实际上是创建了新的对象，所指向的内存空间不同例：String s1=”a”;String s2=”a”;s1==s2true;多次出现的字符常量，Java编译只生成一个，所以返回值为true；String s1=new String(“a”);String s2=new String(“a”);s1==s2false;s1,s2是不同的对象，占用着不同的内存区域，所以返回值为false；==比较的是内存如果只是想要比较内容是否相同用equals（）即可2.StringBuilder StringBuffer是可以修改的3.感悟：这种对于其他数据类型同样适用int不是一个对象integer是一个对象两个new的对象代表着不同的内存区域用==不能去判断4.String的常用方法总结int length()返回当前字符串的长度int indexOf(int ch)查找ch字符在该字符串中第一次出现的位置int indexOf(String str)查找str字符串第一次出现的位置int lastindexOf(int ch)查找ch字符串最后一次出现的位置int lastindexOf(String str)查找str字符串最后一次出现的位置String substring(int began)获取从began位置开始到结束位置的字符串String substring(int began,int end)获取从began位置到end位置的字符串String trim()返回去除了前后空格的字符串Boolean equals()ignoe…String toLowerCase()转换为小写toUpperCasechar charAt(int index)获取字符串中指定位置的字符String[]split(String regex,int limit)讲字符串分割为子字符串，返回字符串数组Byte[]getBytes()将该字符串转换为byte数组关于包装类：1.基本数据类型是不具备对象特征的，不能引用方法，所以出现了包装类2.byte Byte short Short int Integer long Long float Float double Double char Charater Boolean Boolean3.构造方法：Integer(int value)Integer(String s)4.新建对象a a.XXXvalue将对象的数据类型转化为XXX型；5.Integer i=Integer.parseInt(string s)或者Integer i=new Integer(int x)i.ParseInt()将字符串转化为int类型6.valueOf(String s)将字符串转化为Integer类型返回值static Integer7.与字符串之间的转换int c=10;String str1=Integer.toString(c);str1=String.valueOf（c）;str1=c+””;8.字符串转换为基本类型String str=”8”;int d=Integer.parseInt(str);int d=String.valueOf(str)；转化为谁就用谁.valueOf(被转化);关于Date和SimpleDateFormat类表示时间（不建议使用Date）：1.Date d=new Date();使用的无参构造方法是默认是当前的时间；2.在使用Date类时必须先引入java.util.Date类在使用SImperDateFormat的时候要引用java.text.SimperDateFormat因为用parse()方法很容易出现ParseException错误所以引用java.text.ParseException3.有参的Date类即人工设置时间例：SimpleDateFormat sdf=new SimpDateFormat（“yyyy年MM月dd日HH时mm分ss秒”）;Date date=sdf.parse(”1996年09月12日12时12分12秒“)格式相同才可以格式化为String类String string=sdf.format(date);关于Calendar类：1.Date类最主要的作用就是获得当前时间，同时这个类里面也具有设置时间以及一些其他的功能，但是由于本身设计的问题，这些方法却遭到众多批评，不建议使用，更推荐使用Calendar类进行时间和日期的处理。
StringBuilder的用法总结
StringBuilder的⽤法总结在程序开发过程中，我们常常碰到字符串连接的情况，⽅便和直接的⽅式是通过"+"符号来实现，但是这种⽅式达到⽬的的效率⽐较低，且每执⾏⼀次都会创建⼀个String对象，即耗时，⼜浪费空间。
使⽤StringBuilder类就可以避免这种问题的发⽣，下⾯就Stringbuilder的使⽤做个简要的总结：⼀、创建Stringbuilder对象StringBuilder strB = new StringBuilder();1、append(String str)/append(Char c)：字符串连接System.out.println("StringBuilder:"+strB.append("ch").append("111").append('c'));//return "StringBuilder:ch111c"2、toString()：返回⼀个与构建起或缓冲器内容相同的字符串System.out.println("String:"+strB.toString());//return "String:ch111c"3、appendcodePoint(int cp)：追加⼀个代码点，并将其转换为⼀个或两个代码单元并返回thisSystem.out.println("StringBuilder.appendCodePoint:"+strB.appendCodePoint(2));//return "StringBuilder.appendCodePoint:ch111c"4、setCharAt(int i, char c)：将第 i 个代码单元设置为 c（可以理解为替换）strB.setCharAt(2, 'd');System.out.println("StringBuilder.setCharAt:" + strB);//return "StringBuilder.setCharAt:chd11c"5、insert(int offset, String str)/insert(int offset, Char c)：在指定位置之前插⼊字符(串)System.out.println("StringBuilder.insertString:"+ strB.insert(2, "LS"));//return "StringBuilder.insertString:chLSd11c"System.out.println("StringBuilder.insertChar:"+ strB.insert(2, 'L'));//return "StringBuilder.insertChar:chLLSd11c"6、delete(int startIndex,int endIndex)：删除起始位置（含）到结尾位置（不含）之间的字符串System.out.println("StringBuilder.delete:"+ strB.delete(2, 4));//return "StringBuilder.delete:chSd11c"。
StringBuilder详解（String系列之2）
StringBuilder详解（String系列之2）本章介绍StringBuilder以及它的API的详细使⽤⽅法。
StringBuilder 简介StringBuilder 是⼀个可变的字符序列。
它继承于AbstractStringBuilder，实现了CharSequence接⼝。
StringBuffer 也是继承于AbstractStringBuilder的⼦类；但是，StringBuilder和StringBuffer不同，前者是⾮线程安全的，后者是线程安全的。
StringBuilder 和 CharSequence之间的关系图如下：StringBuilder函数列表StringBuilder()StringBuilder(int capacity)StringBuilder(CharSequence seq)StringBuilder(String str)StringBuilder append(float f)StringBuilder append(double d)StringBuilder append(boolean b)StringBuilder append(int i)StringBuilder append(long l)StringBuilder append(char c)StringBuilder append(char[] chars)StringBuilder append(char[] str, int offset, int len)StringBuilder append(String str)StringBuilder append(Object obj)StringBuilder append(StringBuffer sb)StringBuilder append(CharSequence csq)StringBuilder append(CharSequence csq, int start, int end)StringBuilder appendCodePoint(int codePoint)int capacity()char charAt(int index)int codePointAt(int index)int codePointBefore(int index)int codePointCount(int start, int end)StringBuilder delete(int start, int end)StringBuilder deleteCharAt(int index)void ensureCapacity(int min)void getChars(int start, int end, char[] dst, int dstStart)int indexOf(String subString, int start)int indexOf(String string)StringBuilder insert(int offset, boolean b)StringBuilder insert(int offset, int i)StringBuilder insert(int offset, long l)StringBuilder insert(int offset, float f)StringBuilder insert(int offset, double d)StringBuilder insert(int offset, char c)StringBuilder insert(int offset, char[] ch)StringBuilder insert(int offset, char[] str, int strOffset, int strLen)StringBuilder insert(int offset, String str)StringBuilder insert(int offset, Object obj)StringBuilder insert(int offset, CharSequence s)StringBuilder insert(int offset, CharSequence s, int start, int end)int lastIndexOf(String string)int lastIndexOf(String subString, int start)int length()int offsetByCodePoints(int index, int codePointOffset)StringBuilder replace(int start, int end, String string)StringBuilder reverse()void setCharAt(int index, char ch)void setLength(int length)CharSequence subSequence(int start, int end)String substring(int start)String substring(int start, int end)String toString()void trimToSize()AbstractStringBuilder 和 StringBuilder源码AbstractStringBuilder源码(基于jdk1.7.40)1package ng;23import sun.misc.FloatingDecimal;4import java.util.Arrays;56abstract class AbstractStringBuilder implements Appendable, CharSequence { 7char[] value;89int count;1011 AbstractStringBuilder() {12 }1314 AbstractStringBuilder(int capacity) {15 value = new char[capacity];16 }1718public int length() {19return count;20 }2122public int capacity() {23return value.length;24 }2526public void ensureCapacity(int minimumCapacity) {27if (minimumCapacity > 0)28 ensureCapacityInternal(minimumCapacity);29 }3031private void ensureCapacityInternal(int minimumCapacity) {32// overflow-conscious code33if (minimumCapacity - value.length > 0)34 expandCapacity(minimumCapacity);35 }3637void expandCapacity(int minimumCapacity) {38int newCapacity = value.length * 2 + 2;39if (newCapacity - minimumCapacity < 0)40 newCapacity = minimumCapacity;41if (newCapacity < 0) {42if (minimumCapacity < 0) // overflow43throw new OutOfMemoryError();44 newCapacity = Integer.MAX_VALUE;45 }46 value = Arrays.copyOf(value, newCapacity);47 }4849public void trimToSize() {50if (count < value.length) {51 value = Arrays.copyOf(value, count);52 }53 }5455public void setLength(int newLength) {56if (newLength < 0)57throw new StringIndexOutOfBoundsException(newLength);58 ensureCapacityInternal(newLength);5960if (count < newLength) {61for (; count < newLength; count++)62 value[count] = '\0';63 } else {64 count = newLength;65 }66 }6768public char charAt(int index) {69if ((index < 0) || (index >= count))70throw new StringIndexOutOfBoundsException(index);71return value[index];72 }7374public int codePointAt(int index) {75if ((index < 0) || (index >= count)) {76throw new StringIndexOutOfBoundsException(index);77 }78return Character.codePointAt(value, index);79 }8081public int codePointBefore(int index) {82int i = index - 1;86return Character.codePointBefore(value, index);87 }8889public int codePointCount(int beginIndex, int endIndex) {90if (beginIndex < 0 || endIndex > count || beginIndex > endIndex) {91throw new IndexOutOfBoundsException();92 }93return Character.codePointCountImpl(value, beginIndex, endIndex-beginIndex);94 }9596public int offsetByCodePoints(int index, int codePointOffset) {97if (index < 0 || index > count) {98throw new IndexOutOfBoundsException();99 }100return Character.offsetByCodePointsImpl(value, 0, count,101 index, codePointOffset);102 }103104public void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)105 {106if (srcBegin < 0)107throw new StringIndexOutOfBoundsException(srcBegin);108if ((srcEnd < 0) || (srcEnd > count))109throw new StringIndexOutOfBoundsException(srcEnd);110if (srcBegin > srcEnd)111throw new StringIndexOutOfBoundsException("srcBegin > srcEnd");112 System.arraycopy(value, srcBegin, dst, dstBegin, srcEnd - srcBegin);113 }114115public void setCharAt(int index, char ch) {116if ((index < 0) || (index >= count))117throw new StringIndexOutOfBoundsException(index);118 value[index] = ch;119 }120121public AbstractStringBuilder append(Object obj) {122return append(String.valueOf(obj));123 }124125public AbstractStringBuilder append(String str) {126if (str == null) str = "null";127int len = str.length();128 ensureCapacityInternal(count + len);129 str.getChars(0, len, value, count);130 count += len;131return this;132 }133134// Documentation in subclasses because of synchro difference135public AbstractStringBuilder append(StringBuffer sb) {136if (sb == null)137return append("null");138int len = sb.length();139 ensureCapacityInternal(count + len);140 sb.getChars(0, len, value, count);141 count += len;142return this;143 }144145// Documentation in subclasses because of synchro difference146public AbstractStringBuilder append(CharSequence s) {147if (s == null)148 s = "null";149if (s instanceof String)150return this.append((String)s);151if (s instanceof StringBuffer)152return this.append((StringBuffer)s);153return this.append(s, 0, s.length());154 }155156public AbstractStringBuilder append(CharSequence s, int start, int end) {157if (s == null)158 s = "null";159if ((start < 0) || (start > end) || (end > s.length()))160throw new IndexOutOfBoundsException(161 "start " + start + ", end " + end + ", s.length() "162 + s.length());163int len = end - start;164 ensureCapacityInternal(count + len);165for (int i = start, j = count; i < end; i++, j++)166 value[j] = s.charAt(i);170171public AbstractStringBuilder append(char[] str) {172int len = str.length;173 ensureCapacityInternal(count + len);174 System.arraycopy(str, 0, value, count, len);175 count += len;176return this;177 }178179public AbstractStringBuilder append(char str[], int offset, int len) { 180if (len > 0) // let arraycopy report AIOOBE for len < 0 181 ensureCapacityInternal(count + len);182 System.arraycopy(str, offset, value, count, len);183 count += len;184return this;185 }186187public AbstractStringBuilder append(boolean b) {188if (b) {189 ensureCapacityInternal(count + 4);190 value[count++] = 't';191 value[count++] = 'r';192 value[count++] = 'u';193 value[count++] = 'e';194 } else {195 ensureCapacityInternal(count + 5);196 value[count++] = 'f';197 value[count++] = 'a';198 value[count++] = 'l';199 value[count++] = 's';200 value[count++] = 'e';201 }202return this;203 }204205public AbstractStringBuilder append(char c) {206 ensureCapacityInternal(count + 1);207 value[count++] = c;208return this;209 }210211public AbstractStringBuilder append(int i) {212if (i == Integer.MIN_VALUE) {213 append("-2147483648");214return this;215 }216int appendedLength = (i < 0) ? Integer.stringSize(-i) + 1217 : Integer.stringSize(i);218int spaceNeeded = count + appendedLength;219 ensureCapacityInternal(spaceNeeded);220 Integer.getChars(i, spaceNeeded, value);221 count = spaceNeeded;222return this;223 }224225public AbstractStringBuilder append(long l) {226if (l == Long.MIN_VALUE) {227 append("-9223372036854775808");228return this;229 }230int appendedLength = (l < 0) ? Long.stringSize(-l) + 1231 : Long.stringSize(l);232int spaceNeeded = count + appendedLength;233 ensureCapacityInternal(spaceNeeded);234 Long.getChars(l, spaceNeeded, value);235 count = spaceNeeded;236return this;237 }238239public AbstractStringBuilder append(float f) {240new FloatingDecimal(f).appendTo(this);241return this;242 }243244public AbstractStringBuilder append(double d) {245new FloatingDecimal(d).appendTo(this);246return this;247 }248249public AbstractStringBuilder delete(int start, int end) {250if (start < 0)253 end = count;254if (start > end)255throw new StringIndexOutOfBoundsException();256int len = end - start;257if (len > 0) {258 System.arraycopy(value, start+len, value, start, count-end); 259 count -= len;260 }261return this;262 }263264public AbstractStringBuilder appendCodePoint(int codePoint) {265final int count = this.count;266267if (Character.isBmpCodePoint(codePoint)) {268 ensureCapacityInternal(count + 1);269 value[count] = (char) codePoint;270this.count = count + 1;271 } else if (Character.isValidCodePoint(codePoint)) {272 ensureCapacityInternal(count + 2);273 Character.toSurrogates(codePoint, value, count);274this.count = count + 2;275 } else {276throw new IllegalArgumentException();277 }278return this;279 }280281public AbstractStringBuilder deleteCharAt(int index) {282if ((index < 0) || (index >= count))283throw new StringIndexOutOfBoundsException(index);284 System.arraycopy(value, index+1, value, index, count-index-1); 285 count--;286return this;287 }288289public AbstractStringBuilder replace(int start, int end, String str) { 290if (start < 0)291throw new StringIndexOutOfBoundsException(start);292if (start > count)293throw new StringIndexOutOfBoundsException("start > length()"); 294if (start > end)295throw new StringIndexOutOfBoundsException("start > end"); 296297if (end > count)298 end = count;299int len = str.length();300int newCount = count + len - (end - start);301 ensureCapacityInternal(newCount);302303 System.arraycopy(value, end, value, start + len, count - end); 304 str.getChars(value, start);305 count = newCount;306return this;307 }308309public String substring(int start) {310return substring(start, count);311 }312313public CharSequence subSequence(int start, int end) {314return substring(start, end);315 }316317public String substring(int start, int end) {318if (start < 0)319throw new StringIndexOutOfBoundsException(start);320if (end > count)321throw new StringIndexOutOfBoundsException(end);322if (start > end)323throw new StringIndexOutOfBoundsException(end - start);324return new String(value, start, end - start);325 }326327public AbstractStringBuilder insert(int index, char[] str, int offset, 328int len)329 {330if ((index < 0) || (index > length()))331throw new StringIndexOutOfBoundsException(index);332if ((offset < 0) || (len < 0) || (offset > str.length - len))333throw new StringIndexOutOfBoundsException(334 "offset " + offset + ", len " + len + ", str.length "337 System.arraycopy(value, index, value, index + len, count - index); 338 System.arraycopy(str, offset, value, index, len);339 count += len;340return this;341 }342343public AbstractStringBuilder insert(int offset, Object obj) {344return insert(offset, String.valueOf(obj));345 }346347public AbstractStringBuilder insert(int offset, String str) {348if ((offset < 0) || (offset > length()))349throw new StringIndexOutOfBoundsException(offset);350if (str == null)351 str = "null";352int len = str.length();353 ensureCapacityInternal(count + len);354 System.arraycopy(value, offset, value, offset + len, count - offset); 355 str.getChars(value, offset);356 count += len;357return this;358 }359360public AbstractStringBuilder insert(int offset, char[] str) {361if ((offset < 0) || (offset > length()))362throw new StringIndexOutOfBoundsException(offset);363int len = str.length;364 ensureCapacityInternal(count + len);365 System.arraycopy(value, offset, value, offset + len, count - offset); 366 System.arraycopy(str, 0, value, offset, len);367 count += len;368return this;369 }370371public AbstractStringBuilder insert(int dstOffset, CharSequence s) { 372if (s == null)373 s = "null";374if (s instanceof String)375return this.insert(dstOffset, (String)s);376return this.insert(dstOffset, s, 0, s.length());377 }378379public AbstractStringBuilder insert(int dstOffset, CharSequence s, 380int start, int end) {381if (s == null)382 s = "null";383if ((dstOffset < 0) || (dstOffset > this.length()))384throw new IndexOutOfBoundsException("dstOffset "+dstOffset); 385if ((start < 0) || (end < 0) || (start > end) || (end > s.length()))386throw new IndexOutOfBoundsException(387 "start " + start + ", end " + end + ", s.length() "388 + s.length());389int len = end - start;390 ensureCapacityInternal(count + len);391 System.arraycopy(value, dstOffset, value, dstOffset + len,392 count - dstOffset);393for (int i=start; i<end; i++)394 value[dstOffset++] = s.charAt(i);395 count += len;396return this;397 }398399public AbstractStringBuilder insert(int offset, boolean b) {400return insert(offset, String.valueOf(b));401 }402403public AbstractStringBuilder insert(int offset, char c) {404 ensureCapacityInternal(count + 1);405 System.arraycopy(value, offset, value, offset + 1, count - offset); 406 value[offset] = c;407 count += 1;408return this;409 }410411public AbstractStringBuilder insert(int offset, int i) {412return insert(offset, String.valueOf(i));413 }414415public AbstractStringBuilder insert(int offset, long l) {416return insert(offset, String.valueOf(l));417 }418421 }422423public AbstractStringBuilder insert(int offset, double d) {424return insert(offset, String.valueOf(d));425 }426427public int indexOf(String str) {428return indexOf(str, 0);429 }430431public int indexOf(String str, int fromIndex) {432return String.indexOf(value, 0, count,433 str.toCharArray(), 0, str.length(), fromIndex);434 }435436public int lastIndexOf(String str) {437return lastIndexOf(str, count);438 }439440public int lastIndexOf(String str, int fromIndex) {441return stIndexOf(value, 0, count,442 str.toCharArray(), 0, str.length(), fromIndex);443 }444445public AbstractStringBuilder reverse() {446boolean hasSurrogate = false;447int n = count - 1;448for (int j = (n-1) >> 1; j >= 0; --j) {449char temp = value[j];450char temp2 = value[n - j];451if (!hasSurrogate) {452 hasSurrogate = (temp >= Character.MIN_SURROGATE && temp <= Character.MAX_SURROGATE) 453 || (temp2 >= Character.MIN_SURROGATE && temp2 <= Character.MAX_SURROGATE);454 }455 value[j] = temp2;456 value[n - j] = temp;457 }458if (hasSurrogate) {459// Reverse back all valid surrogate pairs460for (int i = 0; i < count - 1; i++) {461char c2 = value[i];462if (Character.isLowSurrogate(c2)) {463char c1 = value[i + 1];464if (Character.isHighSurrogate(c1)) {465 value[i++] = c1;466 value[i] = c2;467 }468 }469 }470 }471return this;472 }473474public abstract String toString();475476final char[] getValue() {477return value;478 }479 }View CodeStringBuilder源码(基于jdk1.7.40)1package ng;23public final class StringBuilder4extends AbstractStringBuilder5implements java.io.Serializable, CharSequence {67static final long serialVersionUID = 4383685877147921099L;89// 构造函数。
string、stringbuffer和stringbuild的区别与联系
String、StringBuffer和StringBuilder的区别String类分别用于实现IComparable、ICloneable、IConvertible、IEnumerable和IComparable接口。
使用Convert类进行转换，而不是使用此类型的IConvertible显式接口成员实现。
String类提供的成员执行以下操作：比较String对象；返回String对象内字符或字符串的索引；复制String对象的值；分隔字符串或组合字符串；修改字符串的值；将数字、日期和时间或枚举值的格式设置为字符串；对字符串进行规范化。
•使用Compare、CompareOrdinal、CompareTo、Equals、EndsWith和StartsWith方法进行比较。
•使用IndexOf、IndexOfAny、LastIndexOf和LastIndexOfAny方法可获取字符串中子字符串或Unicode 字符的索引。
•使用Copy和CopyTo可将字符串或子字符串复制到另一个字符串或Char类型的数组。
•使用Substring和Split方法可通过原始字符串的组成部分创建一个或多个新字符串；使用Concat和Join方法可通过一个或多个子字符串创建新字符串。
•使用Insert、Replace、Remove、PadLeft、PadRight、Trim、TrimEnd和TrimStart可修改字符串的全部或部分。
•使用ToLower、ToLowerInvariant、ToUpper和ToUpperInvariant方法可更改字符串中Unicode 字符的大小写。
•使用Format，可将字符串中的一个或多个格式项占位符替换为一个或多个数字、日期和时间或枚举值的文本表示形式。
•使用Length属性可获取字符串中Char对象的数量；使用Chars属性可访问字符串中实际的Char对象。
•使用IsNormalized方法可测试某个字符串是否已规范化为特定的范式。
stringBuilder 的用法
Console.WriteLine(MyStringBuilder);
此示例将 Hello Beautiful World! 显示到控制台。
(4)可以使用 Remove 方法从当前 StringBuilder 中移除指定数量的字符，移除过程从指定的从零开始的索引处开始。以下示例使用 Remove 方法缩短StringBuilder。
MyStringBuilder.Replace('!', '?');
Console.WriteLine(MyStringBuilder);
此示例将 Hello World? 显示到控制台
stringBuilder 的用法
（1）AAppend 方法 用来将文本或对象的字符串表示形式添加到由当前 StringBuilder 对象表示的字符串的结尾处。以下示例将一个 StringBuilder 对象初始化为“Hello World”，然后将一些文本追加到该对象的结尾处。将根据需要自动分配空间
此示例将 Your total is $25.00 显示到控制台。
(3)Insert 方法将字符串或对象添加到当前 StringBuilder 中的指定位置。以下示例使用此方法将一个单词插入到 StringBuilder 的第六个位置。
StringBuilder MyStringBuilder = new StringBuilder("Hello World!");
(5)使用 Replace 方法，可以用另一个指定的字符来替换 StringBuilder 对象内的字符。以下示例使用 Replace 方法来搜索 StringBuilder 对象，查找所有的感叹号字符 (!)，并用问号字符 (?) 来替换它们。
String,StringBuffer,StringBuilder的区别
String,StringBuffer,StringBuilder的对比1.执行速度方面（大部分情况下）StringBuilder> StringBuffer> String2.StringBuffer （Synchronized）线程安全StringBuilder 线程不安全3.举例（生成对象的速度由快到慢）在某些特别情况下， String 对象的字符串拼接其实是被 JVM 解释成了 StringBuffer 对象的拼接，所以这些时候 String 对象的速度并不会比 StringBuffer 对象慢，而特别是以下的字符串对象生成中， String 效率是远要比 StringBuffer 快的。
String str = “This is only a”+ “simple”+ “test”;StringBuffer sb=new StringBuilder(“This is only a”).append(“simple”).append(“t est”);String str2 = “This is only a”;String str3 = “ simple”;St ring str4 = “ test”;String str1 = str2 +str3 + str4;4.三者选用的条件操作少量的数据用 = String单线程操作大量数据 = StringBuilder多线程操作大量数据 = StringBuffer5.String 字符串常量，字符串的长度不可变StringBuffer 字符串变量；长度可变（调用append方法）；对象可以扩充或修改StringBuilder字符串变量；长度可变（调用append方法）；对象可以扩充或修改6.三者都在ng包下7.StringBuffer的方法7.1 append追加信息：将添加的字符串放在缓存区的末端StringBuffer sb=new StringBuffer()sb.append(“start”)sb.append(“le”)结果是“startle”7.2 insert 在指定的下标位置添加字符（下标从0开始）sb.insert(4, "le")结果是“starlet”7.3 sb.toString() 转换为字符串String类型7.4 delete(0,sb.length())删除指定长度的内容8.StringBuilderJDK5.0新增的类可以简易替换StringBuffer要比StringBuffer速度快9.String的缺点每次对 String 类型进行改变的时候其实都等同于生成了一个新的 String 对象，然后将指针指向新的 String 对象，所以经常改变内容的字符串最好不要用 String ，因为每次生成对象都会对系统性能产生影响，特别当内存中无引用对象多了以后， JVM 的 GC （垃圾回收机制：JVM用于释放那些不再使用的对象所占用的内存）就会开始工作，那速度是一定会相当慢的。
String和StringBuffer的一些用法
String和StringBuffer的一些用法先看一个例子~~~~public class Untitled1 {public Untitled1() {}public static void main(String[] args) {Untitled1 untitled11 = new Untitled1();String s1="STRING类的值是不是会变的->";String s2=s1;System.out.println(s2);s1+="加个试试"; //String 赋值实际上这个是NEW了一个新的对象了，S1变了System.out.println(s2); //S2没有变，这是因为S2指向的地址还是最早的s1所在的地址StringBuffer b1=new StringBuffer("StringBuffer类的值是会变的->"); StringBuffer b2=b1;b2.append("加个试试");//StringBuffer赋值,操作b2还是那个对象，System.out.println(b1);//所以加一个字符进去b1指向的对象的值已经变了哦}}结果：STRING类的值是不是会变的->STRING类的值是不是会变的->StringBuffer类的值是会变的->加个试试摘录：CSDN:这里的"可变"和"不可变",和是不是final没有关系举个例子:String str1 = "hello";String str2 = "world";String str1 = str1 + str2;//这里所做的内部操作,其实不是把str1的内容改变为原str1+str2的内容这么简单, 而把创建一个新的String, 内容为str1 + str2的内容,然后再把str1这个引用重新指向新创建的String, 这就是上面说的String不可变.而如果是StringBuffer的话,则直接更改str1的内容,而不是先创建一个新的StringBuffer使用 StringBuffer 主要就是在性能上的考虑。
java string... 的用法
java string... 的用法在Java编程语言中，String类是一个非常重要的类，用于处理字符串数据。
String类提供了许多方法和功能，可以帮助开发人员更方便地操作和处理字符串数据。
本篇文章将介绍String类的一些常用方法和用法。
一、字符串连接String类提供了多种方法来连接字符串，其中最常见的方法是+运算符和StringBuilder或StringBuffer类的append()方法。
使用+运算符连接字符串非常简单，但是需要注意的是，如果需要连接的字符串数量较多，性能会受到影响，因为每次使用+运算符都会创建一个新的字符串对象。
可以使用StringBuilder或StringBuffer 类的append()方法来连接字符串，性能更高。
二、字符串比较String类提供了equals()和equalsIgnoreCase()方法来比较两个字符串是否相等。
equals()方法比较的是字符串的内容，而equalsIgnoreCase()方法比较的是字符串的内容和大小写。
除此之外，String类还提供了compareTo()和compareToIgnoreCase()方法，可以按照字典顺序比较两个字符串。
三、字符串查找String类提供了indexOf()和lastIndexOf()方法，可以查找一个字符串中某个子字符串第一次出现的位置。
indexOf()方法返回的是子字符串第一次出现的位置，而lastIndexOf()方法返回的是最后一个出现的位置。
除此之外，String类还提供了contains()方法，可以判断一个字符串是否包含另一个字符串。
四、字符串替换String类提供了replace()和replaceFirst()方法，可以用来替换字符串中的某个子字符串。
replace()方法可以替换所有出现的子字符串，而replaceFirst()方法只替换第一个出现的子字符串。
除此之外，String类还提供了substring()方法，可以用来截取字符串的一部分。
java中拼接字符串的方法
java中拼接字符串的方法Java中拼接字符串的方法在Java中，有多种方法可以拼接字符串。
1. 使用加号（+）：这是最基本的字符串拼接方法，也是最常用的方法之一。
例如：String s1 = "Hello";String s2 = "World";String s3 = s1 + s2;System.out.println(s3);输出结果为：HelloWorld需要注意的是，使用加号拼接字符串时，Java会自动创建一个新的字符串对象。
2. 使用StringBuilder或StringBuffer：StringBuffer和StringBuilder都是Java中用于处理字符串的类。
它们的作用是在构建字符串时，避免频繁地创建新的字符串对象，从而提高效率。
StringBuffer和StringBuilder的用法几乎相同，只是在多线程环境下，StringBuffer是线程安全的，而StringBuilder则不是。
以下是它们的用法：StringBuilder sb = new StringBuilder();sb.append("Hello");sb.append("World");String s = sb.toString();System.out.println(s);输出结果为：HelloWorld需要注意的是，每次调用append方法时，StringBuilder或StringBuffer对象本身被修改，而不是创建了一个新的对象。
因此，在需要拼接大量字符串时，使用StringBuilder或StringBuffer会更加高效。
3. 使用字符串格式化方法：Java中的格式化方法可以将字符串和其他数据类型（如数字、日期）组合在一起，生成新的字符串。
例如：String s = String.format("Hello, %s!", "World");System.out.println(s);输出结果为：Hello, World!需要注意的是，格式化方法是比较灵活的，可以根据需要使用不同的参数来生成字符串。