程序博客网 > mysql数据备份方案

Android(java):StringBuffer StringBulider区别

来源：互联网 发布：mysql数据备份方案 编辑：程序博客网 时间：2024/05/16 05:48

java数组复制 System.copyarray()方法

System.copyarray()方法可以用来复制数组，其格式是：

System.arraycopy(Object src, int src_position, Object dst, int dst_position, int length)

它将数组从src 复制到dst，复制的位置是src 的第src_position 个元素到dst 的第dst_position

位置，复制元素的个数为length。

注意：该方法只复制元素。如果数组元素是引用型变量，则只复制引用，不复制对象

实体。

 
StringBuffer 字符串变量（线程安全）
StringBuilder 字符串变量（非线程安全）

String 类型和 StringBuffer 、StringBuilder 类型的主要性能区别其实在于 String 是不可变的对象，而后俩者都是可变的。

来看看 StringBuffer类源码定义：

Java代码 复制代码收藏代码
  1.   
  2. public finalclass StringBuffer 
  3.     extends AbstractStringBuilder 
  4.     implements java.io.Serializable, CharSequence 
  5. { 
  6.  
  7.     public StringBuffer() { 
  8.     super(16); 
  9.     } 
  10.  
  11.      public StringBuffer(int capacity) { 
  12.     super(capacity); 
  13.     } 
[java] view plaincopyprint?
  1. <STRONG>   
  2. public final class StringBuffer  
  3.     extends AbstractStringBuilder  
  4.     implements java.io.Serializable, CharSequence  
  5. {  
  6.   
  7.     public StringBuffer() {  
  8.     super(16);  
  9.     }  
  10.   
  11.      public StringBuffer(int capacity) {  
  12.     super(capacity);  
  13.     }  
  14. </STRONG>  
 public final class StringBuffer    extends AbstractStringBuilder    implements java.io.Serializable, CharSequence{    public StringBuffer() {super(16);    }     public StringBuffer(int capacity) {super(capacity);    }


上例代码我们发现 StringBuffer 继承了 AbstractStringBuilder抽象类。包括构造方法的实现，都是父类提供的。

然后，我们打开 StringBuilder源码定义：

Java代码 复制代码收藏代码
  1. public finalclass StringBuilder 
  2.     extends AbstractStringBuilder 
  3.     implements java.io.Serializable, CharSequence 
  4. { 
  5.  
  6.     public StringBuilder() { 
  7.     super(16); 
  8.     } 
  9.  
  10.     public StringBuilder(int capacity) { 
  11.     super(capacity); 
  12.     } 
[java] view plaincopyprint?
  1. <STRONG>public final class StringBuilder  
  2.     extends AbstractStringBuilder  
  3.     implements java.io.Serializable, CharSequence  
  4. {  
  5.   
  6.     public StringBuilder() {  
  7.     super(16);  
  8.     }  
  9.   
  10.     public StringBuilder(int capacity) {  
  11.     super(capacity);  
  12.     }  
  13. </STRONG>  
public final class StringBuilder    extends AbstractStringBuilder    implements java.io.Serializable, CharSequence{    public StringBuilder() {super(16);    }    public StringBuilder(int capacity) {super(capacity);    }

我们发现两者都继承了AbstractStringBuilder抽象类。且构造方法都调用父类实现。

我们接着看两者append方法实现：

先看StringBuffer的：

Java代码 复制代码收藏代码
  1.    
  2. public synchronized StringBuffer append(Object obj) { 
  3.        super.append(String.valueOf(obj)); 
  4.        return this; 
  5.    } 
  6.  
  7.    public synchronized StringBuffer append(String str) { 
  8.        super.append(str); 
  9.        return this; 
  10.    } 
  11.    //... 
[java] view plaincopyprint?
  1. <STRONG>     
  2.  public synchronized StringBuffer append(Object obj) {  
  3.         super.append(String.valueOf(obj));  
  4.         return this;  
  5.     }  
  6.   
  7.     public synchronized StringBuffer append(String str) {  
  8.         super.append(str);  
  9.         return this;  
  10.     }  
  11.     //...   
  12. </STRONG>  
    public synchronized StringBuffer append(Object obj) {        super.append(String.valueOf(obj));        return this;    }    public synchronized StringBuffer append(String str) {        super.append(str);        return this;    }    //...


再看StringBuilder的：
Java代码 复制代码收藏代码
  1. public StringBuilder append(Object obj) { 
  2.     return append(String.valueOf(obj)); 
  3. } 
  4.  
  5. public StringBuilder append(String str) { 
  6.     super.append(str); 
  7.     return this; 
  8. } 
  9. //... 
[java] view plaincopyprint?
  1. <STRONG>      
  2.     public StringBuilder append(Object obj) {  
  3.         return append(String.valueOf(obj));  
  4.     }  
  5.   
  6.     public StringBuilder append(String str) {  
  7.         super.append(str);  
  8.         return this;  
  9.     }  
  10.     //...   
  11. </STRONG>  
        public StringBuilder append(Object obj) {        return append(String.valueOf(obj));    }    public StringBuilder append(String str) {        super.append(str);        return this;    }    //...


对比上面两段源码 我们发现 StirngBuffer 和StringBuilder的 append实现都是调用父类实现的。唯一不同的是 StringBuffer是线程安全的，方法中多了synchronized ，而StringBuilder 是非线程安全的。

我们看下父类AbstractStringBuilder 定义 及 append 实现：

Java代码 复制代码收藏代码
  1. abstract class AbstractStringBuilderimplements Appendable, CharSequence { 
  2.     //底层与String类一样都是 char类型数组。 
  3.     char value[]; 
  4.     //字符串长度 
  5.     int count; 
  6.  
  7.     AbstractStringBuilder() { 
  8.     } 
  9.  
  10.     AbstractStringBuilder(int capacity) { 
  11.         value = new char[capacity]; 
  12.     } 
[java] view plaincopyprint?
  1. <STRONG>abstract class AbstractStringBuilder implements Appendable, CharSequence {  
  2.     //底层与String类一样都是 char类型数组。   
  3.     char value[];  
  4.     //字符串长度   
  5.     int count;  
  6.   
  7.     AbstractStringBuilder() {  
  8.     }  
  9.   
  10.     AbstractStringBuilder(int capacity) {  
  11.         value = new char[capacity];  
  12.     }  
  13. </STRONG>  
abstract class AbstractStringBuilder implements Appendable, CharSequence {    //底层与String类一样都是 char类型数组。    char value[];    //字符串长度    int count;    AbstractStringBuilder() {    }    AbstractStringBuilder(int capacity) {        value = new char[capacity];    }


Java代码 复制代码收藏代码
  1. public AbstractStringBuilder append(Object obj) { 
  2.     return append(String.valueOf(obj)); 
  3. } 
  4.  
  5. public AbstractStringBuilder append(String str) { 
  6.     //对于str==null的 
  7.     if (str == null) str ="null"; 
  8.     int len = str.length(); 
  9.     if (len == 0)returnthis; 
  10.     //新的字符串长度 
  11.     int newCount = count + len; 
  12.     if (newCount > value.length) 
  13.          //当新的字符串长度比原先数组长度大时，需要对char 数组扩容。 
  14.            expandCapacity(newCount); 
  15.     //将新添的数据追加到char类型数组中。 
  16.      str.getChars(0, len, value, count); 
  17.     count = newCount; 
  18.     return this; 
  19. } 
  20.  
  21. //数组扩容  
  22. void expandCapacity(int minimumCapacity) { 
  23.     //先扩容成 (原先的长度+1）*2 
  24.     int newCapacity = (value.length +1) *2; 
  25.     //判断newCapacity值是否满足要求 
  26.      //如果新的长度还是不够，则直接取值 minimumCapacity  
  27.     if (newCapacity < 0) { 
  28.        newCapacity = Integer.MAX_VALUE; 
  29.     } else if (minimumCapacity > newCapacity) { 
  30.        newCapacity = minimumCapacity; 
  31.     }    
  32.     char newValue[] = new char[newCapacity]; 
  33.     //将原先的数据拷贝到新的char 数组中。 
  34.      System.arraycopy(value, 0, newValue,0, count); 
  35.     value = newValue; 
  36. } 
  37.  
  38. public void getChars(int srcBegin,int srcEnd,char dst[],int dstBegin) { 
  39.     if (srcBegin < 0) { 
  40.         throw new StringIndexOutOfBoundsException(srcBegin); 
  41.     } 
  42.     if (srcEnd > count) { 
  43.         throw new StringIndexOutOfBoundsException(srcEnd); 
  44.     } 
  45.     if (srcBegin > srcEnd) { 
  46.         throw new StringIndexOutOfBoundsException(srcEnd - srcBegin); 
  47.     } 
  48.     System.arraycopy(value, offset + srcBegin, dst, dstBegin, 
  49.          srcEnd - srcBegin); 
  50. } 

StringBuffer与StringBuilder是java.lang包下被大家熟知的两个类。其异同为：一、长度都是可扩充的；二、StringBuffer是线程安全的，StringBuilder是线程不安全的。那么他们的长度是如何实现动态扩充以及StringBuffer的线程安全是如何实现的呢？通过“深度”阅读它们的源代码，最终弄明白其中的缘由。

正文

首先上一张StringBuffer和StringBuilder类结构图：


抽象类AbstractStringBuilder（也是核心实现类）实现了Appendable和CharSequence两个接口；StringBuffer与StringBuilder统统继承自AbstractStringBuilder，并且实现了java.io.Serializable和CharSequence接口。

下面简单描述下这几个接口所起到的作用(引用自中文api)。

  • Appendable：能够被添加 char 序列和值的对象。如果某个类的实例打算接收java.util.Formatter 的格式化输出，那么该类必须实现 Appendable 接口
    。要添加的字符应该是有效的 Unicode 字符，正如 Unicode Character Representation 中描述的那样。注意，增补字符可能由多个 16 位char 值组成
  • CharSequence：CharSequence 是 char 值的一个可读序列。此接口对许多不同种类的 char 序列提供统一的只读访问。char 值表示 Basic Multilingual Plane (BMP) 或代理项中的一个字符。有关详细信息，请参阅Unicode 字符表示形式。此接口不修改equals 和hashCode 方法的常规协定。因此，通常未定义比较实现 CharSequence 的两个对象的结果。每个对象都可以通过一个不同的类实现，而且不能保证每个类能够测试其实例与其他类的实例的相等性。因此，使用任意 CharSequence 实例作为集合中的元素或映射中的键是不合适的。
  • Serializable：类通过实现 java.io.Serializable 接口以启用其序列化功能。未实现此接口的类将无法使其任何状态序列化或反序列化。可序列化类的所有子类型本身都是可序列化的。序列化接口没有方法或字段，仅用于标识可序列化的语义。
  • AbstractStringBuilde
    r这个抽象类提供了StringBuffer和StringBuilder绝大部分的实现。在AbstractStringBuilder的描述中说：如果去掉线程安全，那么StringBuffer和StringBuilder是完全一致的。从实现的角度来说，StringBuffer所有方法(构造方法除外，因为没有必要)签名中都使用synchronized限定，也就是所有的方法都是同步的。

eg.StringBuffer中replace()方法

view sourceprint?
1public synchronized StringBuffer replace(intstart,int end, String str) {
2super.replace(start, end, str);
3return this;
4}

StringBuilder中replace()：

view sourceprint?
1public StringBuilder replace(intstart,int end, String str) {
2super.replace(start, end, str);
3return this;
4}

区别仅仅在方法签名上是否有synchronized。

另外需要稍稍注意的问题是：StringBuffer同步只同步目标，比如：sb.append("i am not synchronized"),sb是同步的，而其中的参数未必是同步的。

而它们两个可扩展长度则是通过ensureCapacity(int minimumCapacity)来验证当前长度是否小于参数minimumCapacity，如果成立则进行分配空间。分配新空间的步长为（当前长度+1）的两倍。

实现如下：

view sourceprint?
01public void ensureCapacity(intminimumCapacity) {
02if (minimumCapacity > value.length) {
03expandCapacity(minimumCapacity);
04}
05}
06void expandCapacity(int minimumCapacity) {
07int newCapacity = (value.length + 1) *2;
08if (newCapacity < 0) {
09newCapacity = Integer.MAX_VALUE;
10} else if (minimumCapacity > newCapacity) {
11newCapacity = minimumCapacity;
12}
13value = Arrays.copyOf(value, newCapacity);
14}

如果新的长度小于0(溢出了)，则使用Integer的最大值作为长度。

另外，在阅读源码的过程中，发现两个有趣的问题，下面一一道来。

第一个，就是reverse的实现。其实我是第一次看StringBuilder和StringBuffer的源码，这里面的reverse的实现是我所知道的java中的最高效的实现，没有之一。

上源码，再做解释：

view sourceprint?
01public AbstractStringBuilder reverse() {
02boolean hasSurrogate = false;
03int n = count - 1;
04for (int j = (n-1) >>1; j >=0; --j) {
05char temp = value[j];
06char temp2 = value[n - j];
07if (!hasSurrogate) {
08hasSurrogate = (temp >= Character.MIN_SURROGATE && temp <= Character.MAX_SURROGATE)
09|| (temp2 >= Character.MIN_SURROGATE && temp2 <= Character.MAX_SURROGATE);
10}
11value[j] = temp2;
12value[n - j] = temp;
13}
14if (hasSurrogate) {
15// Reverse back all valid surrogate pairs
16for (int i = 0; i < count -1; i++) {
17char c2 = value[i];
18if (Character.isLowSurrogate(c2)) {
19char c1 = value[i + 1];
20if (Character.isHighSurrogate(c1)) {
21value[i++] = c1;
22value[i] = c2;
23}
24}
25}
26}
27return this;
28}

reverse分成两个部分：前面一个循环与后面的判断。

首先地一个循环很高效，循环次数为长度(count)的一半，而且使用>>位移运算，交换数组value[j]与value[n-j]的值。这里一是循环次数少，而是使用最高效的位移运算所以说这个reverse很高效。在反转过程中还完成了一件事：就是为hasSurrogate赋值。赋值的依据就是value[j]与value[n-j]两个字符时候有一个在\uD800和\uDFFF之间，如果有则赋值为true。

 

[java] view plaincopyprint?
  1. <STRONG>      
  2.     public AbstractStringBuilder append(Object obj) {  
  3.         return append(String.valueOf(obj));  
  4.     }  
  5.       
  6.     public AbstractStringBuilder append(String str) {  
  7.         //对于str==null的   
  8.         if (str == null) str = "null";  
  9.         int len = str.length();  
  10.         if (len == 0) return this;  
  11.         //新的字符串长度   
  12.         int newCount = count + len;  
  13.         if (newCount > value.length)  
  14.              //当新的字符串长度比原先数组长度大时，需要对char 数组扩容。  
  15.                expandCapacity(newCount);  
  16.         //将新添的数据追加到char类型数组中。   
  17.          str.getChars(0, len, value, count);  
  18.         count = newCount;  
  19.         return this;  
  20.     }  
  21.       
  22.     //数组扩容    
  23.     void expandCapacity(int minimumCapacity) {  
  24.         //先扩容成 (原先的长度+1）*2   
  25.         int newCapacity = (value.length + 1) * 2;  
  26.         //判断newCapacity值是否满足要求   
  27.          //如果新的长度还是不够，则直接取值 minimumCapacity   
  28.         if (newCapacity < 0) {  
  29.            newCapacity = Integer.MAX_VALUE;  
  30.         } else if (minimumCapacity > newCapacity) {  
  31.            newCapacity = minimumCapacity;  
  32.         }     
  33.         char newValue[] = new char[newCapacity];  
  34.         //将原先的数据拷贝到新的char 数组中。   
  35.          System.arraycopy(value, 0, newValue, 0, count);  
  36.         value = newValue;  
  37.     }  
  38.   
  39.      public void getChars(int srcBegin, int srcEnd, char dst[], int dstBegin) {  
  40.         if (srcBegin < 0) {  
  41.             throw new StringIndexOutOfBoundsException(srcBegin);  
  42.         }  
  43.         if (srcEnd > count) {  
  44.             throw new StringIndexOutOfBoundsException(srcEnd);  
  45.         }  
  46.         if (srcBegin > srcEnd) {  
  47.             throw new StringIndexOutOfBoundsException(srcEnd - srcBegin);  
  48.         }  
  49.         System.arraycopy(value, offset + srcBegin, dst, dstBegin,  
  50.              srcEnd - srcBegin);  
  51.     }  
  52. </STRONG>  
        public AbstractStringBuilder append(Object obj) {        return append(String.valueOf(obj));    }        public AbstractStringBuilder append(String str) {        //对于str==null的        if (str == null) str = "null";        int len = str.length();        if (len == 0) return this;        //新的字符串长度        int newCount = count + len;        if (newCount > value.length)             //当新的字符串长度比原先数组长度大时，需要对char 数组扩容。               expandCapacity(newCount);        //将新添的数据追加到char类型数组中。         str.getChars(0, len, value, count);        count = newCount;        return this;    }        //数组扩容     void expandCapacity(int minimumCapacity) {        //先扩容成 (原先的长度+1）*2        int newCapacity = (value.length + 1) * 2;        //判断newCapacity值是否满足要求         //如果新的长度还是不够，则直接取值 minimumCapacity         if (newCapacity < 0) {           newCapacity = Integer.MAX_VALUE;        } else if (minimumCapacity > newCapacity) {           newCapacity = minimumCapacity;        }        char newValue[] = new char[newCapacity];        //将原先的数据拷贝到新的char 数组中。         System.arraycopy(value, 0, newValue, 0, count);        value = newValue;    }     public void getChars(int srcBegin, int srcEnd, char dst[], int dstBegin) {        if (srcBegin < 0) {            throw new StringIndexOutOfBoundsException(srcBegin);        }        if (srcEnd > count) {            throw new StringIndexOutOfBoundsException(srcEnd);        }        if (srcBegin > srcEnd) {            throw new StringIndexOutOfBoundsException(srcEnd - srcBegin);        }        System.arraycopy(value, offset + srcBegin, dst, dstBegin,             srcEnd - srcBegin);    }

mysql数据备份方案 mysql数据备份方案
原创粉丝点击
热门IT博客
平板可以开淘宝店吗平板可以开淘宝店吗
天涯和知乎天涯和知乎
工作任务分配源码
sql 查询每小时数据量
助创cms众筹系统源码
mysql怎么删除函数
淘宝商城天天特价
淘宝新店活动方案
mac containers文件夹
2017年旅游业数据分析
淘宝店铺发布不了宝贝
linux ftp配置
淘宝加盟商靠谱吗
win10磁盘优化不能用
sql having order by
dota2手机直播软件
linux samba 用户权限
pdf怎么转换成txt知乎
淘宝女装进货攻略
游戏手柄软件下载
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 尖山新区 台山新楼盘 马来西亚新山旅游攻略 新山旅游攻略 都会新峰 新峰社区 新峰 手机rom下载 手机rom 新墨西哥州 州加偏旁组新字再组词 蔚县新蔚州宾馆 新州花苑二手房 兴义新州医院网上挂号 新州 新工集团 唐山古冶新工村楼房价格多少 新币 2019新币 新经币 新币图片 2019新币图片 2019年新币 2019新币图 1000000迷你币激活码新 新币购买力 新市觉影院 新市古镇 新市 新市镇 新市区 新市墟 广州新市 新市街道 0608新市觉影院 乌鲁木齐新市区邮编 新市古镇旅游 乌鲁木齐新市区 广州新市医院 新希 新平之窗

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里