Временная сложность подстроки Java ()

Какова временная сложность метода String#substring() в Java?

73 голоса | спросил TimeToCodeTheRoad 13 Jpm1000000pmThu, 13 Jan 2011 14:57:54 +030011 2011, 14:57:54

6 ответов


0

Новый ответ

Начиная с обновления 6 во время жизни Java 7, поведение substring изменилось для создания копии - так что каждый String относится к char[], которое не поделился с любым другим объектом, насколько я знаю. Таким образом, в этот момент substring() стало операцией O (n), где n - это числа в подстроке.

Старый ответ: до Java 7

Недокументированное - но на практике O (1), если вы предполагаете, что сборка мусора не требуется и т. д.

Он просто создает новый объект String, ссылающийся на тот же базовый char[] но с другими значениями смещения и числа. Таким образом, стоимость - это время, затрачиваемое на проверку и создание одного нового (достаточно маленького) объекта. Это O (1), поскольку разумно говорить о сложности операций, которые могут изменяться во времени в зависимости от сборки мусора, кэшей ЦП и т. Д. В частности, это не зависит напрямую от длины исходной строки или подстроки. .

ответил Jon Skeet 13 Jpm1000000pmThu, 13 Jan 2011 15:00:29 +030011 2011, 15:00:29
0

Это был O (1) в старых версиях Java - как сказал Джон, он просто создал новую строку с тем же базовым значением char [], с другим смещением и длиной.

Однако на самом деле это изменилось, начиная с Java 7, обновление 6.

Совместное использование char [] было удалено, а поля смещения и длины были удалены. substring () теперь просто копирует все символы в новую строку.

Ergo, подстрока - это O (n) в Java 7, обновление 6

ответил Chi 21 stEurope/Moscowp30Europe/Moscow09bEurope/MoscowFri, 21 Sep 2012 02:27:16 +0400 2012, 02:27:16
0

Теперь это линейная сложность. Это после устранения проблемы утечки памяти для подстроки.

Итак, из Java 1.7.0_06 помните, что String.substring теперь имеет линейную сложность вместо постоянной.

ответил friends.pallav 28 SatEurope/Moscow2013-12-28T00:25:50+04:00Europe/Moscow12bEurope/MoscowSat, 28 Dec 2013 00:25:50 +0400 2013, 00:25:50
0

O (1), потому что копирование исходной строки не выполняется, просто создается новый объект-обертка с другой информацией о смещении.

ответил rodion 13 Jpm1000000pmThu, 13 Jan 2011 15:01:52 +030011 2011, 15:01:52
0

Судите сами, но недостатки производительности 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");
    }

Вывод:

подстрока 32768 раз
Сумма длин разбиений = 1494414
Прошло 2,446679 мс

Если это O (1) или нет, зависит. Если вы просто ссылаетесь на одну и ту же строку в памяти, то представьте очень длинную строку, вы создадите подстроку и прекратите ссылаться на длинную строку. Было бы неплохо освободить память на долгое время?

ответил peenut 13 Jpm1000000pmThu, 13 Jan 2011 15:11:45 +030011 2011, 15:11:45
0

Добавление доказательства к ответу Джона. У меня были те же сомнения и я хотел проверить, влияет ли длина строки на функцию подстроки. Написан следующий код, чтобы проверить, от чего зависит подстрока параметра.

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

Проверка функции подстроки зависит от длины запрашиваемой подстроки, а не от длины строки.

ответил Konduri Pavan Kumar 11 Jpm1000000pmFri, 11 Jan 2019 13:34:17 +030019 2019, 13:34:17

Похожие вопросы

Популярные теги

security × 330linux × 316macos × 2827 × 268performance × 244command-line × 241sql-server × 235joomla-3.x × 222java × 189c++ × 186windows × 180cisco × 168bash × 158c# × 142gmail × 139arduino-uno × 139javascript × 134ssh × 133seo × 132mysql × 132