time 
设为首页】【收藏本站

白小姐高级会员料: 白小姐彩图

当前位置: 白小姐彩图 > JAVA > JAVA基础 > Java入门 > Java String之StringBuffer以及它的API的详细使用方法

Java String之StringBuffer以及它的API的详细使用方法

时间:2013-11-14 14:08 点击:3704次 字体:[ ]




StringBuffer 简介

白小姐彩图 www.5vq5o.cn StringBuffer 是一个线程安全的可变的字符序列。它继承于AbstractStringBuilder,实现了CharSequence接口。
StringBuilder 也是继承于AbstractStringBuilder的子类;但是,StringBuilder和StringBuffer不同,前者是非线程安全的,后者是线程安全的。

StringBuffer 和 CharSequence之间的关系图如下:

Java String之StringBuffer以及它的API的详细使用方法_白小姐彩图 www.5vq5o.cn


StringBuffer 函数列表

 

  1. StringBuffer()  
  2. StringBuffer(int capacity)  
  3. StringBuffer(String string)  
  4. StringBuffer(CharSequence cs)  
  5.  
  6. StringBuffer     append(boolean b)  
  7. StringBuffer     append(int i)  
  8. StringBuffer     append(long l)  
  9. StringBuffer     append(float f)  
  10. StringBuffer     append(double d)  
  11. synchronized StringBuffer     append(char ch)  
  12. synchronized StringBuffer     append(char[] chars)  
  13. synchronized StringBuffer     append(char[] chars, int start, int length)  
  14. synchronized StringBuffer     append(Object obj)  
  15. synchronized StringBuffer     append(String string)  
  16. synchronized StringBuffer     append(StringBuffer sb)  
  17. synchronized StringBuffer     append(CharSequence s)  
  18. synchronized StringBuffer     append(CharSequence s, int start, int end)  
  19. StringBuffer     appendCodePoint(int codePoint)  
  20. int     capacity()  
  21. synchronized char     charAt(int index)  
  22. synchronized int     codePointAt(int index)  
  23. synchronized int     codePointBefore(int index)  
  24. synchronized int     codePointCount(int beginIndex, int endIndex)  
  25. synchronized StringBuffer     delete(int start, int end)  
  26. synchronized StringBuffer     deleteCharAt(int location)  
  27. synchronized void     ensureCapacity(int min)  
  28. synchronized void     getChars(int start, int end, char[] buffer, int idx)  
  29. synchronized int     indexOf(String subString, int start)  
  30. int     indexOf(String string)  
  31. StringBuffer     insert(int index, boolean b)  
  32. StringBuffer     insert(int index, int i)  
  33. StringBuffer     insert(int index, long l)  
  34. StringBuffer     insert(int index, float f)  
  35. StringBuffer     insert(int index, double d)  
  36. synchronized StringBuffer     insert(int index, char ch)  
  37. synchronized StringBuffer     insert(int index, char[] chars)  
  38. synchronized StringBuffer     insert(int index, char[] chars, int start, int length)  
  39. synchronized StringBuffer     insert(int index, String string)  
  40. StringBuffer     insert(int index, Object obj)  
  41. synchronized StringBuffer     insert(int index, CharSequence s)  
  42. synchronized StringBuffer     insert(int index, CharSequence s, int start, int end)  
  43. int     lastIndexOf(String string)  
  44. synchronized int     lastIndexOf(String subString, int start)  
  45. int     length()  
  46. synchronized int     offsetByCodePoints(int index, int codePointOffset)  
  47. synchronized StringBuffer     replace(int start, int end, String string)  
  48. synchronized StringBuffer     reverse()  
  49. synchronized void     setCharAt(int index, char ch)  
  50. synchronized void     setLength(int length)  
  51. synchronized CharSequence     subSequence(int start, int end)  
  52. synchronized String     substring(int start)  
  53. synchronized String     substring(int start, int end)  
  54. synchronized String     toString()  
  55. synchronized void     trimToSize() 

StringBuffer源码(基于jdk1.7.40)

 

  1. package java.lang;  
  2.  
  3. public final class StringBuffer  
  4.     extends AbstractStringBuilder  
  5.     implements java.io.Serializable, CharSequence  
  6. {  
  7.  
  8.     static final long serialVersionUID = 3388685877147921107L;  
  9.  
  10.     public StringBuffer() {  
  11.         super(16);  
  12.     }  
  13.  
  14.     public StringBuffer(int capacity) {  
  15.         super(capacity);  
  16.     }  
  17.  
  18.     public StringBuffer(String str) {  
  19.         super(str.length() + 16);  
  20.         append(str);  
  21.     }  
  22.  
  23.     public StringBuffer(CharSequence seq) {  
  24.         this(seq.length() + 16);  
  25.         append(seq);  
  26.     }  
  27.  
  28.     public synchronized int length() {  
  29.         return count;  
  30.     }  
  31.  
  32.     public synchronized int capacity() {  
  33.         return value.length;  
  34.     }  
  35.  
  36.  
  37.     public synchronized void ensureCapacity(int minimumCapacity) {  
  38.         if (minimumCapacity > value.length) {  
  39.             expandCapacity(minimumCapacity);  
  40.         }  
  41.     }  
  42.  
  43.     public synchronized void trimToSize() {  
  44.         super.trimToSize();  
  45.     }  
  46.  
  47.     public synchronized void setLength(int newLength) {  
  48.         super.setLength(newLength);  
  49.     }  
  50.  
  51.     public synchronized char charAt(int index) {  
  52.         if ((index < 0) || (index >= count))  
  53.             throw new StringIndexOutOfBoundsException(index);  
  54.         return value[index];  
  55.     }  
  56.  
  57.     public synchronized int codePointAt(int index) {  
  58.         return super.codePointAt(index);  
  59.     }  
  60.  
  61.     public synchronized int codePointBefore(int index) {  
  62.         return super.codePointBefore(index);  
  63.     }  
  64.  
  65.     public synchronized int codePointCount(int beginIndex, int endIndex) {  
  66.         return super.codePointCount(beginIndex, endIndex);  
  67.     }  
  68.  
  69.     public synchronized int offsetByCodePoints(int index, int codePointOffset) {  
  70.         return super.offsetByCodePoints(index, codePointOffset);  
  71.     }  
  72.  
  73.     public synchronized void getChars(int srcBegin, int srcEnd, char[] dst,  
  74.                                       int dstBegin)  
  75.     {  
  76.         super.getChars(srcBegin, srcEnd, dst, dstBegin);  
  77.     }  
  78.  
  79.     public synchronized void setCharAt(int index, char ch) {  
  80.         if ((index < 0) || (index >= count))  
  81.             throw new StringIndexOutOfBoundsException(index);  
  82.         value[index] = ch;  
  83.     }  
  84.  
  85.     public synchronized StringBuffer append(Object obj) {  
  86.         super.append(String.valueOf(obj));  
  87.         return this;  
  88.     }  
  89.  
  90.     public synchronized StringBuffer append(String str) {  
  91.         super.append(str);  
  92.         return this;  
  93.     }  
  94.  
  95.     public synchronized StringBuffer append(StringBuffer sb) {  
  96.         super.append(sb);  
  97.         return this;  
  98.     }  
  99.  
  100.     public StringBuffer append(CharSequence s) {  
  101.         // Note, synchronization achieved via other invocations  
  102.         if (s == null)  
  103.             s = "null";  
  104.         if (s instanceof String)  
  105.             return this.append((String)s);  
  106.         if (s instanceof StringBuffer)  
  107.             return this.append((StringBuffer)s);  
  108.         return this.append(s, 0, s.length());  
  109.     }  
  110.  
  111.     public synchronized StringBuffer append(CharSequence s, int start, int end)  
  112.     {  
  113.         super.append(s, start, end);  
  114.         return this;  
  115.     }  
  116.  
  117.     public synchronized StringBuffer append(char[] str) {  
  118.         super.append(str);  
  119.         return this;  
  120.     }  
  121.  
  122.     public synchronized StringBuffer append(char[] str, int offset, int len) {  
  123.         super.append(str, offset, len);  
  124.         return this;  
  125.     }  
  126.  
  127.     public synchronized StringBuffer append(boolean b) {  
  128.         super.append(b);  
  129.         return this;  
  130.     }  
  131.  
  132.     public synchronized StringBuffer append(char c) {  
  133.         super.append(c);  
  134.         return this;  
  135.     }  
  136.  
  137.     public synchronized StringBuffer append(int i) {  
  138.         super.append(i);  
  139.         return this;  
  140.     }  
  141.  
  142.     public synchronized StringBuffer appendCodePoint(int codePoint) {  
  143.         super.appendCodePoint(codePoint);  
  144.         return this;  
  145.     }  
  146.  
  147.     public synchronized StringBuffer append(long lng) {  
  148.         super.append(lng);  
  149.         return this;  
  150.     }  
  151.  
  152.     public synchronized StringBuffer append(float f) {  
  153.         super.append(f);  
  154.         return this;  
  155.     }  
  156.  
  157.     public synchronized StringBuffer append(double d) {  
  158.         super.append(d);  
  159.         return this;  
  160.     }  
  161.  
  162.     public synchronized StringBuffer delete(int start, int end) {  
  163.         super.delete(start, end);  
  164.         return this;  
  165.     }  
  166.  
  167.     public synchronized StringBuffer deleteCharAt(int index) {  
  168.         super.deleteCharAt(index);  
  169.         return this;  
  170.     }  
  171.  
  172.     public synchronized StringBuffer replace(int start, int end, String str) {  
  173.         super.replace(start, end, str);  
  174.         return this;  
  175.     }  
  176.  
  177.     public synchronized String substring(int start) {  
  178.         return substring(start, count);  
  179.     }  
  180.  
  181.     public synchronized CharSequence subSequence(int start, int end) {  
  182.         return super.substring(start, end);  
  183.     }  
  184.  
  185.     public synchronized String substring(int start, int end) {  
  186.         return super.substring(start, end);  
  187.     }  
  188.  
  189.     public synchronized StringBuffer insert(int index, char[] str, int offset,  
  190.                                             int len)  
  191.     {  
  192.         super.insert(index, str, offset, len);  
  193.         return this;  
  194.     }  
  195.  
  196.     public synchronized StringBuffer insert(int offset, Object obj) {  
  197.         super.insert(offset, String.valueOf(obj));  
  198.         return this;  
  199.     }  
  200.  
  201.     public synchronized StringBuffer insert(int offset, String str) {  
  202.         super.insert(offset, str);  
  203.         return this;  
  204.     }  
  205.  
  206.     public synchronized StringBuffer insert(int offset, char[] str) {  
  207.         super.insert(offset, str);  
  208.         return this;  
  209.     }  
  210.  
  211.     public StringBuffer insert(int dstOffset, CharSequence s) {  
  212.         // Note, synchronization achieved via other invocations  
  213.         if (s == null)  
  214.             s = "null";  
  215.         if (s instanceof String)  
  216.             return this.insert(dstOffset, (String)s);  
  217.         return this.insert(dstOffset, s, 0, s.length());  
  218.     }  
  219.  
  220.     public synchronized StringBuffer insert(int dstOffset, CharSequence s,  
  221.                                             int start, int end)  
  222.     {  
  223.         super.insert(dstOffset, s, start, end);  
  224.         return this;  
  225.     }  
  226.  
  227.     public StringBuffer insert(int offset, boolean b) {  
  228.         return insert(offset, String.valueOf(b));  
  229.     }  
  230.  
  231.     public synchronized StringBuffer insert(int offset, char c) {  
  232.         super.insert(offset, c);  
  233.         return this;  
  234.     }  
  235.  
  236.     public StringBuffer insert(int offset, int i) {  
  237.         return insert(offset, String.valueOf(i));  
  238.     }  
  239.  
  240.     public StringBuffer insert(int offset, long l) {  
  241.         return insert(offset, String.valueOf(l));  
  242.     }  
  243.  
  244.     public StringBuffer insert(int offset, float f) {  
  245.         return insert(offset, String.valueOf(f));  
  246.     }  
  247.  
  248.     public StringBuffer insert(int offset, double d) {  
  249.         return insert(offset, String.valueOf(d));  
  250.     }  
  251.  
  252.     public int indexOf(String str) {  
  253.         return indexOf(str, 0);  
  254.     }  
  255.  
  256.     public synchronized int indexOf(String str, int fromIndex) {  
  257.         return String.indexOf(value, 0, count,  
  258.                               str.toCharArray(), 0, str.length(), fromIndex);  
  259.     }  
  260.  
  261.     public int lastIndexOf(String str) {  
  262.         // Note, synchronization achieved via other invocations  
  263.         return lastIndexOf(str, count);  
  264.     }  
  265.  
  266.     public synchronized int lastIndexOf(String str, int fromIndex) {  
  267.         return String.lastIndexOf(value, 0, count,  
  268.                               str.toCharArray(), 0, str.length(), fromIndex);  
  269.     }  
  270.  
  271.     public synchronized StringBuffer reverse() {  
  272.         super.reverse();  
  273.         return this;  
  274.     }  
  275.  
  276.     public synchronized String toString() {  
  277.         return new String(value, 0, count);  
  278.     }  
  279.  
  280.     private static final java.io.ObjectStreamField[] serialPersistentFields =  
  281.     {  
  282.         new java.io.ObjectStreamField("value"char[].class),  
  283.         new java.io.ObjectStreamField("count", Integer.TYPE),  
  284.         new java.io.ObjectStreamField("shared", Boolean.TYPE),  
  285.     };  
  286.  
  287.     private synchronized void writeObject(java.io.ObjectOutputStream s)  
  288.         throws java.io.IOException {  
  289.         java.io.ObjectOutputStream.PutField fields = s.putFields();  
  290.         fields.put("value", value);  
  291.         fields.put("count", count);  
  292.         fields.put("shared"false);  
  293.         s.writeFields();  
  294.     }  
  295.  
  296.     private void readObject(java.io.ObjectInputStream s)  
  297.         throws java.io.IOException, ClassNotFoundException {  
  298.         java.io.ObjectInputStream.GetField fields = s.readFields();  
  299.         value = (char[])fields.get("value"null);  
  300.         count = fields.get("count"0);  
  301.     }  



本文地址 : //www.5vq5o.cn/plus/view-214079-1.html
标签: java String StringBuffer
------分隔线----------------------------
最新评论 查看所有评论
发表评论 查看所有评论
请自觉遵守互联网相关的政策法规,严禁发布色情、暴力、反动的言论。
评价:
表情:
验证码:

  • Valentino 2017秋冬高级定制大秀 2018-09-08
  • 中国经济充当了世界经济发展的火车头。但是,作为世界经济火车头的中国,在世界主要经济体股市都走牛的情况下,为何熊途漫漫?这种不正常的现象,背后是我们资本市场的投融 2018-07-14
  • 别空谈,说说看,这个“简单的逻辑关系”是什么关系? 2018-07-13
  • “讲课带着泥土味,我们都爱听” 2018-07-13
  • 习近平:绿水青山就是金山银山 2018-07-12
  • 端午思屈原,为什么《橘颂》是一篇伟大的作品 2018-07-11
  • 2018年焉耆县旅游美食文化推介会在库尔勒市举行 2018-07-10
  • 《中国气候变化蓝皮书》:年平均气温显著上升 2018-07-10
  • 24小时智能无人便利店落户唐山 2018-07-09
  • 理货员忙不过来 宁波球迷把啤酒销量喝成井喷状态 2018-07-09
  • 回复@寻找失落的真理:跟你的铁环玩去!咱真的没兴趣碾压你也。 2018-07-08
  • 易烊千玺押中高考作文题?不仅会押,今年还唱过! 2018-07-07
  • 【北京达世行世纪车型报价】北京达世行世纪4S店车型价格 2018-07-06
  • 欢迎访问《北京体育大学学报》编辑部网站 2018-07-05
  • 967| 972| 671| 870| 816| 813| 913| 76| 191| 452|