Question

我的任务是创建一个内存有效方法，该方法采用由数字组成的String并删除任何开始的零。

例如“001112”变为“1112”。

public static String hej (String v)
{
    StringBuilder    h = new StringBuilder(v);
    while(true)
    {
        if (h.charAt(0) == '0')
            h.deleteCharAt(0);
        else
            break;
    }
    return h.toString();
}

这是我的解决方案。当然它可以完成这项工作，但我的问题是，使用StringBuilder是否具有内存效率，或者使用String本身更有效率，例如v.substring()？无法找到有关效率更高的信息。如果有人链接到某些文档，请分享。

干杯

Answer 1

使用String.substring(int)方法将是使用的内存最少

public static String hej(String input)
{
    int i;
    for(i = 0; i < input.length(); i++)
        if(input.charAt(i) != '0')
            break;
    return input.substring(i);
}

来自String的源代码：

public String substring(int beginIndex) {
    if (beginIndex < 0) {
        throw new StringIndexOutOfBoundsException(beginIndex);
    }
    int subLen = value.length - beginIndex;
    if (subLen < 0) {
        throw new StringIndexOutOfBoundsException(subLen);
    }
    return (beginIndex == 0) ? this : new String(value, beginIndex, subLen);
}

这会调用String(char[], int, int)构造函数

public String(char value[], int offset, int count) {
    if (offset < 0) {
        throw new StringIndexOutOfBoundsException(offset);
    }
    if (count <= 0) {
        if (count < 0) {
            throw new StringIndexOutOfBoundsException(count);
        }
        if (offset <= value.length) {
            this.value = "".value;
            return;
        }
    }
    // Note: offset or count might be near -1>>>1.
    if (offset > value.length - count) {
        throw new StringIndexOutOfBoundsException(offset + count);
    }
    this.value = Arrays.copyOfRange(value, offset, offset+count);
}

使用StringBuilder使用一点内存来为输入的大小创建StringBuilder，而使用String.substring(int)只会占用尽可能多的内存来表示修改后的内容输入

Answer 2

如果你的字符串有前导零的n，那么使用String而不是StringBuilder会消耗n倍的内存。你知道String每次在char发生一些变化时都会在内存中创建一个新的空间，所以StringBuilder就是你要去的地方。

请记住

每个字符串构建器都有容量。只要长度了字符串生成器中包含的字符序列不超过容量，没有必要分配新的内部缓冲区。如果内部缓冲区溢出，自动变大。

Oracle Docs

所以

字符串

String是不可变的（一旦创建无法更改）对象。该   作为String创建的对象存储在常量字符串池中。   Java中的每个不可变对象都是线程安全的，这意味着String是   也是线程安全的。两个线程不能使用字符串   同时。分配后的字符串无法更改。

String demo =＆＃34;你好＆＃34; ; //上面的对象存储在常量中   字符串池及其值无法修改。

演示=＆＃34;再见＆＃34; ; //新＆＃34;再见＆＃34; string是在常量池中创建的   由演变变量引用//＆＃34;你好＆＃34;字符串仍然   存在于字符串常量池中，其值不会被覆盖，但我们   失去对＆＃34; hello＆＃34;字符串
的引用
的StringBuffer

StringBuffer是可变的意味着可以更改对象的值。   通过StringBuffer创建的对象存储在堆中。   StringBuffer与StringBuilder具有相同的方法，但每个方法都是如此   StringBuffer中的方法是同步的，即StringBuffer是线程   安全。

由于这个原因，它不允许两个线程同时访问   同样的方法。每个方法一次可以由一个线程访问

但是线程安全也有缺点   StringBuffer由于线程安全属性而命中。因此StringBuilder是   调用每个方法的相同方法时比StringBuffer更快   类。

可以更改StringBuffer值，这意味着可以将其分配给   新的价值。如今这是一个最常见的面试问题   上述课程之间的差异。字符串缓冲区可以转换   使用toString（）方法将字符串转换为字符串。

StringBuffer demo1 = new StringBuffer（＆＃34; Hello＆＃34;）; //上面的对象   存储在堆中，其值可以更改。 demo1的新=   的StringBuffer（＆＃34;再见＆＃34）; //上面的陈述是正确的，因为它修改了   StringBuffer中允许的值

Java Hungry

内存高效方法String后缀

2 个答案: