精华内容
下载资源
问答
  • 简介在JAVA开发过程中,经常会遇到字符串操作,对字符串的拼接操作更常见。拼接字符串主要有以下几种方法:1. "" + ""2. "".concat("")3. new StringBuilder().append()4. new StringBuffer().append()还有一个...

    简介

    在JAVA开发过程中,经常会遇到字符串操作,对字符串的拼接操作更常见。

    拼接字符串主要有以下几种方法:

    1. "" + ""

    2. "".concat("")

    3. new StringBuilder().append()

    4. new StringBuffer().append()

    还有一个StringUtils工具类的join()方法,这里不做讨论。

    时间紧迫的朋友可以跳过分析,直接看结论。

    分析

    1. 直接使用+拼接字符串

    这是最方便的。但是它的性能在大部分情况下也是最低的一个。为什么这么说呢?请看官继续向下:

    废话少说,先上个例子:

    public class Test1 {

    public static void main(String[] args) {

    String s = "abc";

    String s1 = "123" + s;

    String s2 = "efg" + s1;

    }

    }

    我们使用javap工具对字节码文件 Test1.class 反编译一下,瞅瞅+操作符干了些啥。

    javap是java字节码反编译工具。-c 参数表示显示反汇编命令。

    C:\com\demo> javap -c .\Test1.class

    Compiled from "Test1.java"

    public class com.demo.Test1 {

    public com.demo.Test1();

    Code:

    0: aload_0

    1: invokespecial #1 // Method java/lang/Object."":()V

    4: return

    public static void main(java.lang.String[]);

    Code:

    0: ldc #2 // String abc

    2: astore_1

    3: new #3 // class java/lang/StringBuilder

    6: dup

    7: invokespecial #4 // Method java/lang/StringBuilder."":()V

    10: ldc #5 // String 123

    12: invokevirtual #6 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;

    15: aload_1

    16: invokevirtual #6 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;

    19: invokevirtual #7 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;

    22: astore_2

    23: new #3 // class java/lang/StringBuilder

    26: dup

    27: invokespecial #4 // Method java/lang/StringBuilder."":()V

    30: ldc #8 // String efg

    32: invokevirtual #6 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;

    35: aload_2

    36: invokevirtual #6 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;

    39: invokevirtual #7 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;

    42: astore_3

    43: return

    }

    从反编译的代码中可以看出,编译器会把+符号优化成StringBuilder类,并使用 StringBuilder.append() 方法对字符拼接。最后调用 StringBuilder.toString() 方法,返回String。

    在上面的代码中,我们对字符串进行了两次+操作,在优化后的代码也创建两次StringBuilder对象和调用两次toString()方法。

    既然编译器会把+操作优化成StringBuilder方法,那它们效率会一样?其实不然。

    2. 为什么+操作符比StringBuilder效率低?

    首先看看StringBuilder怎么拼接字符串。

    StringBuffer sb = new StringBuffer();

    sb.append("abc");

    sb.append("123");

    sb.append("efg");

    sb.toString();

    上面的代码,只 new 了一个 StringBuilder 对象,而且只调用了一次 toString()方法。

    我们知道在java中实例化对象,其实是很费时的,还要回收什么的。要不就不会搞出 单例模式 这种东西了。

    而toString()这个方法更是浪费时间,我们来看下 StringBuilder 的 toString() 方法的源码。

    public final class StringBuilder extends AbstractStringBuilder implements java.io.Serializable, CharSequence{

    //省略 n 多代码

    private transient char[] toStringCache;

    @Override

    public synchronized String toString() {

    if (toStringCache == null) {

    toStringCache = Arrays.copyOfRange(value, 0, count);

    }

    return new String(toStringCache, true);

    }

    //省略 n 多代码

    }

    StringBuilder和StringBuffer 都是 AbstractStringBuilder 的实现类,其底层是用 char[] 数组来储存数据的。StringBuilder默认初始char[]大小是16,当添加的字符大于16个,就会自动扩容。扩容这个操作本质是对数组的复制,也挺费时的,有兴趣的可以看一下源码。而+操作生成的StringBuilder默认大小为16,如果拼接的字符串过大,会频繁的扩容导致效率低下。

    所以如果使用StringBuilder的时候,我们可以给一个参数capacity,初始化char[]的大小,这样可以避免频繁的扩容。

    toString() 方法就是对 char[] 数组的复制。这可是个挺费时间的操作。

    所以,虽然编译器对 + 操作进行了优化,但是由于频繁的实例化StringBuilder、频繁的调用toString()、在添加的字符串较大的情况下还会频繁的扩容,导致其效率极其低下。

    但是,+一定比StringBuilder效率低嘛?答案当然是否定的。

    3. +什么时候比StringBuilder高效?

    我们再上两段代码:

    public static void main(String[] args) {

    // +

    String s1 = "abc"+"123"+"efg";

    // StringBuilder

    StringBuilder sb = new StringBuilder();

    String s2 = sb.append("abc").append("123").append("efg").toString();

    }

    同样把这段代码反编译一下,你知道,编译器把上面的代码编译成什么样了嘛?

    public static void main(String[] args) {

    String s1 = "abc123efg";

    StringBuilder sb = new StringBuilder();

    String s2 = sb.append("abc").append("123").append("efg").toString();

    }

    编译器直接在编译的时候就把 + 给组合完成了,运行时间为 0 。谁效率高谁效率低显而易见。

    所以进行大量的字符串拼接操作 StringBuilder 更合适,而进行少量的,可预知的字符串拼接 + 更合适。(一般 for 循环中用 StringBuilder ,而静态变量等用 +)

    4. StringBuilder与StringBuffer的区别。

    它们两个的区别主要是 StringBuilder 是线程不安全的,而StringBuffer是线程不安全的。

    我们看一下两个类的 append() 方法的源码:

    StringBuilder

    public final class StringBuilder extends AbstractStringBuilder implements java.io.Serializable, CharSequence{

    // ...

    @Override

    public StringBuilder append(String str) {

    super.append(str);

    return this;

    }

    // ...

    }

    StringBuffer

    public final class StringBuffer extends AbstractStringBuilder implements java.io.Serializable, CharSequence{

    // ...

    @Override

    public synchronized StringBuffer append(String str) {

    toStringCache = null;

    super.append(str);

    return this;

    }

    // ...

    }

    StringBuilder比StringBuffer少了同步锁。其他基本相同,因为它们都是AbstractStringBuilder的实现类。是双胞胎(其实眼瞎的我莫名感觉他们的名字长得还蛮像的)

    所以,在线程安全的情况下,StringBuilder更高效一点(毕竟同步锁也要花时间),而线程不安全就只能用 StringBuffer。

    5. String.concat()拼接与StringBuilder的比较

    上代码:

    String s = "abc".concat("123").concat("efg");

    来瞅瞅源码:

    public String concat(String str) {

    int otherLen = str.length();

    if (otherLen == 0) {

    return this;

    }

    int len = value.length;

    char buf[] = Arrays.copyOf(value, len + otherLen);

    str.getChars(buf, len);

    return new String(buf, true);

    }

    String.concat()方法调用了一次Arrays.copyOf(value, len + otherLen)方法,一次性分配了两个个字符串长度的内存空间,只执行了一次空间分配,并对拼接的两个字符各复制了一次,复制了两次。

    而StringBuilder的append()在char[]未满的情况下,不会扩容。只会在初始化的时候执行一次空间分配,对两个字符串各复制了一次,复制了两次,但是最后会调用toString(),还会复制一次。

    所以,比较之下,在只有两个字符串拼接的情况下,concat的效率要高一点,而大量的字符串拼接,StringBuilder效率会高一点,而且好在初始化的时候,指定char[]容器的大小,这样可以避免过度的扩容。

    测试环境

    系统:windows10 x64

    处理器:i7 9700k

    内存:16G

    台式电脑

    测试代码

    public class Demo {

    public static void main(String[] args) {

    int number = 10000000; //拼接次数

    long start ; //开始时间

    // concat

    String s2 = "";

    start = System.currentTimeMillis();

    for(int i = 0 ; i < number ; ++i){

    s2.concat(String.valueOf(i));

    }

    System.out.println(" concat 用时:"+ (System.currentTimeMillis() - start) + " 毫秒");

    // StringBuilder

    StringBuilder stringBuilder = new StringBuilder();

    start = System.currentTimeMillis();

    for(int i = 0 ; i < number ; ++i){

    stringBuilder.append(String.valueOf(i));

    }

    System.out.println("StringBuilder 用时:"+ (System.currentTimeMillis() - start) + " 毫秒");

    //StringBuffer

    StringBuffer stringBuffer = new StringBuffer();

    start = System.currentTimeMillis();

    for(int i = 0 ; i < number ; ++i){

    stringBuffer.append(String.valueOf(i));

    }

    System.out.println(" StringBuffer 用时:"+ (System.currentTimeMillis() - start) + " 毫秒");

    // +

    String s = "";

    start = System.currentTimeMillis();

    for(int i = 0 ; i < number ; ++i){

    s += String.valueOf(i);

    }

    System.out.println(" + 用时:"+ (System.currentTimeMillis() - start) + " 毫秒");

    }

    }

    测试结果

    测试结果取几次或者1次的平均值整数,不同运行环境会有偏差

    +

    concat

    StringBuilder

    StringBuffer

    1000次

    3ms

    1ms

    1ms

    1ms

    100000次

    15584ms

    10ms

    6ms

    6ms

    1000000次

    2212323ms

    56ms

    34ms

    44ms

    10000000次

    很多很多ms

    408ms

    353ms

    448ms

    结论

    +最好不要直接大量使用。只有在逻辑较简单的情况下(没有for循环之类)或者字符确定的情况下时候使用。如:String a = "abc"+"123"。

    一般情况,在大量字符串拼接操作中。使用StringBuilder和StringBuffer,并尽可能的估算字符串的大小,使用带capacity参数的构造函数,也就是char[]的大小,这样可以避免重复的扩容。

    StringBuffer 在线程不安全的情况下使用,其他情况一般使用StringBuilder。

    只有两个字符串拼接的时候使用 concat(),这个性能最好。 但是每次拼接操作都会分配内存的操作,而上面两个并不一定每次拼接操作都会分配内存。

    展开全文
  • 深刻感觉写程序就是在按照一定的规则在拼接...Java和JavaScript对象都提供了丰富的方法,这里主要对比关于字符串链接的时间效率,比如:String str="abc"; str+="def"关于Java的String连接性能讨论参见这篇博客:J...

    深刻感觉写程序就是在按照一定的规则在拼接字符串。

    Java和JavaScript中的String具有不可变性(immutable),同时正是这样的不可变性成为Java的线程安全和安全机制的基石。

    Java和JavaScript对象都提供了丰富的方法,这里主要对比关于字符串链接的时间效率,比如:String str="abc"; str+="def"

    关于Java的String连接性能讨论参见这篇博客:

    Javascript的String对象提供了丰富的方法,但是由于String的不可变性,字符串发生改变的时候都会重新创建一个新的对象,使用“+”连接符来改变字符串同样是创建了新的字符串。

    Array.join('')这个方法可以将数组中的对象转换为字符串。

    下面通过自定义对象来实现JavaScript中的类似Java的StringBuffer对象。

    实现:

    /**

    * StringBuffer对象

    */

    function StringBuffer() {

    this._stringbuffer_ = new Array();

    /**

    * 获取长度

    */

    if (typeof StringBuffer.size == 'undefined') {

    StringBuffer.prototype.size = function() {

    return this.toString().length;

    };

    }

    }

    StringBuffer.prototype = new Object();

    /**

    * 转换为字符串

    */

    StringBuffer.prototype.toString = function() {

    return this._stringbuffer_.join('');

    };

    /**

    * 追加字符串

    *

    * @param s

    * @returns

    */

    StringBuffer.prototype.append = function(s) {

    if (typeof (s) == 'string') {

    this._stringbuffer_.push(s);

    } else if (typeof (s) == 'number') {

    this._stringbuffer_.push(s.toString(10));

    } else if (typeof (s) == 'boolean') {

    this._stringbuffer_.push(s.toString());

    } else {

    ;

    }

    return this.toString();

    };

    /**

    * 获取指定位置的字符

    *

    * @param i

    * @returns

    */

    StringBuffer.prototype.charAt = function(i) {

    var sb = this.toString();

    if (i < 0 || i >= this.size()) {

    return "";

    } else {

    return sb.charAt(i);

    }

    };

    下面是对StringBuffer对象拼接字符串和“+”运算符拼接字符串的时间效率进行对比。

    对比图一:

    图标说明:String:指的是通过“+”运算符连接字符串

    StringBuffer:指通过StringBuffer的append()方法连接字符串

    图表的纵轴:指运算的时间,单位毫秒

    图片的横轴:指连接字符串操作的次数

    说明:上述链接的字符串都是单字符,精确度很低,仅仅作为时间效率的参考。

    看到上面的图,不要惊讶,是不是和想像中的结果大相径庭,没错,这个结果的测试有问题的,相信自己,StringBuffer和"+"运算符连接字符串效率怎么会差距这么大呢?

    下面是计算StringBuffer的时间:

    start = new Date().getTime();

    for ( var j = 0; j < range[i]; j++) {

    sb.append(j);

    }

    sb.toString();

    end = new Date().getTime();

    sbTimes.push(end - start);

    这样的计算机时间是有问题的,将字符串追加的时间也计算到时间效率中去了。

    下面是修正后的时间效率对比的例子:

    Insert title here

    function calc() {

    var ups=new Array(1000,2000,3000);

    for ( var i = 0; i < ups.length; i++) {

    draw(ups[i], "graphicDiv"+i);

    }

    }

    function draw(up, name) {

    //测试自定义StringBuffer和字符串拼接的效率

    var sbTimes = new Array();

    var stTimes = new Array();

    var range = new Array();

    for ( var i = 0; i < 20; i++) {

    range[i] = 10000 +i* up;

    }

    for ( var i = 0; i < range.length; i++) {

    StringBuffer

    sb = new StringBuffer();

    var start = new Date().getTime();

    var st = "";

    for ( var j = 0; j < range[i]; j++) {

    st += j;

    }

    var end = new Date().getTime();

    stTimes.push(end - start);

    for ( var j = 0; j < range[i]; j++) {

    sb.append(j);

    }

    start = new Date().getTime();

    sb.toString();

    end = new Date().getTime();

    sbTimes.push(end - start);

    sb = null;

    }

    StringBuffer

    xml = new StringBuffer();

    xml

    .append('');

    xml.append('');

    for ( var i = 0; i < range.length; i++) {

    xml.append(' ');

    }

    xml.append('');

    xml

    .append('');

    for ( var i = 0; i < stTimes.length; i++) {

    xml.append('');

    }

    xml.append('');

    xml

    .append('');

    for ( var i = 0; i < sbTimes.length; i++) {

    xml.append('');

    }

    xml.append('');

    xml.append('');

    var dataXml = xml.toString();

    var fcf = new FusionCharts("FCF_MSArea2D.swf", "t_msa2d_" + up, 960,

    680);

    fcf.setDataXML(dataXml);

    fcf.render(name);

    }

    展开全文
  • 深刻感觉写程序就是在按照一定的规则在拼接字符串Java和JavaScript中的String具有...Java和JavaScript对象都提供了丰富的方法,这里主要对比关于字符串链接的时间效率,比如:String str="abc"; str+="def" 关于...

    深刻感觉写程序就是在按照一定的规则在拼接字符串。

    Java和JavaScript中的String具有不可变性(immutable),同时正是这样的不可变性成为Java的线程安全和安全机制的基石。

    Java和JavaScript对象都提供了丰富的方法,这里主要对比关于字符串链接的时间效率,比如:String str="abc"; str+="def"

    关于Java的String连接性能讨论参见这篇博客:

    http://www.blogjava.net/javagrass/archive/2010/01/24/310650.html

    Javascript的String对象提供了丰富的方法,但是由于String的不可变性,字符串发生改变的时候都会重新创建一个新的对象,使用“+”连接符来改变字符串同样是创建了新的字符串。


    Array.join('')这个方法可以将数组中的对象转换为字符串。

    下面通过自定义对象来实现JavaScript中的类似Java的StringBuffer对象。

    实现:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    /**
     * StringBuffer对象
     */
    function StringBuffer() {
        this._stringbuffer_ = new Array();
        /**
         * 获取长度
         */
        if (typeof StringBuffer.size == 'undefined') {
            StringBuffer.prototype.size = function() {
                return this.toString().length;
            };
        }
    }
    StringBuffer.prototype = new Object();
    /**
     * 转换为字符串
     */
    StringBuffer.prototype.toString = function() {
        return this._stringbuffer_.join('');
    };
    /**
     * 追加字符串
     *
     * @param s
     * @returns
     */
    StringBuffer.prototype.append = function(s) {
        if (typeof (s) == 'string') {
            this._stringbuffer_.push(s);
        else if (typeof (s) == 'number') {
            this._stringbuffer_.push(s.toString(10));
        else if (typeof (s) == 'boolean') {
            this._stringbuffer_.push(s.toString());
        else {
            ;
        }
        return this.toString();
    };
    /**
     * 获取指定位置的字符
     *
     * @param i
     * @returns
     */
    StringBuffer.prototype.charAt = function(i) {
        var sb = this.toString();
        if (i < 0 || i >= this.size()) {
            return "";
        else {
            return sb.charAt(i);
        }
    };

    下面是对StringBuffer对象拼接字符串和“+”运算符拼接字符串的时间效率进行对比。

    对比图一:

    143310551.png


    图标说明:

    • String:指的是通过“+”运算符连接字符串

    • StringBuffer:指通过StringBuffer的append()方法连接字符串

    • 图表的纵轴:指运算的时间,单位毫秒

    • 图片的横轴:指连接字符串操作的次数

    说明:上述链接的字符串都是单字符,精确度很低,仅仅作为时间效率的参考。

    看到上面的图,不要惊讶,是不是和想像中的结果大相径庭,没错,这个结果的测试有问题的,相信自己,StringBuffer和"+"运算符连接字符串效率怎么会差距这么大呢?

    下面是计算StringBuffer的时间:


    1
    2
    3
    4
    5
    6
    7
    start = new Date().getTime();
    for var j = 0; j < range[i]; j++) {
        sb.append(j);
    }
    sb.toString();
    end = new Date().getTime();
    sbTimes.push(end - start);


    这样的计算机时间是有问题的,将字符串追加的时间也计算到时间效率中去了。

    下面是修正后的时间效率对比的例子:


    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    <!DOCTYPE html>
    <html>
    <head>
    <meta charset="UTF-8">
    <title>Insert title here</title>
    <script type="text/javascript" src="../js/jiUtil.js"></script>
    <script type="text/javascript" src="../js/FusionCharts.js"></script>
    <script type="text/javascript">
        function calc() {
            var ups=new Array(1000,2000,3000);
            for ( var i = 0; i < ups.length; i++) {
                draw(ups[i], "graphicDiv"+i);
            }
        }
        function draw(up, name) {
            //测试自定义StringBuffer和字符串拼接的效率
            var sbTimes new Array();
            var stTimes new Array();
            var range new Array();
            for ( var i 0; i < 20; i++) {
                range[i] = 10000 +i* up;
            }
            for ( var i 0; i < range.length; i++) {
                StringBuffer
                sb new StringBuffer();
                var start new Date().getTime();
                var st "";
                for ( var j 0; j < range[i]; j++) {
                    st += j;
                }
                var end new Date().getTime();
                stTimes.push(end - start);
                for ( var j 0; j < range[i]; j++) {
                    sb.append(j);
                }
                start new Date().getTime();
                sb.toString();
                end new Date().getTime();
                sbTimes.push(end - start);
                sb null;
            }
            StringBuffer
            xml new StringBuffer();
            xml
                    .append('<graph caption=" string vs join() on speed" subcaption="For the month of Oct 2013" divlinecolor="F47E00" numdivlines="4" showAreaBorder="1" areaBorderColor="000000"  showNames="1" numVDivLines="29" vDivLineAlpha="30" formatNumberScale="1" rotateNames="1">');
            xml.append('<categories  numberSuffix="ms">');
            for ( var i = 0; i < range.length; i++) {
                xml.append('<category name="'+range[i]+'" /> ');
            }
            xml.append('</categories>');
            xml
                    .append('<dataset seriesname="String" color="FF5904" showValues="0" areaAlpha="50" showAreaBorder="1" areaBorderThickness="2" areaBorderColor="FF0000">');
            for ( var i = 0; i < stTimes.length; i++) {
                xml.append('<set value="'+stTimes[i]+'" />');
            }
            xml.append('</dataset>');
            xml
                    .append('<dataset seriesname="StringBuffer" color="99cc99" showValues="0" areaAlpha="50" showAreaBorder="1" areaBorderThickness="2" areaBorderColor="006600">');
            for ( var i = 0; i < sbTimes.length; i++) {
                xml.append('<set value="'+sbTimes[i]+'" />');
            }
            xml.append('</dataset>');
            xml.append('</graph>');
            var dataXml = xml.toString();
            var fcf = new FusionCharts("FCF_MSArea2D.swf", "t_msa2d_" + up, 960,
                    680);
            fcf.setDataXML(dataXml);
            fcf.render(name);
        }
    </script>
    </head>
    <body     <div id="graphicDiv0" align="center"></div>
        <div id="graphicDiv1" align="center"></div>
        <div id="graphicDiv2" align="center"></div>
    </body>
    </html>

    StringBuffer的append()实现使用了数组对象的push()方法,而数组的join()方法才是正真将数组中的字符串对象连接一起成为字符串,join()方法所花费的时间和“+”连接的时间在连接次数不够大的情况下相差并不是特别显著,相反还增加了append()这一操作。

    如果站在空间复杂度看待这个问题,由于String的不可变性又会使得内存开销很大,产生较多的垃圾内存需要垃圾回收机制去处理。

    对于浏览器和用户来讲,时间效率显得更重要些,用户交互需要更流畅,而不是去等待。

    下面三张上述示例测试的结果图:


    150719863.png

    150719335.png

    150719859.png

    从上面看,StringBuffer完成的时间随链接数量变化不是特别大,而“+”连接在连接数量达到2万5千的时候开始网上飙升。

    测试的影响因素:

    本机的内存,浏览器JS引擎,其他操作对其部分运算的干扰(运算过程中进行其他事情占用计算机资源)。


    总结:

    1.实际工作做中几乎碰不到这样大的字符串连接;

    2.“+”运算符连接字符串方便便捷,因为1,所以也不会产生太多的内存垃圾;

    3.抛开数组中的元素添加,Array.join()方法连接字符串显然比“+”连接字符时间效率高很多;

    4.实际工作用字符串连接也是有数据来源的,不可能无缘无故的拼接一些字符串,如上面的测试用例,就是要使用到一些数据,因而采用了append()方法;

    5.“+"连接字符串过程中产生的是匿名的字符串,二次使用较为困难,而使用append()方法连接字符串,由于其内部是使用Array进行存储的因此操作方便,而且便于修改,直接解决了String的不可变性带来的不便,同事内存空间是使用率很高。

    6.使用StringBuffer去操作字符串比"+"连接字符串的代码可读性好,出错肯能性小,面向对象的意思更浓。

    综上种种:使用StringBuffer对象的append()方法来拼接字符串更有利些。



    本文转自 secondriver 51CTO博客,原文链接:http://blog.51cto.com/aiilive/1304174,如需转载请自行联系原作者

    展开全文
  • 记录一下:java数组转字符串 以防止链接过期,做一下记录:例子是str[] = {0,1,2,3,4,5} //第一种方法是遍历,将数组遍历后拆分再组合(这种就不讲了) 略... //第二种,数组转字符串 org.apache.commons.lang3....

    记录一下:java数组转字符串

    以防止链接过期,做一下记录:例子是str[] = {0,1,2,3,4,5}
    //第一种方法是遍历,将数组遍历后拆分再组合(这种就不讲了)...
    
    //第二种,数组转字符串 org.apache.commons.lang3.StringUtils
    String str1 = StringUtils.join(arr); // 数组转字符串,其实使用的也是遍历
    System.out.println(str1); // 012345
    String str2 = StringUtils.join(arr, ","); // 数组转字符串(逗号分隔)(推荐)
    System.out.println(str2); // 0,1,2,3,4,5
    
    //第三种,数组转字符串 org.apache.commons.lang3.ArrayUtils
    String str3 = ArrayUtils.toString(arr, ","); // 数组转字符串(逗号分隔,首尾加大括号)
    System.out.println(str3); // {0,1,2,3,4,5}
    

    【参考】https://www.cnblogs.com/ooo0/p/9169311.html

    展开全文
  • 当我开始使用Python时,很直观、很容易就想到使用加法运算符+来连接字符串,就像很多编程语言如Java一样。然而,很快我就意识到,很多开发者似乎都喜欢用.join()方法而不是+。在这篇文章中,我将介绍这两种方法的...
  • 1.在已有字符串数组的场合,使用 strings.Join() 能有比较好的性能。 2.在一些性能要求较高的场合,尽量使用 buffer.WriteString() 以获得更好的性能。大量拼接用append方法性能最好。 3.较少字符串连接的场景下性能...
  • 字符串无所不在,字符串的处理也是最常见的操作。本章节将总结和字符串处理相关的一切操作。主要包括基本的字符串操作;高级字符串操作之正则。目前共有25个小例子 91 反转字符串 st="python" #方法1 ''.join...
  • 字符串操作是python绕不开的话题,python拥有丰富的api来处理...字符串的赋值,还有大小写函数都是常用的功能,其中count功能还能统计字符串中某个元素出现的次数,这个比java强大多了。 join链接函数,把某个字
  • 当我们仅仅需要a b 的时候,两个字符串链接任何方法的效率基本一样,都在0.0001毫秒内就可以完成。不过如果需要1万次,10000万次,就会发现string自身的join速度显著下降 代码如下 复制代码 packag...
  • 包括基础语法,OOP,字符串,集合,IO,反射,线程,网络等。未完成模块:阿里Java手册,java8,注解,fork / join,加解密等。 我微信:bysocket01,加入纯技术交流群,成长技术 给教程的开源代码仓库点个Star吧 ...
  • java范例开发大全

    2013-03-08 20:06:54
    实例42 字符串索引越界异常(StringIndexOutBounds) 60 实例43 操作错误(UnsupportedOperationException) 60 4.2 运行时异常 61 实例44 找不到指定类时发生的异常(ClassNotFoundException) 62 实例45 请求的...
  • 当我们仅仅需要a+b 的时候,两个字符串链接任何方法的效率基本一样,都在0.0001毫秒内就可以完成。不过如果需要1万次,10000万次,就会发现string自身的join速度显著下降 package com.java.lang;   public class ...
  • java范例开发大全源代码

    热门讨论 2011-10-30 23:31:51
     实例42 字符串索引越界异常(StringIndexOutBounds) 60  实例43 操作错误(UnsupportedOperationException) 60  4.2 运行时异常 61  实例44 找不到指定类时发生的异常(ClassNotFoundException) 62 ...
  • Java String类是灰常常用的一个类,但是天天在用每页没管过。...关于字符串函数(split、join、indexOf、substring),这些常用的方法可参考下链接;虽然总结的是js的,但是一样的,joinjava 1.8d的 字符串函数(spl
  • Java范例开发大全 (源程序)

    热门讨论 2011-04-27 07:47:22
     实例42 字符串索引越界异常(StringIndexOutBounds) 60  实例43 操作错误(UnsupportedOperationException) 60  4.2 运行时异常 61  实例44 找不到指定类时发生的异常(ClassNotFoundException) 62  ...
  • Java范例开发大全(全书源程序)

    热门讨论 2013-04-05 11:50:26
    实例42 字符串索引越界异常(StringIndexOutBounds) 60 实例43 操作错误(UnsupportedOperationException) 60 4.2 运行时异常 61 实例44 找不到指定类时发生的异常(ClassNotFoundException) 62 实例45 请求...
  • 每日一练_17

    2017-12-15 09:15:46
    join()是用来将字符串用分隔符链接起来,形成数组Java 简答题Java 有那些基本数据类型,String 是不是基本数据类型,他们有何区别?分为3类: 字符串类:char 数值类型:byte,short,int,long,float,double 布尔类:
  • Java学习笔记-个人整理的

    热门讨论 2012-12-19 09:57:07
    {1}Java基础}{17}{chapter.1} {1.1}基本语法}{17}{section.1.1} {1.2}数字表达方式}{17}{section.1.2} {1.3}补码}{19}{section.1.3} {1.3.1}总结}{23}{subsection.1.3.1} {1.4}数据类型}{23}{section.1.4} {...
  • python性能优化指南

    2017-02-28 17:06:30
    当需要迭代生成一个长字符串时逐一相加不仅会影响速度也会而外增加内存消耗(如中间结果,参考java StringBuffer), 但是当仅需链接很少的字符串join方法未必明智 join的恰当使用 “”%() format
  • String类的常用方法

    2018-03-25 14:21:04
    Java String类是灰常常用的一个类,但是天天在...关于字符串函数(split、join、indexOf、substring),这些常用的方法可参考下链接;虽然总结的是js的,但是一样的,joinjava 1.8d的字符串函数(split、join、indexO...
  • 函数join接受连接字符串s将一个字符串数组中的元素,两两相连,构成一个新的字符串,例如["I", "U"]如果用字符串" love "链接,会得到"I love U";而["abc"]中只有一个元素,因此无论用什么连接,始终得到"abc"本身...
  • 精通javascript

    2012-12-05 18:17:35
    • 2.13.htm 通过字符串调用toLowerCase()方法 • 2.14.htm 使用值的数据操作 • 2.15.htm 对数据的引用执行 • 2.16.htm 字符串的比较 第3章(\第3章) • 3.1.htm ...
  • MYSQL中文手册

    2013-03-11 21:21:34
    8.14. replace:字符串替换实用工具 8.15. mysql_zap:杀死符合某一模式的进程 9. 语言结构 9.1. 文字值 9.1.1. 字符串 9.1.2. 数值 9.1.3. 十六进制值 9.1.4. 布尔值 9.1.5. 位字段值 9.1.6. NULL值 9.2....
  • 8.14. replace:字符串替换实用工具 8.15. mysql_zap:杀死符合某一模式的进程 9. 语言结构 9.1. 文字值 9.1.1. 字符串 9.1.2. 数值 9.1.3. 十六进制值 9.1.4. 布尔值 9.1.5. 位字段值 9.1.6. NULL值 9.2. 数据库、...
  • 8.14. replace:字符串替换实用工具 8.15. mysql_zap:杀死符合某一模式的进程 9. 语言结构 9.1. 文字值 9.1.1. 字符串 9.1.2. 数值 9.1.3. 十六进制值 9.1.4. 布尔值 9.1.5. 位字段值 9.1.6. NULL值 9.2. 数据库、...
  • 注意不同的是被单引号引出的字符串是以字面定义的,而双引号引出的字符串可以被扩展。反斜杠(\)可以被用来分割某些特殊字符。举例如下: $first = 'Hello'; $second = "World"; $full1 = "$first $second"; # ...

空空如也

空空如也

1 2 3
收藏数 46
精华内容 18
关键字:

java链接字符串join

java 订阅