string автоматическое - Сравнение Java с==из двух строк является ложным?





определение топологии (11)


Используйте метод equals для сравнения объектов:

String[] test = {"231", "CA-California", "Sacramento-155328", "aleee",
                 "Customer Service Clerk", "Alegra Keith.doc.txt"};

System.out.println("231".equals(test[0]));

Сравнение '==' сравнивает ссылки, а не значения.

На этот вопрос уже есть ответ:

Строковые части - это строка [6]:

["231", "CA-California", "Sacramento-155328", "aleee", "Customer Service Clerk", "Alegra Keith.doc.txt"]

Но когда я сравниваю parts[0] с "231" :

"231" == parts[0]

приведенный выше результат ложный,

Я в замешательстве, так может кто-нибудь сказать мне, почему?




Оператор == сравнивает ссылки на объекты, а не значение String s.

Чтобы сравнить значения String s, используйте метод String.equals :

"231".equals(parts[0]);

Это справедливо для любого другого объекта в Java - при сравнении значений всегда используйте метод equals вместо использования оператора == .

Метод equals является частью Object и должен быть переопределен классами, которые будут сравниваться так или иначе.




Используйте метод equals: parts [0] .equals ("231"). == оператор сравнивает ссылки на объекты.




«==» сравнивает ссылки на объекты, в вашем случае «231» - это другой объект, чем части [0].

Вы хотите использовать String.equals .

parts[0].equals("231")



Ответ очень прост: когда вы сравниваете строки с помощью оператора ==, вы фактически сравниваете, если две разные переменные относятся к одному объекту String. И они этого не делают, строка в массиве и вновь созданная «231» - это разные объекты String с тем же содержимым.

Правильное дело - использовать следующее выражение: "231".equals(parts[0]) или "231".equalsIgnoreCase(parts[0]) . Это даст вам то, что вам нужно, и вернет true, если эти объекты String содержат одинаковые значения.




Вот хороший пример. Оператор '==' со строкой может быть очень сложным в Java.

class Foo {
    public static void main(String[] args) {
        String a = "hello";
        String b = "hello";
        String c = "h";
        c = c + "ello";

        String operator = null;

        if(a == b) {
            operator = " == ";
        } else {
            operator = " != ";
        }

        System.out.println(a + operator + b);

        if(a == c) {
            operator = " == ";
        } else {
            operator = " != ";
        }

        System.out.println(a + operator + c);

        if(a == "hello") {
            operator = " == ";
        } else {
            operator = " != ";
        }

        System.out.println(a + operator + "hello");

        if(c == "hello") {
            operator = " == ";
        } else {
            operator = " != ";
        }

        System.out.println(c + operator + "hello");
    }
}

Что будет производить следующий результат:

hello == hello
hello != hello
hello == hello
hello != hello



Следующее выводит «true»;

String s = "231";
if(s == "231")
{
    System.out.println("true");
}
else
{
    System.out.println("false");
}

Это связано с тем, что строки не изменяются, и java будет пытаться сохранить как можно больше места, поэтому он указывает на то же самое, что и в памяти.

Однако следующее выдает «false»:

String s = new String("231");
if(s == "231")
{
    System.out.println("true");
}
else
{
    System.out.println("false");
}

new заставит его сохранить строку в новой ячейке памяти.

Кстати, вы должны ВСЕГДА использовать .equals() для сравнения строк (для случаев, подобных этому)




Как многие другие уже объяснили, вы пытаетесь сравнить с оператором равенства, но тогда он будет полагаться на Object.equals () вместо String.equals ().

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

parts[0].equals("blahblah")

Я бы предпочел:

"blahblah".equals(parts[0])

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

Другой способ - использовать String.intern ():

if (parts[0].intern() == "blahblah") ...

Дополнительную информацию об этом см. В http://java.sun.com/j2se/1.4.2/docs/api/java/lang/String.html#intern() .




Если строки не интернированы, то == проверяет ссылочный идентификатор. Использование:

 "231".equals(parts[0]);

вместо.




== в Java сравнивает адрес объектов (в этом случае строки).

То, что вам нужно, это parts[0].equals("231")




В ES6 у нас есть что-то, что включает в себя, что делает именно то, что вы хотите: так вы можете просто так:

'str1'.includes('str2');

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

String.prototype.includes = String.prototype.includes || function(str) {
  return this.indexOf(str) > -1;
}




java string equals