解决String和StringBuilder向前追加内容效率低的问题

已于 2023-04-21 09:24:16 修改
阅读量1k 收藏
点赞数
文章标签： java jvm junit
于 2023-03-24 10:43:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cz1803472613/article/details/129744201
版权

前言

在工作中经常遇到字符串拼接的问题，一般如果只是简单的拼接一次直接使用String和“+”就可以实现，如果大量的拼接则需要StringBuilder或者StringBuffer。但是不管是String还是StringBuilder他们在拼接的时候向后追加的效率都是很高的，但是如果向前拼接追加，那效率则相当低下。原因就是字符串底层在向前追加内容的时候，都会使数组中的其他元素向后移动，这样效率就会很低。下面我们就来探索如果实现一个高效的向前追加拼接方法。

解决方法

在StringBuilder的基础上进行扩展使用其支持高效的向前追加，但是由于StringBuilder是使用final修饰的，所以这里重新实现StringBuilder。代码如下：

package com.cz.redis;

import java.util.Arrays;

/**
 * @program: PostGirl
 * @description: 扩展JStringBuilder
 * 提供向前追加的功能
 * 实现原理：
 *         1、初始化数组，如果向前插入，则向前扩容，如果向后插入则向后扩容
 *         2、扩容后提供前缀指针和后缀指针来指向当前存储的位置
 * @author: Cheng Zhi
 * @create: 2023-03-22 14:01
 **/
public class JefStringBuilder {

    /**
     * The value is used for character storage.
     */
    char[] value;

    /**
     * The count is the number of characters used.
     */
    int count;

    /**
     * 前缀数组的指针，初始化为0
     */
    int preCursor;

    /**
     * 后缀数组的指针，初始化为0
     */
    int fixCursor = 0;

    /**
     * 初始化数组长度
     */
    int defaultCapacity = 16;

    /**
     * 前缀数组长度
     */
    int preArraySize;

    /**
     * The maximum size of array to allocate (unless necessary).
     * Some VMs reserve some header words in an array.
     * Attempts to allocate larger arrays may result in
     * OutOfMemoryError: Requested array size exceeds VM limit
     */
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

    public JefStringBuilder() {
        value = new char[defaultCapacity];
    }

    public JefStringBuilder(int capacity) {
        value = new char[capacity];
    }

    /**
     * 向后追加字符串
     * @param str
     * @return
     */
    public JefStringBuilder append(String str) {
        if (str == null)
            return appendNull();
        int len = str.length();
        ensureCapacityInternal(count + len, len);
        str.getChars(0, len, value, fixCursor);
        fixCursor = fixCursor + len;
        count += len;
        return this;
    }

    public JefStringBuilder append(StringBuffer sb) {
        if (sb == null)
            return appendNull();
        int len = sb.length();
        ensureCapacityInternal(count + len, len);
        sb.getChars(0, len, value, fixCursor);
        fixCursor = fixCursor + len;
        count += len;
        return this;
    }

    /**
     * @since 1.8
     */
    JefStringBuilder append(JefStringBuilder asb) {
        if (asb == null)
            return appendNull();
        int len = asb.length();
        ensureCapacityInternal(count + len, len);
        asb.getChars(0, len, value, count);
        count += len;
        return this;
    }

    public void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) {
        if (srcBegin < 0)
            throw new StringIndexOutOfBoundsException(srcBegin);
        if ((srcEnd < 0) || (srcEnd > count))
            throw new StringIndexOutOfBoundsException(srcEnd);
        if (srcBegin > srcEnd)
            throw new StringIndexOutOfBoundsException("srcBegin > srcEnd");
        System.arraycopy(value, srcBegin, dst, dstBegin, srcEnd - srcBegin);
    }


    // Documentation in subclasses because of synchro difference
    public JefStringBuilder append(CharSequence s) {
        if (s == null)
            return appendNull();
        if (s instanceof String)
            return this.append((String)s);
        if (s instanceof JefStringBuilder)
            return this.append((JefStringBuilder)s);

        return this.append(s, 0, s.length());
    }

    public JefStringBuilder append(CharSequence s, int start, int end) {
        if (s == null)
            s = "null";
        if ((start < 0) || (start > end) || (end > s.length()))
            throw new IndexOutOfBoundsException(
                    "start " + start + ", end " + end + ", s.length() "
                            + s.length());
        int len = end - start;
        ensureCapacityInternal(count + len, len);
        for (int i = start, j = count; i < end; i++, j++)
            value[j] = s.charAt(i);
        count += len;
        return this;
    }

    public JefStringBuilder append(Object obj) {
        return append(String.valueOf(obj));
    }

    /**
     * 向前追加
     * @param str
     * @return
     */
    public JefStringBuilder preAppand(String str) {
        if (str == null) {
            return this;
        }
        int len = str.length();
        int newLength = count + len;
        preEnsureCapacityInternal(newLength, len);
        int length = value.length;
        preCursor = preCursor - len;
        str.getChars(0, len, value, preCursor);
        count += len;
        return this;
    }

    /**
     * 向前扩容
     * @param minimumCapacity 扩容的长度
     * @param len 当前字符串的长度，用来判断是否需要扩容
     */
    private void preEnsureCapacityInternal(int minimumCapacity,int len) {
        // 如果当前指针的位置减去将要存入数组的字符串长度，如果不够存，意味着要扩容
        if ((preCursor - len) < 0) {
            int persSize = newCapacity(minimumCapacity);
            // 数组向前扩容
            char[] copy = new char[persSize + value.length];
            //char[] copy = new char[persSize + count];
            System.arraycopy(value, preCursor, copy, preCursor + persSize, value.length - preCursor);
            int oldPreCursor = preCursor;
            preCursor = oldPreCursor + copy.length - value.length ;
            fixCursor = fixCursor + preCursor - oldPreCursor;
            value = copy;
            copy = null;
        }
    }

    private JefStringBuilder appendNull() {
        int c = count;
        ensureCapacityInternal(c + 4, 4);
        final char[] value = this.value;
        value[c++] = 'n';
        value[c++] = 'u';
        value[c++] = 'l';
        value[c++] = 'l';
        count = c;
        return this;
    }

    /**
     * 向后扩容
     * @param minimumCapacity 扩容的长度
     * @param len 当前字符串的长度，用来判断是否需要扩容
     */
    private void ensureCapacityInternal(int minimumCapacity, int len) {

        if ((fixCursor + len-value.length) > 0) {
            value = Arrays.copyOf(value, newCapacity(minimumCapacity));
        }
    }

    /**
     * 计算新容量
     * @param minCapacity
     * @return
     */
    private int newCapacity(int minCapacity) {
        // overflow-conscious code
        int newCapacity = (value.length << 1) + 2;
        if (newCapacity - minCapacity < 0) {
            newCapacity = minCapacity;
        }
        return (newCapacity <= 0 || MAX_ARRAY_SIZE - newCapacity < 0)
                ? hugeCapacity(minCapacity)
                : newCapacity;
    }

    private int hugeCapacity(int minCapacity) {
        if (Integer.MAX_VALUE - minCapacity < 0) { // overflow
            throw new OutOfMemoryError();
        }
        return (minCapacity > MAX_ARRAY_SIZE)
                ? minCapacity : MAX_ARRAY_SIZE;
    }

    public String toString() {
        // Create a copy, don't share the array
        return new String(value, preCursor, count);
    }

    public int length() {
        return count;
    }

}

单元测试案例

package com.cz;

import com.cz.redis.JefStringBuilder;
import org.junit.jupiter.api.Test;

import java.util.Stack;

/**
 * @program: Reids
 * @description: 测试字符串拼接
 * @author: Cheng Zhi
 * @create: 2023-03-24 09:41
 **/
public class TestJefStringBuilder {

    /**
     * @author Chengzhi
     * @date 2023-03-24
     * @测试目的：测试String类型向后循环追加的耗时以及内存占用情况
     * @测试结果:  内存消耗：cost -174393888 byte (-170306 KB).
     *             时间消耗：cost 9499 milliseconds (9 seconds).
     * @特殊说明：消耗内存出现负数的原因：在运行过程中，内存不够用时，Java的垃圾回收器(gc)会回收垃圾内存(没有引用的对象)
     */
    @Test
    public void testStringConcatAfter(){
        TimeLag timeLag = new TimeLag();
        timeLag.openMemoStat();
        String str = "a";
        for (int i = 0; i< 100000; i++) {
            str = str + i;
        }
        System.out.println(timeLag.cost());
    }

    /**
     * @author Chengzhi
     * @date 2023-03-24
     * @测试目的： 测试String类型向前循环追加的耗时以及内存占用情况
     * @测试结果: 内存消耗：cost -291341328 byte (-284513 KB).
     *            时间消耗：cost 10671 milliseconds (10 seconds).
     * @特殊说明：消耗内存出现负数的原因：在运行过程中，内存不够用时，Java的垃圾回收器(gc)会回收垃圾内存(没有引用的对象)
     */
    @Test
    public void testStringConcatBefore(){
        TimeLag timeLag = new TimeLag();
        timeLag.openMemoStat();
        String str = "a";
        for (int i = 0; i< 100000; i++) {
            str = i + str;
        }
        System.out.println(timeLag.cost());
    }

    /**
     * @author Chengzhi
     * @date 2023-03-24
     * @测试目的：测试StringBuilder向后循环追加的耗时以及内存占用情况
     * @预期结果: 内存消耗：cost 6457160 byte (6305 KB).
     *            时间消耗：cost 21 milliseconds (0 seconds).
     */
    @Test
    public void testStringBuiderConcatAfter(){
        TimeLag timeLag = new TimeLag();
        timeLag.openMemoStat();
        StringBuilder str = new StringBuilder();
        str.append("a");
        for (int i = 0; i< 100000; i++) {
            str.append(i);
        }
        System.out.println(timeLag.cost());
    }

    /**
     * @author Chengzhi
     * @date 2023-03-24
     * @测试目的： 测试StringBuilder向前循环追加的耗时以及内存占用情况,由于stringbuilder为提供直接向前拼接的方法，所以只能用插入的方式变相实现。
     * @预期结果: 内存消耗：cost 11221808 byte (10958 KB).
     *            时间消耗：cost 1108 milliseconds (1 seconds).
     */
    @Test
    public void testStringBuiderConcatBefore(){
        TimeLag timeLag = new TimeLag();
        timeLag.openMemoStat();
        StringBuilder str = new StringBuilder();
        str.append("a");
        for (int i = 0; i< 100000; i++) {
            str.insert(0,i);
        }
        System.out.println(timeLag.cost());
    }

    /**
     * @author Chengzhi
     * @date 2023-03-24
     * @测试目的： 通过栈和StringBuilder变相实现字符串向前拼接,测试内存以及耗时情况。
     * @预期结果: 内存消耗：cost 20428544 byte (19949 KB).
     *            时间消耗：cost 52 milliseconds (0 seconds).
     */
    @Test
    public void testStringBuilderWith(){
        TimeLag timeLag = new TimeLag();
        timeLag.openMemoStat();
        Stack<String> stack = new Stack<String>();
        stack.push("a");
        for (int i=0;i<100000; i++) {
            stack.push(i+"");
        }
        int stackSize = stack.size();
        StringBuilder stringBuilder = new StringBuilder();
        for (int i=0; i<stackSize; i++) {
            stringBuilder.append(stack.pop());
        }
        System.out.println(timeLag.cost());
    }

    /**
     * @author Chengzhi
     * @date 2023-03-24
     * @测试目的：测试JefStringBuilder向后循环追加的耗时以及内存占用情况
     * @预期结果: 内存消耗：cost 14229360 byte (13895 KB).
     *            时间消耗：cost 41 milliseconds (0 seconds).
     */
    @Test
    public void testJefStringBuiderConcatAfter(){
        TimeLag timeLag = new TimeLag();
        timeLag.openMemoStat();
        JefStringBuilder str = new JefStringBuilder();
        str.append("a");
        for (int i = 0; i< 100000; i++) {
            str.append(i);
        }
        System.out.println(timeLag.cost());
    }

    /**
     * @author Chengzhi
     * @date 2023-03-24
     * @测试目的：测试JefStringBuilder向前循环追加的耗时以及内存占用情况
     * @预期结果: 内存消耗：cost 20120968 byte (19649 KB).
     *            时间消耗：cost 31 milliseconds (0 seconds).
     */
    @Test
    public void testJefStringBuiderConcatBefore(){
        TimeLag timeLag = new TimeLag();
        timeLag.openMemoStat();
        JefStringBuilder str = new JefStringBuilder();
        str.append("a");
        for (int i = 0; i< 100000; i++) {
            str.preAppand(i+"");
        }
        System.out.println(timeLag.cost());
    }
}

综上可以发现，自己实现的字符串拼接在效率上还是比较占优势的。

另附上效率统计工具：

package com.cz;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.Date;

/**
 * 工具类，打印耗时
 * @program: PostGirl-panent
 * @description: TimeLag
 * @author: Cheng Zhi
 * @create: 2021-04-29 11:18
 **/
public class TimeLag {

    Logger logger = LoggerFactory.getLogger(TimeLag.class);

    private Date startDate;
    private Date endDate;
    private long startMemeory;
    private long endMemorty;
    private Runtime runtime;
    private boolean isOpenMemoryStatistics = false;
    public TimeLag() {
        startDate = new Date();
    }

    public void openMemoStat() {
        isOpenMemoryStatistics = true;
        // 先执行gc
        runtime = Runtime.getRuntime();
        runtime.gc();
        startMemeory = runtime.totalMemory();
    }
    /**
     * 返回耗时
     * @return
     */
    public String cost() {
        endDate = new Date();
        long cont = endDate.getTime() - startDate.getTime();
        StringBuffer stringBuffer = new StringBuffer();
        if (isOpenMemoryStatistics) {
            endMemorty = runtime.freeMemory();
            long contMemory = startMemeory - endMemorty;
            stringBuffer.append("cost ").append(contMemory).append(" byte (").append(contMemory / 1024).append(" KB).").append('\n');
        }
        String s = stringBuffer.append("cost ").append(cont).append(" milliseconds (").append(cont / 1000).append(" seconds).").toString();
        return s;
    }

    public static void main(String[] args) {
        TimeLag lag = new TimeLag();
        lag.openMemoStat();
        int s = 0;
        for ( int i=0; i<100000; i++) {

            for (int j = 100000; j>i; j--) {
                s = j+i;
            }

        }
        System.out.println(s);
        System.out.println(lag.cost());
    }
}
ะัี潪ิื
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
StringBuffer
weixin_63865844的博客
04-23 2436
StringBuffer类的概述 我们如果对字符串进行拼接操作，每次拼接，都会构建一个新的String对象，既耗费时间，又浪费空间，而StringBuffer类就可以解决这个问题。 StringBuffer时一个线程安全的可变字符序列 StringBuffer类的构造方法 1.构造方法 public StringBuffer():无参构造 public StringBuffer(int capacity):指定容量的字符串缓冲区对象 public StringBuffer(String str
C#学习笔记——StringBuilder类
oyqho的博客
01-20 817
在C#中，有一个非常实用的创建字符型数据的类——StringBuilder类，使用StringBuilder，可以创建出字符串，并且StringBuilder中封装的有许多对字符串进行操作的方法（这一点很方便）。比如说字符串是固定长度的，但是通过StringBuilder类中的Append()方法就可以改变字符串的长度。StringBuilder类的使用需要在前面加上System.Text。从上面的例子可以看到，字符串明显是变长了。
StringBuilder在字符串前面加字符
热门推荐
yinni11的博客
03-21 3万+
StringBuilder sb = new StringBuilder(); sb.append( "B" ); // 追加一个字符：B sb.insert( 0 , "A" ); // 在最前面插入一个：A 那么sb的结果就是：AB
StringBuilder如何在前面添加字符？
(╯3╰)
05-14 1万+
public StringBuilder insert(int offset, char c) offset必须大于等于0，且小于等于字符串的最大长度。如果offset=0，则在字符串首位插入指定的值。
java StringBuilder向前追加
李程程的博客
04-14 4528
java StringBuilder向前追加 java StringBuilder向前追加 StringBuilder sb = new StringBuilder(); sb.append("1"); sb.append("2"); sb.append("3"); sb.append("4"); sb.append("5"); sb.insert(0,"0"); //结果为：012345
C#中String和StringBuilder的简介与区别
08-26
C#中String和StringBuilder的简介与区别 String类型对象的特点： 1.它是引用类型，在堆上分配内存 2.运算时会产生一个新的实例 ...在实际应用中，选择合适的字符串类型可以提高程序的性能和效率。
C#使用String和StringBuilder运行速度测试及各自常用方法简介
08-26
C#使用String和StringBuilder运行速度测试及各自常用方法简介 在C#语言中，String和StringBuilder都是用于处理字符串的类，但是它们在性能和使用场景方面有很大的区别。本文将对String和StringBuilder进行运行速度...
Java 中 String，StringBuffer 和 StringBuilder 的区别及用法
08-31
StringBuffer 是 Java 中的字符串构建器之一，它可以解决 String 类型的不可变性问题。StringBuffer 是一个可变的字符串序列，这意味着可以对其进行增、删、改的操作。 StringBuffer 的特点是线程安全的，可以在多...
java String、StringBuilder和StringBuffer的区别详解
08-25
Java中的`String`、`StringBuilder`和`StringBuffer`都是用来处理字符串的类，它们各自有不同的特性和适用场景。在理解它们之间的区别之前，我们首先要知道它们的共同点。 **共同点：** 1. **都是字符串类**：这三...
String和StringBuilder效率测试
07-30
在Java编程语言中，`String`和`StringBuilder`都是用于处理字符串的重要类，但它们在处理方式和效率上有显著的区别。本资源中的代码是针对这两种类的效率进行测试的实例，旨在帮助开发者理解它们在不同场景下的性能...
java StringBuilder向前添加字符串
qq_61348511的博客
06-12 647
java StringBuilder向前添加字符串
Java中StringBuffer的用法
Wxiaozhong的博客
01-12 560
public class Test { public static void main(String[] args) { Scanner input = new Scanner(System.in); System.out.println("输入一串数字"); String str = input.next(); StringBuffer sb = new StringBuffer(str); //最好是从后往前追加.
StringBuffer的添加功能：
why
07-31 450
package cn.itcast_02; /*  * StringBuffer的添加功能：  * public StringBuffer append(String str):可以把任意类型数据添加到字符串缓冲区里面,并返回字符串缓冲区本身  *   * public StringBuffer insert(int offset,String str):在指定位置把任意类型的数
StringBuffer类中的append方法
qq_46940224的博客
12-27 1937
StringBuffer类中的append方法
Java中StringBuffer的添加功能
weixin_57219176的博客
04-09 2175
* 添加功能： * append(boolean/int/String...) * 追加到末尾，可以追加任何数据，返回值是它本身 * public StringBuffer insert(int offset,String str) * 在指定位置添加字符(在指定位置数的前面插入) public class StringBufferDemo { public static void main(String[] args) { //...
JAVA进阶教学之（StrngBuffer进行字符串拼接）
LBJ8888888的博客
03-12 624
使用StringBuffer字符串拼接目的就是为了让字符串占用的内存空间减少，提高效率 思考：我们在实际的开发中，如果需要进行字符串的频繁拼接，会有什么问题？ 答案： 因为java中的字符串是不可变的，每一次拼接都会产生新的字符串，这样会占用大量的方法区内存，造成内存空间的浪费 底层分析： 代码演示： public class StringTest05 { public static void main(String[] args) { Str...
（JAVA）:字符串的拼接插入-----StringBuffer类的常见API
yzh2776680982的博客
04-02 2708
前言： 1、StringBuffer类的初始化 注意： StringBuffer在字符串操作上克服了String拼接会产生多个对象的问题。它可以以一个字符串作为参数进行初始化。 常见的三种初始化： 第一种： StringBuffer str1 = new StringBuffer(); //无参构造函数初始化 第二种： StringBuffer str1 = new StringBuffer("ting"); //使用字符串对象进行初始化 第三种： ...
Java 中的 String、StringBuilder、StringBuffer 的区别
Chittyo
10-22 2173
一、是什么？ String 不可变字符序列 String 是字符串常量，其对象一旦创建之后该对象是不可更改的， 因此在每次对 String 类型进行改变的时候其实都等同于生成了一个新的 String 对象，然后将指针指向新的 String 对象，所以经常改变内容的字符串最好不要用 String ，因为每次生成新对象都会开辟新的内存空间，不仅占用大量内存空间，特别当内存中无引用对象多了以后， JVM 的 GC 就会开始工作，那速度一定是相当慢的，对系统性能产生影响。 String 这个类很特殊，特殊在于
string 和stringbuilder
最新发布
09-23
string和stringbuilder都是Java中用于存储和操作字符串的类。string是不可变的，意味着一旦创建了string对象，就无法修改其内容。而stringbuilder是可变的，可以在已有字符串的基础上进行添加、删除和修改操作。 ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值