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

Question

Я создал «Выбор цвета» с тремя текстовыми полями, где пользователь определяет значения rgb.
Чтобы проверить правильность введенных значений (только цифры от 0 до 255), я использую следующее:

public Color getColor() {
    if (tfRed.getText().equals("") || tfGreen.getText().equals("") || tfBlue.getText().equals("")) {
                return new Color(0, 0, 0, 0);
    } else {
        if (tfRed.getText().matches("\\d+") && tfGreen.getText().matches("\\d+") && tfBlue.getText().matches("\\d+")) {
            // ...
        } else {
            return new Color(0, 0, 0, 0);
        }
    }
}

Что я спрашиваю: лучше использовать String.isEmpty()? Я никогда не находил удовлетворительного ответа, и я всегда задавался вопросом, есть ли разница.

Answer 1

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

  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, если он нулевой), что, по-видимому, вас не волнует , Если вы не беспокоитесь о том, что s может быть нулевым (или иным образом проверяете его), я бы определенно использовал s.isEmpty(); он показывает, что именно вы проверяете, вас волнует, является ли s пустым или нет, равно ли оно пустой строке

Answer 2

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

Answer 3

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

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

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

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

Answer 4

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

"".equals(someString);

Null-safe:)

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

Answer 5

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

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

Answer 6

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

Но самое большое различие заключается в удобочитаемости - isEmpty() короче и легче понять. Кстати, я бы хотел, чтобы было isBlank() сокращение для .trim().isEmpty() ...

Answer 7

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

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

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

Answer 8

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

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

Answer 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 с нулевой безопасностью, создавая статический метод isEmpty .

Answer 10

isEmpty была введена только в 1.6. Отметьте С тегом в javadoc .

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

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