当前位置：首页 > news >正文

深圳网站如何制作/百度搜索推广的定义

news 2025/6/30 15:39:20

深圳网站如何制作,百度搜索推广的定义,网站开发项目实战,手机可以制作网站吗目录一、String 二、StringBuilder&StringBuild 三、三类对比 String无疑是Java中使用最频繁的类之一，而String类也有一定的缺陷，随后衍生出了StringBuilder和StringBuffer，当然它们俩也有一定的缺陷。所以我们在选择字符串类型时需要…

一、String

二、StringBuilder&StringBuild

三、三类对比

String无疑是Java中使用最频繁的类之一，而String类也有一定的缺陷，随后衍生出了StringBuilder和StringBuffer，当然它们俩也有一定的缺陷。所以我们在选择字符串类型时需要考虑下使用哪个会比较合适。

一、String

1、成员属性

我们先来看一下String类的成员属性(jdk1.7)

public final class Stringimplements java.io.Serializable, Comparable<String>, CharSequence
{/** The value is used for character storage. */private final char value[];/** The offset is the first index of the storage that is used. */private final int offset;/** The count is the number of characters in the String. */private final int count;/** Cache the hash code for the string */private int hash; // Default to 0/** use serialVersionUID from JDK 1.0.2 for interoperability */private static final long serialVersionUID = -6849794470754667710L;//......}

可见：

String类其实是通过char数组来保存字符串的

String类是final类，也即意味着String类不能被继承，并且它的成员方法都默认为final方法。在Java中，被final修饰的类是不允许被继承的，并且该类中的成员方法都默认为final方法。

源码的注释中有这一句话：

Strings are constant; their values cannot be changed after theyare created. String buffers support mutable strings.

字符串是常量；它们的值在创建之后不能更改。字符串缓冲区支持可变字符串。

我们可以测试一下：

public class test {public static void main(String[] args) {String s = "abc";System.out.println("s之前的hashCode："+s.hashCode());s = "abc" + "1";System.out.println("s之后的hashCode："+s.hashCode());}
}

我们都知道hashcode关联到对象在内存中的存储位置，字符串经过拼接操作后hashcode值改变了，也就是说s这个引用指向了另一个对象"abc1"。可以看一下String操作时内存变化的图：

这就会导致每次对String的操作都会生成新的String对象，短短的两个字符串，却需要开辟三次内存空间，这样不仅效率低下，而且大量浪费有限的内存空间。

2、方法

下面是取子串、拼接以及替换方法的源码：

public String substring(int beginIndex, int endIndex) {if (beginIndex < 0) {throw new StringIndexOutOfBoundsException(beginIndex);}if (endIndex > count) {throw new StringIndexOutOfBoundsException(endIndex);}if (beginIndex > endIndex) {throw new StringIndexOutOfBoundsException(endIndex - beginIndex);}return ((beginIndex == 0) && (endIndex == count)) ? this :new String(offset + beginIndex, endIndex - beginIndex, value);
}public String concat(String str) {int otherLen = str.length();if (otherLen == 0) {return this;}char buf[] = new char[count + otherLen];getChars(0, count, buf, 0);str.getChars(0, otherLen, buf, count);return new String(0, count + otherLen, buf);
}public String replace(char oldChar, char newChar) {if (oldChar != newChar) {int len = count;int i = -1;char[] val = value; /* avoid getfield opcode */int off = offset;   /* avoid getfield opcode */while (++i < len) {if (val[off + i] == oldChar) {break;}}if (i < len) {char buf[] = new char[len];for (int j = 0 ; j < i ; j++) {buf[j] = val[off+j];}while (i < len) {char c = val[off + i];buf[i] = (c == oldChar) ? newChar : c;i++;}return new String(0, len, buf);}
}

源码的逻辑清晰易读，可见无论是substring、concat还是replace操作都不是在原有的字符串上进行的，而是重新生成了一个新的字符串对象。也就是说进行这些操作后，最原始的字符串并没有被改变。

三、String字符串常量池

为了解决大量频繁的创建字符串而带来的高昂的时间与空间代价，JVM在堆内存(jdk1.7之后)中为字符串开辟一个字符串常量池，类似于缓存区。创建字符串常量时，首先坚持字符串常量池是否存在该字符串；存在该字符串，返回引用实例，不存在，实例化该字符串并放入池中。

String其中两个实例化方法可以完美理解字符串常量池：

public class test {   public static void main(String[] args) {String str1 = "hahaha";String str2 = new String("hahaha");String str3 = "hahaha";String str4 = new String("hahaha");System.out.println(str1==str2);System.out.println(str1==str3);System.out.println(str2==str4);}
}

运行结果：

在上述代码中，String str1 = "hahaha";和String str3 = "hahaha"; 都在编译期间生成了字面常量和符号引用，运行期间字面常量"hahaha"被存储在运行时常量池，只保存了一份）。通过这种方式来将String对象跟引用绑定的话，JVM执行引擎会先在运行时常量池查找是否存在相同的字面常量，如果存在，则直接将引用指向已经存在的字面常量；否则在运行时常量池开辟一个空间来存储该字面常量，并将引用指向该字面常量。

而通过new关键字来生成对象是在堆区进行的，而在堆区进行对象生成的过程是不会去检测该对象是否已经存在的。因此通过new来创建对象，创建出的一定是不同的对象，即使字符串的内容是相同的。

字符串常量池只能解决频繁地重复创建字面量相同字符串。还需要使用Java提供的其他两个操作字符串的类——StringBuffer类和StringBuild类来对此种变化字符串进行处理。

二、StringBuilder&StringBuild

先来看三者的继承结构

和 String 类不同的是，因为实现了Appendable接口，StringBuffer 和 StringBuilder 类的对象能够被多次的修改，并且不产生新的未使用对象。

而StringBuilder和 StringBuffer 之间的最大不同在于 StringBuilder 的方法不是线程安全的（不能同步访问）。原因很简单，我们可以看一下StringBuilder和 StringBuffer中的insert方法的源码：

StringBuilder的insert方法：

public StringBuilder insert(int index, char str[], int offset,int len){super.insert(index, str, offset, len);return this;
}

StringBuffer的insert方法：

public synchronized StringBuffer insert(int index, char str[], int offset,int len){super.insert(index, str, offset, len);return this;
}

事实上，StringBuilder和StringBuffer类拥有的成员属性以及成员方法基本相同，区别是StringBuffer类的成员方法前面多了一个关键字：synchronized，不用多说，这个关键字是在多线程访问时起到安全保护作用的,也就是说StringBuffer是线程安全的。

StringBuilder 相较于 StringBuffer 有速度优势，所以多数情况下建议使用 StringBuilder 类。然而在应用程序要求线程安全的情况下，则必须使用 StringBuffer 类。

具体的方法使用可以参考api手册，就不在此测试了~

不过三者之间的转换可以注意一下：

String转换成StringBuffer：构造方法和append方法；
StringBuffer转换成String：构造方法和toString方法。

三、三类对比

	String	StringBuffer	StringBuilder
对象类型	字符串常量。属于不可变类(每次对String的操作都会生成新的String对象)，效率低，浪费大量优先的内存空间	字符串变量。属于可变类（任何对它指向的字符串的操作都不会产生新的对象）。每个StringBuffer对象都有一定的缓冲区容量，当字符串大小没有超过容量时，不会分配新的容量，当字符串大小超过容量时，会自动增加容量	字符串变量。属于可变类，速度更快
大致执行效率	低	中	高
线程有关	线程不安全	多线程操作字符串，线程安全	单线程操作字符串，线程不安全
适用场景	操作少，数据少	多线程，操作多，数据多	单线程，操作多，数据多

这三个类各有利弊，应当根据不同的情况来进行选择使用！

接下来我们可以测试一下三类的性能

public class test {private static int time = 50000;public static void main(String[] args) {testString();testStringBuffer();testStringBuilder();}public static void testString () {String s="";long begin = System.currentTimeMillis();for(int i=0; i<time; i++){s += "HappyNewYear";}long over = System.currentTimeMillis();System.out.println("操作"+s.getClass().getName()+"类型使用的时间为："+(over-begin)+"毫秒");}public static void testStringBuffer () {StringBuffer sb = new StringBuffer();long begin = System.currentTimeMillis();for(int i=0; i<time; i++){sb.append("HappyNewYear");}long over = System.currentTimeMillis();System.out.println("操作"+sb.getClass().getName()+"类型使用的时间为："+(over-begin)+"毫秒");}public static void testStringBuilder () {StringBuilder sb = new StringBuilder();long begin = System.currentTimeMillis();for(int i=0; i<time; i++){sb.append("HappyNewYear");}long over = System.currentTimeMillis();System.out.println("操作"+sb.getClass().getName()+"类型使用的时间为："+(over-begin)+"毫秒");}}

运行结果：

对三种类型的的对象进行50000次拼接操作，其效率对比可见一斑！

大致效率：StringBuilder > StringBuffer > String；当然这也不是绝对的，当涉及到很少数目的字符串操作时孰快孰慢就不一定了。

另外，String类型拼接时"直接"拼接和"间接"拼接的效率是不同的（jvm在编译器对String类型的优化）：

public class test {private static int time = 50000;public static void main(String[] args) {test1String();test2String();}public static void test1String () {long begin = System.currentTimeMillis();for(int i=0; i<time; i++){String s = "I"+"love"+"java";}long over = System.currentTimeMillis();System.out.println("字符串直接相加操作："+(over-begin)+"毫秒");}public static void test2String () {String s1 ="I";String s2 = "love";String s3 = "java";long begin = System.currentTimeMillis();for(int i=0; i<time; i++){String s = s1+s2+s3;}long over = System.currentTimeMillis();System.out.println("字符串间接相加操作："+(over-begin)+"毫秒");}}

也就是说对于直接相加字符串，效率很高，因为在编译器便确定了它的值，也就是说形如"Happy"+"New"+"Year"; 的字符串相加，在编译期间便被优化成了"happyNewYear"。。对于间接相加（即包含字符串引用），形如s1+s2+s3; 效率要比直接相加低，因为在编译器不会对引用变量进行优化。

关于+= 与 + 可以看另外一个例子：

public class test {private static int time = 50000;public static void main(String[] args) {testString();testString1();}public static void testString () {String s="";long begin = System.currentTimeMillis();for(int i=0; i<time; i++){s += "Happy";}long over = System.currentTimeMillis();System.out.println("操作 s += 'Happy';型使用的时间为："+(over-begin)+"毫秒");}public static void testString1 () {String s="";long begin = System.currentTimeMillis();for(int i=0; i<time; i++){s = s + "Happy";}long over = System.currentTimeMillis();System.out.println("操作 s = s + 'Happy';型使用的时间为："+(over-begin)+"毫秒");}}