Как сравнить два числа в java

13.2. Java – Метод compareTo()

Метод compareTo() – сравнивает числовой объект, который вызывает метод, с аргументом. При работе с числами метод compareTo() в Java позволяет сравнить два числа одного типа, например, byte, long, integer и т.д. Однако нельзя сравнивать два разных типа аргумента и числового объекта, вызывая метод они должны быть одного типа.

Синтаксис

public int compareTo( NumberSubClass referenceName )

Параметры

Подробная информация о параметрах:

referenceName – должно быть byte, double, integer, float, long или short.

Возвращаемое значение

Если Integer равно аргументу, то возвращается 0.
Если Integer меньше, чем аргумент, то возвращается -1.
Если Integer больше, чем аргумент, то возвращается 1.

Пример

public class Test < public static void main(String args[])< Integer x = 5; System.out.println(x.compareTo(3)); System.out.println(x.compareTo(5)); System.out.println(x.compareTo(8)); >>

Будет получен следующий результат:

1 0 -1

1. Java – Самоучитель для начинающих
2. Java – Обзор языка
3. Java – Установка и настройка
4. Java – Синтаксис
5. Java – Классы и объекты
6. Java – Конструкторы
7. Java – Типы данных и литералы
8. Java – Типы переменных
9. Java – Модификаторы
10. Java – Операторы
11. Java – Циклы и операторы цикла
11.1. Java – Цикл while
11.2. Java – Цикл for
11.3. Java – Улучшенный цикл for
11.4. Java – Цикл do..while
11.5. Java – Оператор break
11.6. Java – Оператор continue
12. Java – Операторы принятия решений
12.1. Java – Оператор if
12.2. Java – Оператор if..else
12.3. Java – Вложенный оператор if
12.4. Java – Оператор switch..case
12.5. Java – Условный оператор (? 🙂
13. Java – Числа
13.1. Java – Методы byteValue(), shortValue(), intValue(), longValue(), floatValue(), doubleValue()
13.2. Java – Метод compareTo()
13.3. Java – Метод equals()
13.4. Java – Метод valueOf()
13.5. Java – Метод toString()
13.6. Java – Метод parseInt()
13.7. Java – Метод Math.abs()
13.8. Java – Метод Math.ceil()
13.9. Java – Метод Math.floor()
13.10. Java – Метод Math.rint()
13.11. Java – Метод Math.round()
13.12. Java – Метод Math.min()
13.13. Java – Метод Math.max()
13.14. Java – Метод Math.exp()
13.15. Java – Метод Math.log()
13.16. Java – Метод Math.pow()
13.17. Java – Метод Math.sqrt()
13.18. Java – Метод Math.sin()
13.19. Java – Метод Math.cos()
13.20. Java – Метод Math.tan()
13.21. Java – Метод Math.asin()
13.22. Java – Метод Math.acos()
13.23. Java – Метод Math.atan()
13.24. Java – Метод Math.atan2()
13.25. Java – Метод Math.toDegrees()
13.26. Java – Метод Math.toRadians()
13.27. Java – Метод Math.random()
14. Java – Символы
14.1. Java – Метод Character.isLetter()
14.2. Java – Метод Character.isDigit()
14.3. Java – Метод Character.isWhitespace()
14.4. Java – Метод Character.isUpperCase()
14.5. Java – Метод Character.isLowerCase()
14.6. Java – Метод Character.toUpperCase()
14.7. Java – Метод Character.toLowerCase()
14.8. Java – Метод Character.toString()
15. Java – Строки
15.1. Java – Метод charAt()
15.2. Java – Метод compareTo()
15.3. Java – Метод compareToIgnoreCase()
15.4. Java – Метод concat()
15.5. Java – Метод contentEquals()
15.6. Java – Метод copyValueOf()
15.7. Java – Метод endsWith()
15.8. Java – Метод equals()
15.9. Java – Метод equalsIgnoreCase()
15.10. Java – Метод getBytes()
15.11. Java – Метод getChars()
15.12. Java – Метод hashCode()
15.13. Java – Метод indexOf()
15.14. Java – Метод intern()
15.15. Java – Метод lastIndexOf()
15.16. Java – Метод length()
15.17. Java – Метод matches()
15.18. Java – Метод regionMatches()
15.19. Java – Метод replace()
15.20. Java – Метод replaceAll()
15.21. Java – Метод replaceFirst()
15.22. Java – Метод split()
15.23. Java – Метод startsWith()
15.24. Java – Метод subSequence()
15.25. Java – Метод substring()
15.26. Java – Метод toCharArray()
15.27. Java – Метод toLowerCase()
15.28. Java – Метод toString()
15.29. Java – Метод toUpperCase()
15.30. Java – Метод trim()
15.31. Java – Метод valueOf()
15.32. Java – Классы StringBuilder и StringBuffer
15.32.1. Java – Метод append()
15.32.2. Java – Метод reverse()
15.32.3. Java – Метод delete()
15.32.4. Java – Метод insert()
15.32.5. Java – Метод replace()
16. Java – Массивы
17. Java – Дата и время
18. Java – Регулярные выражения
19. Java – Методы
20. Java – Потоки ввода/вывода, файлы и каталоги
20.1. Java – Класс ByteArrayInputStream
20.2. Java – Класс DataInputStream
20.3. Java – Класс ByteArrayOutputStream
20.4. Java – Класс DataOutputStream
20.5. Java – Класс File
20.6. Java – Класс FileReader
20.7. Java – Класс FileWriter
21. Java – Исключения
21.1. Java – Встроенные исключения
22. Java – Вложенные и внутренние классы
23. Java – Наследование
24. Java – Переопределение
25. Java – Полиморфизм
26. Java – Абстракция
27. Java – Инкапсуляция
28. Java – Интерфейсы
29. Java – Пакеты
30. Java – Структуры данных
30.1. Java – Интерфейс Enumeration
30.2. Java – Класс BitSet
30.3. Java – Класс Vector
30.4. Java – Класс Stack
30.5. Java – Класс Dictionary
30.6. Java – Класс Hashtable
30.7. Java – Класс Properties
31. Java – Коллекции
31.1. Java – Интерфейс Collection
31.2. Java – Интерфейс List
31.3. Java – Интерфейс Set
31.4. Java – Интерфейс SortedSet
31.5. Java – Интерфейс Map
31.6. Java – Интерфейс Map.Entry
31.7. Java – Интерфейс SortedMap
31.8. Java – Класс LinkedList
31.9. Java – Класс ArrayList
31.10. Java – Класс HashSet
31.11. Java – Класс LinkedHashSet
31.12. Java – Класс TreeSet
31.13. Java – Класс HashMap
31.14. Java – Класс TreeMap
31.15. Java – Класс WeakHashMap
31.16. Java – Класс LinkedHashMap
31.17. Java – Класс IdentityHashMap
31.18. Java – Алгоритмы Collection
31.19. Java – Iterator и ListIterator
31.20. Java – Comparator
32. Java – Дженерики
33. Java – Сериализация
34. Java – Сеть
34.1. Java – Обработка URL
35. Java – Отправка Email
36. Java – Многопоточность
36.1. Java – Синхронизация потоков
36.2. Java – Межпоточная связь
36.3. Java – Взаимная блокировка потоков
36.4. Java – Управление потоками
37. Java – Основы работы с апплетами
38. Java – Javadoc

Как сравнить два числа типа string?

Как сравнить переменную типа String с переменной типа Int?
Как сравнить переменную типа String с переменной типа Int в конструкции "if".

Как сравнить два элемента массива типа string?
Задание. Вычислить какая компания чаще всего участвовала в роли истца. У меня есть массив в.

Как сравнить два char string
подскажите сделал задачу которая проверит является ли данная строка палиндромом вот код.

Как сравнить две строки типа string?
C типом char все просто. Поиск по Фамилии и имени. char name,name1,address, dom; int h=0; .

Сравнение объектов в Java

Сравнение объектов является важной функцией объектно-ориентированных языков программирования. В этом руководстве мы рассмотрим некоторые функции языка Java, которые позволяют нам сравнивать объекты. Также мы обратим внимание на подобные функции во внешних библиотеках.

Операторы == и !=

Давайте начем с операторов == и != , которые могут сказать, одинаковы ли Java-объекты или нет соответственно.

Примитивы

Для примитивных типов быть одинаковым означает иметь одинаковые значения:

assertThat(1 == 1).isTrue();

Благодаря автоматической распаковке это также работает при сравнении примитивного значения с его классом-оберткой:

Integer a = new Integer(1); assertThat(1 == a).isTrue();

Если две целочисленные переменные имеют разные значения, оператор == вернет false , а оператор != вернет true .

Объекты

Предположим, мы хотим сравнить два экземпляра классов-оберток Integer с одинаковыми значениями:

Integer a = new Integer(1); Integer b = new Integer(1); assertThat(a == b).isFalse();

При сравнении двух объектов их значения не равняются 1. Скорее различаются их адреса памяти в стеке, поскольку оба объекта создаются с использованием оператора new . Если мы присвоим переменной а переменную b , то получим другой результат:

Integer a = new Integer(1); Integer b = a; assertThat(a == b).isTrue();

Теперь давайте посмотрим, что происходит, когда мы используем фабричный метод Integer#valueOf :

Integer a = Integer.valueOf(1); Integer b = Integer.valueOf(1); assertThat(a == b).isTrue();

В этом случае они считаются одинаковыми. Это связано с тем, что метод valueOf() держит Integer в кеше, чтобы избежать создания слишком большого количества оберток с одинаковыми значениями. Поэтому метод возвращает один и тот же экземпляр Integer для обоих вызовов.

Java также делает это для переменных типа String:

assertThat("Hello!" == "Hello!").isTrue();

Однако, если они созданы с помощью оператора new , они не будут одинаковыми.

Наконец, две нулевые ссылки считаются одинаковыми, в то время как любой не-null объект считается отличным от null:

assertThat(null == null).isTrue(); assertThat("Hello!" == null).isFalse();

Конечно, поведение операторов равенства может быть ограничивающим. Что если мы хотим сравнить два объекта, расположенных по разным адресам и при этом полагать, что они равны на основании их внутренних состояний? Как это сделать, мы увидим в следующих пунктах.

Метод Object#equals

Теперь давайте поговорим о более широком концепте равенства с методом equals() .

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

Во-первых, давайте посмотрим, как он ведет себя для существующих объектов, таких как Integer:

Integer a = new Integer(1); Integer b = new Integer(1); assertThat(a.equals(b)).isTrue();

Наш метод по-прежнему возвращает true, когда оба объекта одинаковы.

Отметим здесь, что мы можем передать объект null в качестве аргумента метода, но не в качестве объекта, для которого мы вызываем метод.

Мы также можем использовать метод equals() с любым пользовательским объектом. Допустим, у нас есть класс Person:

public class Person < private String firstName; private String lastName; public Person(String firstName, String lastName) < this.firstName = firstName; this.lastName = lastName; >>

Мы можем переопределить метод equals() для этого класса, чтобы мы могли сравнить два объекта Persons на основе их внутренних данных:

@Override public boolean equals(Object o)

Чтобы узнать больше по этой теме, читайте вот эту статью.

Статический метод Objects#equals

Давайте посмотрим на статический метод Objects#equals . Ранее мы упоминали, что нельзя использовать null в качестве значения первого объекта, иначе будет выброшено исключение NullPointerException .

Метод equals() вспомогательного класса Objects решает эту проблему. Он принимает два аргумента и сравнивает их, а также обрабатывает значения null.

Давайте снова сравним объекты Person :

Person joe = new Person("Joe", "Portman"); Person joeAgain = new Person("Joe", "Portman"); Person natalie = new Person("Natalie", "Portman"); assertThat(Objects.equals(joe, joeAgain)).isTrue(); assertThat(Objects.equals(joe, natalie)).isFalse();

Как мы объяснили, этот метод обрабатывает значения null. Следовательно, если оба аргумента равны null, он вернет значение true, а если только один из них равен null, он вернет значение false.

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

public Person(String firstName, String lastName, LocalDate birthDate)

Затем нужно обновить метод equals() , но с обработкой null значений. Мы можем сделать это, добавив условие в метод equals() :

birthDate == null ? that.birthDate == null : birthDate.equals(that.birthDate);

Однако же, если мы добавим слишком много полей с возможными null значениями в класс, он может стать запутанным. Использование метода Objects#equals в реализации equals() намного чище, что улучшает читаемость кода.

Objects.equals(birthDate, that.birthDate);

Интерфейс Comparable

Логику сравнения также можно использовать для размещения объектов в определенном порядке. Интерфейс Comparable позволяет нам определять порядок между объектами, выявляя, является ли объект больше, меньше или равным другому.

Интерфейс Comparable является дженериком и имеет только один метод, compareTo() , который принимает аргумент дженерик-типа и возвращает int. Возвращаемое значение отрицательное, если this меньше аргумента, 0, в случае если они равны, и положительное в обратном случае.

Допустим, в классе Person мы хотим сравнить объекты Person по их фамилии:

public class Person implements Comparable  < //. @Override public int compareTo(Person o) < return this.lastName.compareTo(o.lastName); >>

Метод compareTo() вернет отрицательный int, если оно вызвано с именем Person , имеющим большую фамилию, чем this, ноль, если ту же фамилию, и положительное значение в обратном случае.

Чтобы узнать подробнее, прочитайте статью на эту тему.

Интерфейс Comparator

Интерфейс Comparator является дженериком и содержит метод compare , который принимает два аргумента этого типа и возвращает integer. Мы ранее уже видели этот шаблон с интерфейсом Comparable.

Comparator аналогичен ему; однако он отделен от определения класс. Следовательно, мы можем определить столько Comparator , сколько захотим для одного класса, где мы можем предоставить только одну реализацию Comparable .

Представим, что у нас есть веб-страница, содержащая список людей в виде таблицы, и мы хотим предложить пользователю возможность сортировать их по именам, а не по фамилиям. Это невозможно с Comparable , если мы также хотим сохранить нашу текущую реализацию, но мы можем реализовать наши собственные Comparators .

Давайте создадим Person Comparator , который будет сравнивать их только по именам:

Comparator compareByFirstNames = Comparator.comparing(Person::getFirstName);

Теперь отсортируем список людей, используя Comparator :

Person joe = new Person("Joe", "Portman"); Person allan = new Person("Allan", "Dale"); List people = new ArrayList<>(); people.add(joe); people.add(allan); people.sort(compareByFirstNames); assertThat(people).containsExactly(allan, joe);

В интерфейсе Comparator есть и другие методы, которые мы можем использовать в реализации compareTo() :

@Override public int compareTo(Person o)

В этом примере мы сначала сравниваем фамилии, а затем имена. Затем мы сравниваем даты рождения, но, поскольку они нулевые, нужно рассказать, что с этим делать. Для этого мы задаем второй аргумент, чтобы сказать, что их нужно сравнить в соответствии с их естественным порядком, причем значения null идут последними.

Apache Commons

Давайте взглянем на библиотеку Apache Commons. Прежде всего, импортируем зависимость Maven.

 org.apache.commons commons-lang3 3.12.0

Метод ObjectUtils#notEqual

Для начала поговорим о методе ObjectUtils#notEqual . Потребуется два аргумента Object , чтобы определить, не равны ли они, в соответствии с их собственной реализацией метода equals() . Он также обрабатывает значения null.

Используем наши примеры со String повторно:

String a = new String("Hello!"); String b = new String("Hello World!"); assertThat(ObjectUtils.notEqual(a, b)).isTrue();

Следует отметить, что у ObjectUtils есть метод equals() , что однако является устаревшим с момента возникновения Java 7, когда появились Objects#equals .

Метод ObjectUtils#compare

Теперь давайте сравним порядок объектов с помощью метода ObjectUtils#compare . Это дженерик-метод, который принимает два аргумента Comparable дженерик типа и возвращает Integer.

Приведем пример, снова используя Strings:

String first = new String("Hello!"); String second = new String("How are you?"); assertThat(ObjectUtils.compare(first, second)).isNegative();

По умолчанию этот метод обрабатывает значения null, считая их бОльшими. Он также предлагает перегруженную версию с аргументом boolean, которая предлагает изменить это поведение и считать их мЕньшими, принимая аргумент boolean.

Guava

Давайте взглянем на Guava. Прежде всего импортируем зависимость:

 com.google.guava guava 31.0.1-jre

Метод Objects#equal

Как и библиотека Apache Commons, Google предоставляет нам метод определения равенства двух объектов, Objects#equal . Хотя у них разные реализации, возвращают они одинаковые результаты:

String a = new String("Hello!"); String b = new String("Hello!"); assertThat(Objects.equal(a, b)).isTrue();

Хотя он не помечен как устаревший, в JavaDoc говорится, что этот метод следует считать устаревшим, поскольку Java 7 предоставляет метод Objects#equals .

Методы сравнения

Библиотека Guava не предлагает метода для сравнения двух объектов (в следующем разделе мы увидим, что мы можем для этого сделать), но она предоставляет нам методы для сравнения примитивных значений. Давайте возьмем вспомогательный класс Ints и посмотрим, как работает его метод compare() :

assertThat(Ints.compare(1, 2)).isNegative();

Как обычно, он возвращает integer, который может быть отрицательным, нулевым или положительным, если первый аргумент меньше, равен или больше второго соответственно. Подобные методы существуют для всех примитивных типов, за исключением bytes.

Класс ComparisonChain

Наконец, библиотека Guava предлагает класс ComparisonChain , который позволяет нам сравнивать два объекта по цепочке сравнений. Мы можем легко сравнить два объекта Person по имени и фамилии:

Person natalie = new Person("Natalie", "Portman"); Person joe = new Person("Joe", "Portman"); int comparisonResult = ComparisonChain.start() .compare(natalie.getLastName(), joe.getLastName()) .compare(natalie.getFirstName(), joe.getFirstName()) .result(); assertThat(comparisonResult).isPositive();

Базовое сравнение достигается с помощью метода compareTo() , поэтому аргументы, передаваемые методам compare() , должны быть либо примитивными, либо Comparable.

Заключение

В этой статье мы узнали о разных способах сравнения объектов в Java. Мы изучили разницу между тождественностью, равенством и порядком. Мы также рассмотрели соответствующие функции в библиотеках Apache Commons и Guava.

Полный код из статьи можно найти на GitHub.

Приглашаем всех желающих на открытое занятие «Языки статической и динамической типизации». На этом вебинаре поговорим о стилях программирования и необходимости каждого из них. Разберём основные принципы объектно-ориентированного стиля (Инкапсуляция, Наследование, Полиморфизм). Рассмотрим возможности функционального стиля, которые предоставляет язык Java. Регистрация на вебинар.

Блог компании OTUS
Программирование
Java

Как сравнить два вещественных числа без if?

Собственно, надо сравнить два числа, не используя условных операторов и операций сравнения. Язык — Java.
Для целых чисел проблем никаких нет, все делается в одну строку. Проблемы начинаются, если числа вещественные. Вообще, мой алгоритм такой: отнять одно число от другого и посмотреть на знак получившегося выражения. Но это не сработает для double, так как знак можно получить операциями сдвига, которые определены только для целых чисел. привести к целому тоже нельзя, потому что если разница чисел меньше единицы, то алгоритм отработает не верно. Придумал такой трюк:

public class Compare < public static int cmp(double a, double b) < double r = a - b, d = 0; int i = 19; while (i != 0 && d == 0) < r *= 10; d = (int)r % 10; i--; >return ((int)d >> 63) + 1; > >

Осталось избавиться от цикла и двух сравнений. Цикл я думал заменить на рекурсию. А что сделать со сравнением даже не знаю. Привести к типу boolean язык не позволяет, что меня очень огорчает.
Что можете посоветовать? Может есть более простые способы?
P.S. Метод должен работать одновременно для целых и вещественных чисел.
P.P.S.
Вдруг кому пригодится, вот решение:

public class Compare < public static int cmp(double a, double b) < return (int)((Double.doubleToRawLongBits(a - b)) >> 63) + 1; > >

Вопрос задан более трёх лет назад
5110 просмотров

4 комментария

Оценить 4 комментария