Кофе-брейк #227. В чем разница между String и StringBuilder в Java. Зачем нужны итераторы в Java-коде

В чем разница между String и StringBuilder в Java

Источник: Medium Это руководство поможет вам углубить понимание классов String и StringBuilder. Вы узнаете об их характеристиках, различиях и вариантах использования на соответствующих примерах кода. Поскольку Java — это широко используемый язык программирования, он предлагает множество способов работы со строками. Среди них для обработки строк чаще всего применяются String и StringBuilder.

Неизменяемые строки

Как известно, в Java строки неизменяемы. Это означает, что после создания объекта String вы не можете изменить его содержимое. Вот простая демонстрация:

String str = "Hello, ";
str += "World!";
System.out.println(str);  // Вывод: Hello, World!

В этом примере может показаться, что мы изменили str, но на самом деле произошло то, что новый объект String был создан с комбинированным содержимым. Исходный строковый объект “Hello, ” все еще существует в памяти, но он потерян для нас, потому на него больше нет ссылки. Все это может привести к неэффективному использованию памяти, особенно при работе с большими объемами строковых данных.

Представляем StringBuilder

Java предлагает решение этой потенциальной неэффективности с помощью класса StringBuilder. В отличие от String, StringBuilder является изменяемым, то есть его содержимое может быть изменено после его создания.

StringBuilder sb = new StringBuilder("Hello, ");
sb.append("World!");
System.out.println(sb.toString());  // Вывод: Hello, World!

Здесь мы создаем StringBuilder с “Hello,”, а затем добавляем к нему “World!”. Во время этого процесса не создаются новые объекты, что делает StringBuilder более экономичным вариантом при выполнении нескольких обработок строк.

Сравнение String и StringBuilder

При принятии решения об использовании String или StringBuilder важно учитывать вариант использования. Вот ключевые факторы, на которые стоит обратить внимание:

• Производительность: StringBuilder работает быстрее при выполнении нескольких конкатенаций, так как не создает каждый раз новый объект.
• Безопасность потоков: String является потокобезопасным, потому что он неизменяем. Несколько потоков не могут изменить свое состояние. Тогда как StringBuilder не является потокобезопасным. Поэтому если вам нужно обработать строки в нескольких потоках, то наверное стоит рассмотреть StringBuffer, который является потоко-ориентированным вариантом StringBuilder.
• Сложность: для простых строковых операций, где производительность не имеет значения, использование String может упростить чтение и понимание кода.

Давайте взглянем на пример, демонстрирующий разницу в производительности между String и StringBuilder:

long startTime = System.currentTimeMillis();
String str = "";
for (int i = 0; i < 10000; i++) {
    str += i;
}
long endTime = System.currentTimeMillis();
System.out.println("Time taken by String: " + (endTime - startTime) + "ms");

startTime = System.currentTimeMillis();
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 10000; i++) {
    sb.append(i);
}
endTime = System.currentTimeMillis();
System.out.println("Time taken by StringBuilder: " + (endTime - startTime) + "ms");

Здесь мы добавляем числа от 0 до 9999 к String и StringBuilder. Время, затрачиваемое StringBuilder, значительно меньше, чем у String.

Заключение

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

Зачем нужны итераторы в Java-коде

Источник: Medium Данная публикация подробно объясняет, зачем нужно использовать итераторы в коде Java. Также вы ознакомитесь с примерами кода, в которых применяется интерфейс Iterator. В языке Java итератор (iterator) — это объект, который предоставляет способ перебора коллекции элементов, например LinkedList или HashSet. Итератор позволяет выполнять такой перебор (каждый шаг цикла называется итерацией) по элементам, обращаясь к каждому элементу поочередно без необходимости знать базовую реализацию коллекции, используемую для хранения элементов. Многие коллекции в Java по умолчанию реализуют интерфейс Iterator. Это значит, что они по умолчанию совместимы с итераторами. Перед вами список некоторых часто используемых коллекций в Java, которые реализуют интерфейс Iterator:

• ArrayList
• LinkedList
• Vector
• Stack
• Queue
• HashSet
• TreeSet
• HashMap
• TreeMap

Интерфейс Iterator определяет три основных метода, которые используются для обхода коллекции:

• hasNext() — возвращает true, если текущий элемент имеет следующий элемент, который соответствует текущему элементу, не являющемуся последним элементом коллекции.
• next() — возвращает следующий элемент в коллекции.
• remove() — удаляет последний элемент, возвращенный итератором. Он полезен, поскольку может просто удалить элемент без использования разработчиком методов связанной коллекции для удаления элемента. Метод итератора remove() сам вызывает необходимые методы и выполняет работу за вас.

Чтобы использовать метод remove(), вы должны сначала вызвать метод next(), чтобы получить элемент, который нужно удалить из коллекции. Если вы вызовете метод remove() без предварительного вызова next(), то получите исключение IllegalStateException. Ниже приведен фрагмент кода, показывающий, как выполняется итерация с помощью Iterator:

ArrayList<String> fruits = new ArrayList<>();
        fruits.add("Apple");
        fruits.add("Banana");
        fruits.add("Orange");

        Iterator<String> iterator = fruits.iterator();
        while (iterator.hasNext()) {
            String fruit = iterator.next();
            System.out.println(fruit);
        }

А далее у нас фрагмент, показывающий, как применяя итераторы можно удалить элемент из коллекции:

ArrayList<Integer> numbers = new ArrayList<>();
        numbers.add(10);
        numbers.add(20);
        numbers.add(30);

        Iterator<Integer> iterator = numbers.iterator();
        while (iterator.hasNext()) {
            int number = iterator.next();
            if (number > 20) {
                iterator.remove();
            }
        }

        System.out.println(numbers); // Вывод: [10, 20]

Зачем использовать итераторы в Java-коде?

Существует много преимуществ использования итераторов. Вот лишь некоторые из них, которые я считаю наиболее важными: Простота и удобочитаемость. Итераторы абстрагируются от базовой функциональности при доступе или удалении элемента из коллекции. Если вы работаете с несколькими коллекциями/типами данных, то можете использовать итераторы для создания общих и многократно используемых методов для работы с элементами из разных коллекций. Безопасность. Итераторы создают четкое разделение между процессом итерации и базовой структурой данных, тем самым предотвращая любые случайные модификации, ошибки индексации и другие проблемы, которые могут вызвать неприятные сюрпризы. Настройка. Вы можете создавать настраиваемые итераторы для различных целей, чтобы перемещаться по коллекции определенным образом в соответствии с потребностями вашей программы и избегать дублирования кода. Обратите внимание на “ленивое удаление” (lazy deletion) как простой вариант использования этого аспекта. Обработка исключений. В большинстве случаев итераторы имеют встроенную обработку исключений. Таким образом, если во время обхода возникает ошибка, то итератор выдает исключение, помогая вам более эффективно отлаживать код.

Заключение

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