Home / Questions / 225
Accepted
Jordi Castilla
Asked: 2020-12-03 04:35:37 +0800 CST 2020-12-03 04:35:37 +0800 CST

Как правильно сравнивать строки (и объекты) в Java?

  • 772

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

final String miNombre = "Jordi";
Scanner input = new Scanner(System.in);
System.out.println("Adivina mi nombre: ");

while (true) {
    String intento = input.next();
    if(intento == miNombre) {
        System.out.println("Acertaste!");
        break;
    } else {
        System.out.println("Intentalo de nuevo!");
    }
}

ВЫХОД:

Adivina mi nombre: 
manuel
Intentalo de nuevo!
jordi
Intentalo de nuevo!
Jordi
Intentalo de nuevo!
java

12 Answers

  1. Best Answer

    Если Javaтолько примитивные типы (описанные в JLS (§4.2) , например intили char) сравниваются с ==, Strings (и другие объекты) в Javaсравниваются друг с другом с помощью метода equals.

    String#equals(Object)

    Сравнивает это Stringс указанным объектом. Результат будет trueтогда и только тогда, когда аргумент не является nullи является объектом типа String, который представляет ту же последовательность символов, что и этот объект.

    • JLS (§15.21.3) Хотя его можно использовать ==для сравнения ссылок на типы String, проверка на равенство определяет, ссылаются ли два операнда на один и тот же объектString . В результате falseоперанды являются разными объектами String, даже если они содержат одинаковую последовательность символов.

    Таким образом, ваше сравнение должно быть:

    if(miNombre.equals(intento)) {

    ВЫХОД:

    Adivina mi nombre: 
manuel
Intentalo de nuevo!
Jordi
Acertaste!

    ПОЯСНЕНИЯ:

    • Я поместил переменную miNombreв начало сравнения, чтобы избежать NullPointerExceptionif intento == null (да, сравнения с nullтакже выполняются с помощью ==).

      В качестве дополнения: если это nullдействительное значение в представлении (и поэтому мы хотим избежать одного NPE), оно Objects.equalsдоступно из Java 7и заботится о возврате true, если оба значения истинны nullили falseесли только одно истинно.

    • В этом случае вы можете использовать метод String#equalsIgnoreCase(Object), который будет игнорировать MAYUSCULASили MINUSCULASпри выполнении сравнения:

      if(miNombre.equalsIgnoreCase(intento)) {

    • JLS (§15.21) Операторы равенства ( ==и !=) можно использовать для сравнения двух операндов, которые могут быть преобразованы (§5.1.8) числового типа, или двух операндов типа booleanили , Booleanили двух операндов, которые >имеют тип ссылки, или тип null. Все остальные случаи вызывают ошибку времени компиляции.

    • 116

  2. Начиная с Java 7 можно сравнивать равенство двух строк , используя метод equalsкласса java.util.Objects. То есть:

    String a = ...
String b = ...

if (Objects.equals(a, b)) {
    // iguales
} else {
    // diferentes
}

    Так как они могут a.equals(b)либо b.equals(a)колдовать java.lang.NullPointerExceptionесли он aили nullон bсоответственно null, при использовании этого пути, aлибо bони могут быть nullбез всякого риска.

    Если вы используете Java 6 (или более раннюю версию), код этого класса можно переписать ifследующим образом:

    if (a == b || (a != null && a.equals(b))) {
    // iguales
} else {
    // diferentes
}
    • 34

    • Оператор "==" сравнивает две ссылки, то есть возвращает true , если оба объекта занимают одну и ту же ячейку памяти.

    • Метод «равно» сравнивает значения объектов.

    • 27

  4. В языке Java, который используется equals()для сравнения strings, оператор НИКОГДА не должен использоваться== .

    String nombre = "elenasys";

if (nombre.equals("elenasys")) { //Correcto para comparar strings!
    ...
}

if (nombre == "elenasys") {   //Incorrecto para comparar strings!
    ...
}

    Это распространенная ошибка начинающих разработчиков.

    • 18

  5. Чтобы дополнить другие ответы, я скажу вам, что нет правила для сравнения равенства строки, и метод, .equals()и оператор == полностью действительны, разница зависит от того, что вы хотите сравнить или каково ваше намерение, когда вы хотите сравнить два объекта String(по ссылке или по значению).

    Строки — это такие же объекты, как и любые другие, но есть большие и тонкие отличия, которые отделяют их от остальных объектов. Прежде всего, вы можете инициализировать строку двумя этими способами.

    String usandoLiteral = "Mi literal"; // Por medio de un literal
String usandoNew = new String("Con operador new"); // Utilizando el operador clasico new

    В обоих случаях создается объект, отсутствие оператора newв первом примере — это просто ярлык (так выглядит более естественно).

    Теперь вы должны понять, как Java управляет строками, в Java есть пул строк, это пространство памяти, зарезервированное для хранения строк, приложение обычно интенсивно использует строки, и только они могут занимать до 40% памяти во время выполнения. и многие из этих строк повторяются, например, «a», «en», «la» и т. д. Чтобы оптимизировать это, Java собирает все эти строки как литералы в местоположении JVM и повторно использует повторяющиеся литералы для оптимизации использования памяти, поэтому, если вы сохраните литерал «carlos» в двух переменных, Java будет повторно использовать этот литерал.

    По этой причине, если вы объявите следующие переменные Stringи инициализируете их одним и тем же литералом. (помните, что вы создаете два объекта)

    String nombre = "carlos";
String nombre2 = "carlos";

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

    Boolean sonIguales = nombre == nombre2; // sonIguales tiene el valor true

    Пул строк перерабатывает и хранит только литералы, это означает, что если вы создадите строку следующим образом

    String nombre3 = new String("carlos");

    Поскольку он не инициализируется литералом Java, он не будет храниться в пуле строк и не будет перерабатываться, поэтому он будет удален сборщиком мусора, если это так, то следующее сравнение приведет к ложному результату.

    Boolean esIgualAlTercero = nombre == nombre3; // esIgualAlTercero tiene el valor false.

    Вот почему, когда вы выполняете сравнение с оператором ==, он иногда возвращает true, а иногда false, даже если вы сравниваете одно и то же значение в строке.

    Метод .equals используется, когда вы хотите сравнить строку по значению или символ за символом, это безопасный способ сделать сравнение строк, поскольку помните, что, как и в первом примере, мы технически делали сравнение по значению с оператором == из-за особенности пула строк.

    Дополнительное примечание, если вам интересно, если при инициализации строки литералом значение сохраняется в пуле строк, что происходит, когда я изменяю строку?

    Ну, это еще один момент, строки в Java неизменяемы, это означает, что вы не можете изменить их значение, например, добавить больше символов в значение String, а Java не предоставляет никакого API для прямого изменения строки. (однако Java предоставляет API, чтобы сделать это косвенно)

    Например, если я хочу добавить фамилию в свою переменную (имя), я могу повторно назначить новую строку переменной (имени), которую я создам путем объединения исходного значения с фамилией в Сюда.

    nombre = nombre + " lucero";

    Это создает новое значение "carlos lucero" и присваивает это значение строке имени.

    Что произойдет, если теперь я сравню «имя» с новой переменной, которая содержит то же значение, что и «имя», но назначена как литерал?

    String nombreCompleto = "carlos lucero";
Boolean esNombreCompletoIgual = nombreCompleto == nombre; // recuerda que nombre ahora tiene el valor "carlos lucero"

    Ну, так как переменной (имя) было переназначено новое значение, которое не было создано с помощью литерала , теперь переменной (имя) больше нет в пуле строк, поэтому ее ссылка не перерабатывается и сравнение с переменная (FullName), которая, если она была создана с помощью литерала, в результате даст False.

    Наконец, Java предоставляет API для решения проблемы неизменности строк, этот API предоставляется классом StringBuilder.

    • 16

  6. Как уже было сказано, оператор == подтверждает в случае примитивов, что значения идентичны, в случае объектов ссылка указывает на один и тот же объект.

    Осталось немного объяснить метод equals() . Все классы в Java являются подклассами Object , объект поставляется с объявлением equals() по умолчанию .

    Если я объявлю новый класс, другие пользователи моего класса ожидают, что я реализую метод equals(Object o) , который подразумевает, что два объекта считаются равными. Это не обязательно означает, что они есть, и могут потребовать комментариев в документации. Пример:

    public class Point(){
    private int x;
    private int y;

    public Point(intx, int y){
        this.x=x;
        this.y=y;
    }

    public int getX() {return x;}

    public int getY() {return x;}

    @Override
    public boolean equals(Object o){
        return o instanceof Point && ((Point)o).getX()==x && ((Point)o).getY()==y;
    }
}

    Если я объявлю подкласс Point с меткой вроде:

    public class NamedPoint extends Point{

    private String etiqueta;

    public NamedPoint(int x, int y, String etiqueta){
        super(x,y);
        this.etiqueta=etiqueta;
    }

    public String getEtiqueta(){ return etiqueta }
}

    Я должен отметить, что две NamedPoints считаются равными, если координаты совпадают, независимо от метки.

    Осторожно, простое переопределение метода не гарантирует согласованности моей логики. Если я переопределю equals в NamedPoint , чтобы также учитывать метки, у меня останется следующая проблема:

    Point point = new Point(3,6);
Point otroPoint = new NamedPoint(3,6,"Foo");
boolean equals1 = point.equals(otroPoint); // resultado true
boolean equals2 = otroPoint.equals(point); // resultado false

    Чтобы избежать этой двусмысленности, вы можете сравнить классы вместо использования instanceof:

        @Override
    public boolean equals(Object o){
        return this.getClass().equals(o.getClass()) 
            && ((Point)o).getX()==x && ((Point)o).getY()==y;
    }

    Описание: В вопросе равенства есть драконы.

    • 11

  7. Оператор == обычно работает, когда переменная уже инициализирована, так как он сравнивает внутренние представления, но самый правильный метод — это сравнение с использованием метода equals, который унаследован от класса Object.

    Сравнение их с использованием равных почти всегда является лучшим решением.

    String cadena1="Hola";
String cadena2="Hola";
System.out.println(cadena1.equals(cadena2)); //funciona

String cadena1;
String cadena2="Hola";
System.out.println(cadena1.equals(cadena2)); //funciona

    Но, несмотря на это, у вас могут возникнуть проблемы, если ваша виртуальная машина меньше, чем Tiger, потому что в неудачных реализациях строка, определенная как null, не совпадала с пустой строкой.

    String cadena1="";
String cadena2=null;
String cadena3;
System.out.println(cadena1.equals(cadena2).equals(cadena3));

    Поэтому для этих случаев вы можете использовать сравнение с помощью оператора==

    String cadena1="Hola";
String cadena2="Hola";
System.out.println(cadena1 == cadena2); //funciona porque ya están inicializadas

    Или имея большой резерв, сравнивая внутренние представления.

    String cadena1="Hola";
String cadena2="Hola";
System.out.println(cadena1.intern() == cadena2.intern()); //son iguales solamente si cadena1.equals(cadena2)
    • 9

  8. "==" используется для Integer , Char, Object или null, среди прочего, лучше использовать equals или equalsIgnoreCase:

     final String miNombre = "Jordi";
Scanner input = new Scanner(System.in);
System.out.println("Adivina mi nombre: ");

while (true) {
    String intento = input.next();
    if(intento.equalsIgnoreCase(miNombre)) { //Tu puedes usar equals para que sea igual y equalsIgnoreCase para que se igual ignorando las mayúsculas && minúsculas, es decir que por mas que escribas JoRdI va a ser "true".
        System.out.println("Acertaste!");
        break;
    } else {
        System.out.println("Intentalo de nuevo!");
    }
}
    • 9

  9. Только для примитивных типов сравнение == вообще допустимо. Для объектов следует использовать методы сравнения, так как equals()это может быть справедливо для Strings. Для других типов объектов этот тип сравнения может оказаться недопустимым.

    При == сравниваются ссылки, а не содержимое объектов в памяти.

    • 8

  10. Правильный способ сравнить 2 строки — использовать функцию equals() , которая предназначена для сравнения 2 строк и equalsIngnoreCase() , которая является той же самой, но игнорирует регистр.

    Тест:

    if(intento.equalsIgnoreCase(miNombre)){
     System.out.println("Has Acertado");
}
else{
     System.out.println("Incorrecto");
}
    • 8