Question

Java中String#substring()方法的时间复杂度是什么？

Answer 1

新答案

从Java 7生命周期中的更新6开始，substring的行为已更改为创建副本 - 因此每String个引用char[] >据我所知，>与任何其他对象共享。所以在这一点上，substring()变成了一个O（n）操作，其中n是子串中的数字。

旧答案：Java 7之前

未记载 - 但在实践中O（1）如果您认为不需要垃圾收集等等。

它只是构建一个新的String对象，引用相同的基础char[]，但具有不同的偏移量和计数值。因此，成本是执行验证和构建单个新（合理小）对象所花费的时间。这是O（1），因为谈论基于垃圾收集，CPU缓存等可以随时间变化的操作的复杂性是明智的。特别是，它不直接取决于原始字符串或子串的长度

Answer 2

在Java的旧版本中是O（1） - 正如Jon所说，它只是创建了一个具有相同底层char []的新String，以及不同的偏移量和长度。

然而，实际上这已经从Java 7更新6开始改变了。

消除了char []共享，并删除了偏移和长度字段。 substring（）现在只是将所有字符复制到一个新的字符串中。

Ergo，子串在Java 7 update 6中是O（n）

Answer 3

现在是线性复杂性。这是在修复子串的内存泄漏问题之后。

因此，从Java 1.7.0_06开始，请记住String.substring现在具有线性复杂度而不是常量复杂度。

Answer 4

O（1）因为没有复制原始字符串，所以它只是创建一个具有不同偏移信息的新包装器对象。

Answer 5

从跟随判断你自己，但Java的性能缺点在于其他地方，而不是在字符串的子串中。代码：

public static void main(String[] args) throws IOException {

        String longStr = "asjf97zcv.1jm2497z20`1829182oqiwure92874nvcxz,nvz.,xo" + 
                "aihf[oiefjkas';./.,z][p\\°°°°°°°°?!(*#&(@*&#!)^(*&(*&)(*&" +
                "fasdznmcxzvvcxz,vc,mvczvcz,mvcz,mcvcxvc,mvcxcvcxvcxvcxvcx";
        int[] indices = new int[32 * 1024];
        int[] lengths = new int[indices.length];
        Random r = new Random();
        final int minLength = 6;
        for (int i = 0; i < indices.length; ++i)
        {
            indices[i] = r.nextInt(longStr.length() - minLength);
            lengths[i] = minLength + r.nextInt(longStr.length() - indices[i] - minLength);
        }

        long start = System.nanoTime();

        int avoidOptimization = 0;
        for (int i = 0; i < indices.length; ++i)
            //avoidOptimization += lengths[i]; //tested - this was cheap
            avoidOptimization += longStr.substring(indices[i],
                    indices[i] + lengths[i]).length();

        long end = System.nanoTime();
        System.out.println("substring " + indices.length + " times");
        System.out.println("Sum of lengths of splits = " + avoidOptimization);
        System.out.println("Elapsed " + (end - start) / 1.0e6 + " ms");
    }

输出：

substring 32768 times
Sum of lengths of splits = 1494414
Elapsed 2.446679 ms

如果是（1）或不是，取决于。如果你只是在内存中引用相同的String，那么想象一下非常长字符串，你创建子字符串并停止引用长字符串。长期释放记忆力不是很好吗？

Answer 6

为Jon的答案添加证据。我也有同样的疑问，想检查字符串的长度是否对子字符串功能有任何影响。编写以下代码，检查实际取决于哪个参数子字符串。

import org.apache.commons.lang.RandomStringUtils;

public class Dummy {

    private static final String pool[] = new String[3];
    private static int substringLength;

    public static void main(String args[]) {
        pool[0] = RandomStringUtils.random(2000);
        pool[1] = RandomStringUtils.random(10000);
        pool[2] = RandomStringUtils.random(100000);
        test(10);
        test(100);
        test(1000);
    }

    public static void test(int val) {
        substringLength = val;
        StatsCopy statsCopy[] = new StatsCopy[3];
        for (int j = 0; j < 3; j++) {
            statsCopy[j] = new StatsCopy();
        }
        long latency[] = new long[3];
        for (int i = 0; i < 10000; i++) {
            for (int j = 0; j < 3; j++) {
                latency[j] = latency(pool[j]);
                statsCopy[j].send(latency[j]);
            }
        }
        for (int i = 0; i < 3; i++) {
            System.out.println(
                    " Avg: "
                            + (int) statsCopy[i].getAvg()
                            + "\t String length: "
                            + pool[i].length()
                            + "\tSubstring Length: "
                            + substringLength);
        }
        System.out.println();
    }

    private static long latency(String a) {
        long startTime = System.nanoTime();
        a.substring(0, substringLength);
        long endtime = System.nanoTime();
        return endtime - startTime;
    }

    private static class StatsCopy {
        private  long count = 0;
        private  long min = Integer.MAX_VALUE;
        private  long max = 0;
        private  double avg = 0;

        public  void send(long latency) {
            computeStats(latency);
            count++;
        }

        private  void computeStats(long latency) {
            if (min > latency) min = latency;
            if (max < latency) max = latency;
            avg = ((float) count / (count + 1)) * avg + (float) latency / (count + 1);
        }

        public  double getAvg() {
            return avg;
        }

        public  long getMin() {
            return min;
        }

        public  long getMax() {
            return max;
        }

        public  long getCount() {
            return count;
        }
    }

}

在Java 8中执行时的输出为：

 Avg: 128    String length: 2000    Substring Length: 10
 Avg: 127    String length: 10000   Substring Length: 10
 Avg: 124    String length: 100000  Substring Length: 10

 Avg: 172    String length: 2000    Substring Length: 100
 Avg: 175    String length: 10000   Substring Length: 100
 Avg: 177    String length: 100000  Substring Length: 100

 Avg: 1199   String length: 2000    Substring Length: 1000
 Avg: 1186   String length: 10000   Substring Length: 1000
 Avg: 1339   String length: 100000  Substring Length: 1000

证明子字符串功能取决于请求的子字符串的长度，而不取决于字符串的长度。

Answer 7

之前 Java 1.7.0_06：O（1）。

之后 Java 1.7.0_06：O（n）。由于内存泄漏，此更改已更改。从字符串中删除字段offset和count之后，子字符串实现变为O（n）。

有关更多详细信息，请参阅：http://java-performance.info/changes-to-string-java-1-7-0_06/

Java的子串（）的时间复杂度

7 个答案: