Разница между String.isEmpty() и String.equals("")

Ответ 1

Я думаю, что isEmpty() немного эффективнее. Однако интеллектуальный компилятор может в любом случае оптимизировать вызов equals(""). Из OpenJDK source:

  671     public boolean isEmpty() {
  672         return count == 0;
  673     }

 1013     public boolean equals(Object anObject) {
 1014         if (this == anObject) {
 1015             return true;
 1016         }
 1017         if (anObject instanceof String) {
 1018             String anotherString = (String)anObject;
 1019             int n = count;
 1020             if (n == anotherString.count) {
 1021                 char v1[] = value;
 1022                 char v2[] = anotherString.value;
 1023                 int i = offset;
 1024                 int j = anotherString.offset;
 1025                 while (n-- != 0) {
 1026                     if (v1[i++] != v2[j++])
 1027                         return false;
 1028                 }
 1029                 return true;
 1030             }
 1031         }
 1032         return false;
 1033     }

Также ответ здесь о том, следует ли использовать str.isEmpty() или "".equals(str):

Основное преимущество "".equals(s) - вам не нужна нулевая проверка (equals проверит его аргумент и вернет false, если он равен null), который вам, похоже, не волнует. Если вы не беспокоитесь о том, что s является нулевым (или иным образом проверяют его), я бы определенно использовал s.isEmpty(); он точно показывает, что вы проверяете, вы заботитесь о том, пустой или нет s, а не он равен пустой строке

Ответ 2

Да, используйте String.isEmpty(). Это чище (семантически) (производительность также немного лучше, но это было бы незаметно). Если экземпляр может быть нулевым, используйте commons-lang StringUtils.isEmpty(string)

Ответ 3

Так как isEmpty() проверяет, равна ли длина String 0 и "" единственной String с длиной 0, каждая String, для которой isEmpty() возвращает true, также возвращает true > до .equals(""). Так что технически они делают то же самое.

Там может быть минимальная разница в производительности, но я бы не стал об этом беспокоиться (я был бы очень удивлен, если бы это было заметно в производственном коде).

Другое отличие - если вы написали "".equals(someString), тогда это будет "null -safe". Другими словами: если someString был null, эта конструкция просто оценивалась бы до false и не выбрала бы NullPointerException. Если, однако, у вас есть someString.equals(""), это не будет применяться.

Самое важное отличие состоит в том, как он читается: isEmpty() делает намерение очень ясным: вы хотите по-разному обрабатывать пустые строки. .equals("") всегда немного менее ясен ( "если эта строка равна этой другой строке, которая оказывается пустой" ).

Ответ 4

Как правило, мне нравится использовать equals, но наоборот, т.е.:

"".equals(someString);

Null-safe:)

Но да, isEmpty() - более простая операция, но не настолько, что я вижу, что она делает какой-то значительный вклад в производительность (если вы не пишете встроенные материалы в реальном времени).

Ответ 5

С myString.equals("") сначала компилятор создает объект String (он эквивалентен myString.equals(new String("")).

Итак, isEmpty() должен быть лучшим вариантом (хотя equals ("") очень популярен).

Ответ 6

В теории это так. Для isEmpty() необходимо просмотреть только внутренние метаданные строки (например, ее длину). Для сравнения, вы ожидаете, что произойдет еще несколько случаев дифференциации.

На практике это не имеет значения. Вы не заметили бы разницу в скорости.

Правило удара: используйте метод, который лучше всего понят/читается программистом. Если это тест для пустой строки, я думаю, что isEmpty() лучше подходит для этой цели.

Ответ 7

isEmpty() быстрее, потому что он сравнивает только целочисленное поле length в классе String с 0, в то время как сравнение с пустой строкой будет в лучшем случае сравнивать ссылки (аналогичная скорость), а в худшем - запустить цикл с 0 итераций.

Но самое большое различие - читаемость - isEmpty() короче и легче понять. BTW Мне жаль, что есть isBlank() сокращение для .trim().isEmpty()...

Ответ 8

Еще одна причина использования myString.equals("") или myString.length() == 0 заключается в том, что метод String#isEmpty() был введен в Java 1.6.

Так что аргументы для использования String#isEmpty() могут быть соображениями совместимости с предыдущими версиями Java.

Ответ 9

Отчасти это вопрос истории и наследия. isEmpty() был добавлен только в JDK 6:

/**
 * Returns <tt>true</tt> if, and only if, {@link #length()} is <tt>0</tt>.
 *
 * @return <tt>true</tt> if {@link #length()} is <tt>0</tt>, otherwise
 * <tt>false</tt>
 *
 * @since 1.6
 */
public boolean isEmpty() {

До этого все по сравнению с "", чтобы увидеть, была ли строка пустой или нет. Старые привычки умирают тяжело, поэтому многие люди продолжают использовать сравнение "".

Конечно, как уже упоминалось кем-то еще, если вы используете "".equals(someString), то он автоматически недействителен. Многие люди объединяют идею isEmpty с нулевой безопасностью, создавая static isEmpty method.

Ответ 10

isEmpty был введен только в 1.6. Проверить с тегом javadoc.

Поэтому, если вы компилируете для 1.5 и ниже equals(""), это ваш единственный выбор.

Однако, если совместимость версий не беспокоит вас, я бы использовал isEmpty. Как заметил Божо, он семантически чист (и немного быстрее).

Ответ 11

Я всегда использовал .isEmpty()... до сегодняшнего дня, когда обнаружил, что он не существует на Java 5.

Итак:

• В Java 6 и новее у нас есть выбор, и я рекомендую использовать .isEmpty(), его легче писать и читать более четко.
• В Java 5 и старше мы должны использовать .equals("").

Ответ 12

String.equals("") бит медленнее, чем просто вызов isEmpty(). Строки хранят переменную count, инициализированную в конструкторе, поскольку строки являются неизменяемыми.

isEmpty() сравнивает переменную count с 0, а equals проверяет тип, длину строки и затем перебирает строку для сравнения, если размеры совпадают.

Итак, чтобы ответить на ваш вопрос, isEmpty() на самом деле сделает намного меньше! и это хорошо.