【Java基础】Java常见几组概念的比较(String、StringBuilder、StringBuffer、HashMap、HashTable

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/yuanmxiang/article/details/68539505

一、String、StringBuilder、StringBuffer的区别

String是字符串常量,StringBuffer和StringBuilder是字符串变量。

  • StringBuilder 线程不安全的字符产变量,一般来说效率高
  • StringBuffer 线程安全的字符串变量
StringBuffer部分源码
// StirngBuffer 的方法,同步的,线程安全
public synchronized StringBuffer append(Object obj) {
toStringCache = null;
super.append(String.valueOf(obj));
return this;
}
StringBuilder 的部分源码
//StringBuilder的方法,非同步,线程不安全,较高效率
public StringBuilder append(char[] str) {
super.append(str);
return this;
}
在每次对 String 类型进行改变的时候其实都等同于生成了一个新的 String 对象,然后将指针指向新的 String 对象。
StringBuilder和StringBuffer每次都对对象本身进行操作。


二、HashMap 和 Hashtable

  • HashMap 线程不安全,效率高
  • Hashtable 线程安全
//HashTable源码,线程安全
public synchronized boolean containsKey(Object key) {
Entry<?,?> tab[] = table;
int hash = key.hashCode();
int index = (hash & 0x7FFFFFFF) % tab.length;
for (Entry<?,?> e = tab[index] ; e != null ; e = e.next) {
if ((e.hash == hash) && e.key.equals(key)) {
return true;
}
}
return false;
}
//HashMap源码,线程不安全,效率高
public boolean containsKey(Object key) {
return getNode(hash(key), key) != null;
}
三、抽象类和接口的区别
  • 1、抽象类单继承,接口可以多继承。
  • 2、抽象类既能有抽象方法又能有非抽象方法,还能定义一般的属性;接口只能有抽象方法,接口中定义的属性全部都是static final修饰的。
abstract class AA{
public int a = 0; //抽象类中的一般属性
public int play(){
return 0;
}//非抽象方法
abstract int say(); //抽象方法
}
class BB extends AA{ 
@Override
int say() {
return 0;
}
}
interface CC {
public final static int a=1; //接口中的属性 静态不可修改
void say(); //默认 public abstract 修饰
}
class DD implements CC {
@Override
public void say() { 
}
}


JAVAStringStringBuffer 、StringBuilder的区别

06-09

String和StringBuffer的区别,网上资料可以说是数不胜数,但是看到这篇文章,感觉里面做的小例子很有代表性,所以转一下,并自己做了一点总结。rnrn在java中有3个类来负责字符的操作。rnrn1.Character 是进行单个字符操作的,rnrn2.String 对一串字符进行操作。不可变类。rnrn3.StringBuffer 也是对一串字符进行操作,但是可变类。rnrnString:rn是对象不是原始类型.rn为不可变对象,一旦被创建,就不能修改它的值.rn对于已经存在的String对象的修改都是重新创建一个新的对象,然后把新的值保存进去.rnString 是final类,即不能被继承.rnrnStringBuffer:rn是一个可变对象,当对他进行修改的时候不会像String那样重新建立对象rn它只能通过构造函数来建立,rnStringBuffer sb = new StringBuffer();rnnote:不能通过付值符号对他进行付值.rnsb = "welcome to here!";//errorrn对象被建立以后,在内存中就会分配内存空间,并初始保存一个null.向StringBufferrn中付值的时候可以通过它的append方法.rnsb.append("hello");rnrn字符串连接操作中StringBuffer的效率要比String高:rnrnString str = new String("welcome to ");rnstr += "here";rn的处理步骤实际上是通过建立一个StringBuffer,让侯调用append(),最后rn再将StringBuffer toSting();rn这样的话String的连接操作就比StringBuffer多出了一些附加操作,当然效率上要打折扣.rnrn并且由于String 对象是不可变对象,每次操作Sting 都会重新建立新的对象来保存新的值.rn这样原来的对象就没用了,就要被垃圾回收.这也是要影响性能的.rnrn看看以下代码:rn将26个英文字母重复加了5000次,rnrn String tempstr = "abcdefghijklmnopqrstuvwxyz";rn int times = 5000;rn long lstart1 = System.currentTimeMillis();rn String str = "";rn for (int i = 0; i < times; i++) rn str += tempstr;rn rn long lend1 = System.currentTimeMillis();rn long time = (lend1 - lstart1);rn System.out.println(time);rn可惜我的计算机不是超级计算机,得到的结果每次不一定一样一般为 46687左右。rn也就是46秒。rn我们再看看以下代码rnrn String tempstr = "abcdefghijklmnopqrstuvwxyz";rn int times = 5000;rn long lstart2 = System.currentTimeMillis();rn StringBuffer sb = new StringBuffer();rn for (int i = 0; i < times; i++) rn sb.append(tempstr);rn rn long lend2 = System.currentTimeMillis();rn long time2 = (lend2 - lstart2);rn System.out.println(time2);rn得到的结果为 16 有时还是 0rn所以结论很明显,StringBuffer 的速度几乎是String 上万倍。当然这个数据不是很准确。因为循环的次数在100000次的时候,差异更大。不信你试试。rnrn根据上面所说:rnrnstr += "here";rn的处理步骤实际上是通过建立一个StringBuffer,让侯调用append(),最后rn再将StringBuffer toSting();rnrn所以str += "here";可以等同于rnrnStringBuffer sb = new StringBuffer(str);rnrnsb.append("here");rnrnstr = sb.toString();rnrn所以上面直接利用"+"来连接String的代码可以基本等同于以下代码rnrn String tempstr = "abcdefghijklmnopqrstuvwxyz";rn int times = 5000;rn long lstart2 = System.currentTimeMillis();rn String str = "";rn for (int i = 0; i < times; i++) rn StringBuffer sb = new StringBuffer(str);rn sb.append(tempstr);rn str = sb.toString();rn rn long lend2 = System.currentTimeMillis();rn long time2 = (lend2 - lstart2);rn System.out.println(time2);rn平均执行时间为46922左右,也就是46秒。rnrn本文来自CSDN博客,转载请标明出处:http://blog.csdn.net/yirentianran/archive/2008/09/03/2871417.aspxrnrnStringBuffer维护了一个大小固定的字符串缓冲区,当字符串长度超过StringBuffer大小时会自动增加,主要使用Insert和append方法,对于运行期要进行字符串的组装操作推荐使用,rnrn StringBuilder: jdk5以后有个和StringBuffer等价的StringBuider,区别在于StringBuffer是线程安全的,StringBuilder是单线程的,不提供同步,理论上效率更高。rnrn String是系统内置类型,而且是final的,定义一个字符串会产生一个实例和一个对该实例地址的引用。rnrn 如果在编译期间定义的字符串,例如 :rnrn String a = "name";rn a += "is";rn a += "good";rnrn 尽管这种方法是不被推荐的,但在编译期,编译器会对该代码进行优化,所以还是可以理解为:String a = "name is good";而如果在此时采用StringBuffer,反而会推迟到运行期才会被处理,相比之下,反而会比StringBuffer效率更高,灵活运用。rnString 字符串常量rnStringBuffer 字符串变量(线程安全)rnStringBuilder 字符串变量(非线程安全)rn 简要的说, String 类型和 StringBuffer 类型的主要性能区别其实在于 String 是不可变的对象, 因此在每次对 String 类型进行改变的时候其实都等同于生成了一个新的 String 对象,然后将指针指向新的 String 对象,所以经常改变内容的字符串最好不要用 String ,因为每次生成对象都会对系统性能产生影响,特别当内存中无引用对象多了以后, JVM 的 GC 就会开始工作,那速度是一定会相当慢的。rn 而如果是使用 StringBuffer 类则结果就不一样了,每次结果都会对 StringBuffer 对象本身进行操作,而不是生成新的对象,再改变对象引用。所以在一般情况下我们推荐使用 StringBuffer ,特别是字符串对象经常改变的情况下。而在某些特别情况下, String 对象的字符串拼接其实是被 JVM 解释成了 StringBuffer 对象的拼接,所以这些时候 String 对象的速度并不会比 StringBuffer 对象慢,而特别是以下的字符串对象生成中, String 效率是远要比 StringBuffer 快的:rn String S1 = “This is only a” + “ simple” + “ test”;rn StringBuffer Sb = new StringBuilder(“This is only a”).append(“ simple”).append(“ test”);rn 你会很惊讶的发现,生成 String S1 对象的速度简直太快了,而这个时候 StringBuffer 居然速度上根本一点都不占优势。其实这是 JVM 的一个把戏,在 JVM 眼里,这个rn String S1 = “This is only a” + “ simple” + “test”; 其实就是:rn String S1 = “This is only a simple test”; 所以当然不需要太多的时间了。但大家这里要注意的是,如果你的字符串是来自另外的 String 对象的话,速度就没那么快了,譬如:rnString S2 = “This is only a”;rnString S3 = “ simple”;rnString S4 = “ test”;rnString S1 = S2 +S3 + S4;rn这时候 JVM 会规规矩矩的按照原来的方式去做rnrn在大部分情况下 StringBuffer > StringrnStringBufferrnJava.lang.StringBuffer线程安全的可变字符序列。一个类似于 String 的字符串缓冲区,但不能修改。虽然在任意时间点上它都包含某种特定的字符序列,但通过某些方法调用可以改变该序列的长度和内容。rn可将字符串缓冲区安全地用于多个线程。可以在必要时对这些方法进行同步,因此任意特定实例上的所有操作就好像是以串行顺序发生的,该顺序与所涉及的每个线程进行的方法调用顺序一致。rnStringBuffer 上的主要操作是 append 和 insert 方法,可重载这些方法,以接受任意类型的数据。每个方法都能有效地将给定的数据转换成字符串,然后将该字符串的字符追加或插入到字符串缓冲区中。 append 方法始终将这些字符添加到缓冲区的末端;而 insert 方法则在指定的点添加字符。rn例如,如果 z 引用一个当前内容是“start”的字符串缓冲区对象,则此方法调用 z.append("le") 会使字符串缓冲区包含“startle”,而 z.insert(4, "le") 将更改字符串缓冲区,使之包含“starlet”。rn在大部分情况下 StringBuilder > StringBufferrnjava.lang.StringBuildernjava.lang.StringBuilder 一个可变的字符序列是5.0新增的。此类提供一个与 StringBuffer 兼容的 API,但不保证同步。该类被设计用作 StringBuffer 的一个简易替换,用在字符串缓冲区被单个线程使用的时候(这种情况很普遍)。如果可能,建议优先采用该类,因为在大多数实现中,它比 StringBuffer 要快。两者的方法基本相同。rn通过非官方试验测试,StringBuilder和StringBuffer的测试总结如下:rnrn1. 为了获得更好的性能,在构造 StirngBuffer 或 StirngBuilder 时应尽可能指定它的容量。当然,如果你操作的字符串长度不超过 16 个字符就不用了。rnrn2. 相同情况下使用 StirngBuilder 相比使用 StringBuffer 仅能获得 10%~15% 左右的性能提升,但却要冒多线程不安全的风险。而在现实的模块化编程中,负责某一模块的程序员不一定能清晰地判断该模块是否会放入多线程的环境中运行,因此:除非你能确定你的系统的瓶颈是在 StringBuffer 上,并且确定你的模块不会运行在多线程模式下,否则还是用 StringBuffer 吧 Jrnrn3. 用好现有的类比引入新的类更重要。很多程序员在使用 StringBuffer 时是不指定其容量的(至少我见到的情况是这样),如果这样的习惯带入 StringBuilder 的使用中,你将只能获得 10 %左右的性能提升(不要忘了,你可要冒多线程的风险噢);但如果你使用指定容量的 StringBuffer ,你将马上获得 45% 左右的性能提升,甚至比不使用指定容量的 StirngBuilder 都快 30% 左右。rn

没有更多推荐了,返回首页

私密
私密原因:
请选择设置私密原因
  • 广告
  • 抄袭
  • 版权
  • 政治
  • 色情
  • 无意义
  • 其他
其他原因:
120
出错啦
系统繁忙,请稍后再试