Сравнительные проблемы в Java являются очень простыми и простыми в запутанных. Сегодня я суммирую и организую более подробное резюме и договоренность нескольких склонных к ошибкам, надеясь, что это будет полезно для исследования и собеседования каждого.
1. Разница между == и равным ()
Прежде всего, нам нужно знать разницу между == и равным (). Знак == всегда сравнивается со значением адреса. Для базовых типов данных == сравнение фактически является ли значения переменной равными, в то время как для эталонных типов данных сравнивается значение адреса. На что вам нужно обратить особое внимание, так это тип строки, который легко воспринимать как должное == и легко допустить ошибки. Метод equals () - это метод в классе объекта. Мы знаем, что все классы в Java будут наследовать класс объектов по умолчанию, поэтому объекты класса будут иметь метод equals (). Метод equals () в классе объекта показан на рисунке ниже:
Как видно из исходного кода, базовый уровень метода equals () в классе объекта также использует ==, так что это фактически значение адреса. Поэтому, если мы хотим использовать метод Equals () для других сравнений, нам необходимо переопределить метод equals ().
2. Основные типы данных и типы упаковки
Мы все знаем, что байт, короткие, Int, Long, Boolean, Char, Double и Float являются основными типами данных, а также заявляющие переменные хранятся в памяти стека. Переменные, определенные их соответствующими типами упаковки (байт, короткие, целочисленные, длинные, логические, символы, двойные), существуют в памяти кучи. Для основных типов данных их сравнение относительно простое, то есть использовать ==, чтобы определить, равны ли они, и используют <,>, <=,> = = для сравнения размеров. Но для типов упаковки это немного отличается.
Во -первых, для определения того, является ли это равным, см. Результат выполнения следующего кода:
Пакет DailyTest; импорт org.junit.test;/*** Сравнительное резюме в java* @author yrr*/public class javacomparetest {/*** Суд типа целочисленного типа*/@test public void test01 () {int n3 = 48; System.out.println("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- n8); System.out.println ("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------. System.out.println (n1.intvalue () == n2.intvalue ()); N6); Nullpointexception}/*** Суждение длинного типа равно*/@test public void test02 () {// здесь обратите внимание, что при использовании длинного определения L или L не требуется, но при использовании длинной, в противном случае будет сообщена ошибка // добавить ее в конструкцию, чтобы указать на разницу длинный n3 = 48L; System.out.println ("--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- n1); System.out.println("--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- System.out.println (n4 == n5); // При использовании метода long.intvalue () вам необходимо обратить внимание, чтобы убедиться, что он является нулевым, чтобы предотвратить NullPointexception}}}}}}}}Для приведенных выше результатов выполнения сделано следующее объяснение:
Во -первых, для нового метода мы объявляем целое число или длинный объект. Поскольку новый объект открывает кусок пространства в куче, даже если значения двух одинаковы, для == значение адреса сравнивается, поэтому False будет возвращен. Для классов обертки базовых типов данных метод equals () был переписан, и численный размер будет сравниваться, поэтому метод equals () может использоваться для суждения на основе численного размера. Что касается проблемы сравнения целочисленных переменных с переменными int, мы обнаружим, что значение сравнения также основано на численном размере. Это связано с тем, что при сравнении целочисленный тип автоматически раскатывается и преобразуется в тип Int. Объяснение первых трех точек применимо ко всем типам упаковки. Для метода прямого назначения две целочисленные переменные со значением 48 считаются истинными по знаку ==, но когда значение составляет 128, оно является ложным. Это связано с тем, что внизу, для целого числа n1 = 48;, метод прямого назначения фактически вызывает метод integer.value (). Мы можем кратко взглянуть на исходный код метода integer.value (), как показано на рисунке ниже:
Мы видим, что здесь есть суждение. Когда вход I находится в диапазоне [-128, 127], он возвращается непосредственно из массива IntegerCache. Следовательно, для значений в этом диапазоне, значения адреса, соответствующие этому массиву, возвращаются, поэтому использование знака == для судьи истина будет возвращено. То, что не находится в этом диапазоне, является новым объектом, поэтому false будет возвращен. Этот вывод верен для байта, коротких, целочисленных и длинных типов (если вы заинтересованы, вы можете проверить исходный код их соответствующего метода значения ()), потому что область типа байта [-128, 127], поэтому для типа байта с использованием == не отличается от равных ().
Для сравнения размеров нет проблем с использованием>, <, <=,> =, и они будут автоматически не распакованы. Но мы обычно рекомендуем использовать следующие два способа сравнения размеров:
Вызовите метод xxxvalue (), чтобы преобразовать его в основной тип данных для сравнения. В классе обертки метод сравнения () переписан. Глядя на исходный код сравнения (), вы можете увидеть, что на самом деле основное использование также преобразуется в соответствующий основной тип данных с помощью автоматического распаковки, а затем сравнивая его.
2. Сравнение объектов Java
С приведенным выше введением легче сравнивать объекты. Принципы такие же.
1. Сравнение типов строк
Следует отметить, что тип строки не может быть использован напрямую>, <=,> = и <, и будет сообщать об исключении компиляции.
Пакет DailyTest; импорт org.junit.test;/*** Сравнительное резюме в Java* @author yrr*/public class javacomparetest {@test public void test03 () {string s1 = new String ("123"); String S2 = New String ("123"); System.out.println (S1 == S2); // false System.out.println (s1.equals (s2)); Строка S3 = "234"; Строка S4 = "234"; System.out.println (S3 == S4); // true System.out.println (s3.equals (s4)); // true //system.out.println(s1 <= s3); // Оператор <не определен для типа аргумента (ы) java.lang.string, java.lang.string System.out.println (s1.compareto (s3) <0); //истинный }}2. Сравнение объектов класса
Заключение объектов класса одинаково, но по сравнению с основными типами данных и типами строк он немного сложнее.
В соответствии с определенным правилом, чтобы определить, являются ли два объекта равными, метод equals () должен быть переписывается в судящем классе. Пример кода заключается в следующем:
Пакет DailyTest; импорт org.junit.test;/*** Сравнительное резюме в Java* @author yrr*/public class javacomparetest {@test public void test04 () {Person P1 = новый человек («yrr», 18); Человек P2 = новый человек («YRR», 18); System.out.println (P1 == P2); // false System.out.println (p2.equals (p1)); // true}} класс Person {private String name; частный целый возраст; public Person () {} public Perform (String name, Integer Age) {this.name = name; this.age = возраст; } public String getName () {return name; } public integer getage () {return Age; } @Override public boolean equals (Object obj) {Person Person = (Person) obj; return name.equals (person.getName ()) && age.equals (person.getage ()); }}И если вы хотите сравнить размеры двух объектов (это также общий вопрос собеседования), есть два способа:
Сопоставимый класс реализует сопоставимый интерфейс и переопределяет метод сравнения () для определения класса, который реализует интерфейс компаратора, или использует внутренний класс для переопределения метода Compare (): первый определяется на сопоставимом классе, в то время как последний определяется вне сопоставимого класса. Благодаря этой разнице преимущества и недостатки двух также очевидны. Первый прост, но требует модификации сравниваемого класса, в то время как второй не нуждается в изменении исходного кода, который является более гибким.
Первый метод, образец кода заключается в следующем:
Пакет DailyTest; импорт org.junit.test;/*** Сравнительное резюме в java* @author yrr*/public class javacomparetest {@test public void test5 () {person p1 = новое лицо («yrr», 18); Человек P2 = новый человек («WX», 19); System.out.println (p1.compareto (P2) <0); }} класс Человек реализует сопоставимо <person> {private String name; частный целый возраст; public Person () {} public Perform (String name, Integer Age) {this.name = name; this.age = возраст; } public integer getage () {return Age; } @Override public int compareto (человек o) {return this.getage () - o.getage (); }}Второй метод, пример кода следующего:
пакет компаратор; импорт java.util.arrays; import java.util.comparator; открытый класс mycomparator {public static void main (string [] args) {user [] users = новый пользователь [] {новый пользователь («U1001», 25), новый пользователь («U1002», 20), новый пользователь («U1003», 21)}; Arrays.sort (пользователи, новый компаратор <user> () {@override public int compare (пользователь o1, user o2) {return o1.getage () - o2.getage ();}}); for (int i = 0; i <users.length; i ++) {user user = users [i]; System.out.println (user.getid () + "" + user.getage ()); }}} класс пользователь {private String Id; частный int возраст; public User (String Id, int Age) {this.id = id; this.age = возраст; } public int getage () {return Age; } public void setage (int age) {this.age = age; } public String getId () {return id; } public void setId (String id) {this.id = id; }}Выше приведено соответствующее содержание вопросов сравнения Java, которые я вам рассказал на этот раз. Если у вас есть другие вопросы, вы можете обсудить их в области комментариев ниже. Спасибо за вашу поддержку.