Как сравнить 3 числа в java
Перейти к содержимому

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

  • автор:

13.3. Java – Метод equals()

Метод equals() – определяет в Java равен ли числовой объект, который вызывает метод, объекту, который передается в качестве аргумента.

Синтаксис

public boolean equals(Object o)

Параметры

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

  • o – любой объект.

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

  • В Java equals() возвращает истину (true), если аргумент не имеет нулевого значения (null), является объектом того же типа и с тем же числовым значением. Есть некоторые дополнительные требования, описанные в документации Java API, для double и float объектов.

Пример

public class Test < public static void main(String args[])< Integer x = 5; Integer y = 10; Integer z =5; Short a = 5; System.out.println(x.equals(y)); System.out.println(x.equals(z)); System.out.println(x.equals(a)); >>

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

false true false

Оглавление

  • 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

Сравнение 3 чисел

В отделе работают 3 сотрудника, которые получают заработную плату в рублях. Требуется определить: на сколько зарплата самого высокооплачиваемого из них отличается от самого низкооплачиваемого.

Как можно написать эту задачу проще и почему у меня не вычитается максимальное значение от минимального?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46
public static void main(String[] args) { int a,b,c,min,max,raz; //raz=max-min; Scanner sc= new Scanner(System.in); a=sc.nextInt(); b=sc.nextInt(); c=sc.nextInt(); if (a>b); { if (a>c) max=a; System.out.println("Наибольшая зарплата "+a); } if (ab) { if (ac) min=a; System.out.println("Наименьшая зарплата "+a); } if (b>a); { if (b>c) max=b; System.out.println("Наибольшая зарплата "+b); } if (ba) { if (bc) min=b; System.out.println("Наименьшая зарплата "+b); } if (c>a); { if (c>b) max=b; System.out.println("Наибольшая зарплата "+c); } if (ca) { if (cb) min=b; System.out.println("Наименьшая зарплата "+c); } //System.out.println("Разница между максимальной и минимальной "+raz); }

Как сравнить строки в Java? Сравниваем строки в Java

В этой статье мы рассмотрим операторы и методы сравнения строк в Java. Поговорим про особенности использования оператора == , а также про методы equals(), equalsIgnoreCase и compareTo(), т. к. они используются чаще всего.

Оператор для сравнения строк «==»

В первую очередь, надо сказать, что этот оператор проверяет и сравнивает не значения, а ссылки. С его помощью вы сможете проверить, являются ли сравниваемые вами элементы одним и тем же объектом. Когда 2 переменные String указывают на тот же самый объект в памяти, сравнение вернёт true, в обратном случае — false.

 
"Java" == "Java" //true


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


 
new String("Java") == "Java" // false


Вышеприведённые переменные String указывают уже на различные объекты.


 
new String("Java") == new String("Java") // false


Здесь тоже вышеприведенные переменные String указывают на различные объекты.


Итак, мы видим, что оператор == по сути, сравнивает не две строки, а лишь ссылки, на которые указывают строки.








 
class TestClass< public static void main (String[] args)< // ссылается на тот же объект, возвращая true if( "Java" == "Java" )< System.out.println("Statement is true"); >else < System.out.println("Statement is false"); >// указывает уже на другой объект, возвращая false if(new String("Java") == "Java")< System.out.println("Statement is true"); >else < System.out.println("Statement is false"); >// указывает тоже на другой объект, возвращая false if(new String("Java") == new String("Java") )< System.out.println("Statement is true"); >else < System.out.println("Statement is false"); >> >


Итог:


 
Statement is true Statement is false Statement is false


Метод сравнения String equals()


Сравнение строк с помощью equals позволяет проверять исходное содержимое строки. Метод возвращает true, когда параметр — объект String, представляющий собой ту же строку символов, что и объект:


 
Objects.equals("Java", new String("Java")) //true


Когда надо выполнить проверку, имеют ли 2 строки одинаковое значение, мы можем задействовать Objects.equals() .


 
class TestClass< public static void main (String[] args) < String str1 = "Java"; String str2 = "Java"; String str3 = "ASP"; String str4 = "JAVA"; String str5 = new String("Java"); // оба равны и возвращают true if(str1.equals(str2))< System.out.println("Statement is true"); >else < System.out.println("Statement is false"); >// оба не равны и возвращают false if(str1.equals(str3))< System.out.println("Statement is true"); >else < System.out.println("Statement is false"); >// оба не равны и возвращают false if(str1.equals(str4))< System.out.println("Statement is true"); >else < System.out.println("Statement is false"); >// оба равны и возвращают true if(str1.equals(str5))< System.out.println("Statement is true"); >else < System.out.println("Statement is false"); >> >


Итог:


 
Statement is true Statement is false Statement is false Statement is true


Метод сравнения String equalsIgnoreCase()


С помощью метода equalsIgnoreCase() вы выполните сравнение строк, что называется, лексикографически, причём различия регистра будут игнорированы. Здесь значение true возвращается в том случае, если аргумент является объектом String и представляет такую же последовательность символов, что и у объекта. Прекрасное решение, если надо осуществить проверку строки на равенство, не учитывая при этом регистр.








 
class TestClass< public static void main (String[] args)< String str1 = "Java"; String str2 = "JAVA"; // возвращается true, ведь обе строки равны без учёта регистра if(str1.equalsIgnoreCase(str2))< System.out.println("Statement is true"); >else < System.out.println("Statement is false"); >// возвращается false, т. к. учитывается регистр символов if(str1.equals(str2))< System.out.println("Statement is true"); >else < System.out.println("Statement is false"); >> >


 
Statement is true Statement is false


Метод сравнения String compareTo()


Метод сравнения compareTo() применяется, если надо определить лексикографический порядок строк. Он выполняет сравнение значения char, действуя аналогично equals(). Когда 2 строки совпадают, compareTo() вернёт значение «ноль» (результат = 0). Сравнивая 2 строки, он вернёт положительное целое число (результат > 0), если 1-й объект String следует за 2-й строкой. Соответственно, метод вернёт отрицательный результат (результат < 0), когда 1-й объект String будет предшествовать 2-й строке:


 
result1 == result2 :возвращается 0; result1 > result2 :возвращается положительное значение; result1 < result2 : возвращается отрицательное значение.


Приведём пример:


 
class TestClass < public static void main (String[] args) < String str1 = "Java"; String str2 = "Java"; String str3 = "ASP"; int val = 0; val = str1.compareTo(str2); System.out.println(val); val = str1.compareTo(str3); System.out.println(val); val = str3.compareTo(str1); System.out.println(val); >>


Итог:


 
0 9 -9


На этом всё, очень надеемся, что этот материал будет вам полезен при сравнении строк в "Джава".


При подготовке статьи использовалась публикация «String Comparison in Java».








Хотите знать больше? Приходите на курс!


Как правильно сравнить два целых числа в Java?


a автоматически будет распакован, и сравнение будет работать. Однако, что происходит, когда вы сравниваете два вставных Integers и хотите сравнить либо равенство, либо меньше/больше, чем?


Integer a = 4; Integer b = 5; if (a == b) 


Будет ли выше код приводить к проверке того, являются ли они одним и тем же объектом, или будет ли он автоматически распаковываться в этом случае? Как насчет:


Integer a = 4; Integer b = 5; if (a < b) 


Jon Skeet 04 окт. 2009, в 00:20

Поделиться

Ну, что случилось, когда ты попробовал? Что вы наблюдали?

Bart Kiers 03 окт. 2009, в 21:36


@Bart Барт Киерс: Явный эксперимент мог только опровергнуть, но не доказать, что распаковка происходит. Если использование == вместо equals приводит к правильному результату, это может быть связано с тем, что числа в штучной упаковке интернированы или используются иным образом (предположительно, для оптимизации компилятора). Причиной задать этот вопрос является выяснение того, что происходит внутри, а не того, что происходит. (По крайней мере, поэтому я здесь.)








Jim Pivarski 08 дек. 2013, в 06:23

Поделиться:

autoboxing


7 ответов


Нет, == между Integer, Long и т.д. будет проверять ссылочное равенство - i.e.


Integer x = . ; Integer y = . ; System.out.println(x == y); 


это проверит, относятся ли теги x и y к одному и тому же объекту, а не к равным объектам.


Integer x = new Integer(10); Integer y = new Integer(10); System.out.println(x == y); 


гарантируется печать false . Интернирование "малых" значений автобокса может привести к сложным результатам:


Integer x = 10; Integer y = 10; System.out.println(x == y); 


Это напечатает true , из-за правил бокса (JLS раздел 5.1.7). Он по-прежнему ссылается на равенство, но ссылки действительно равны.








Лично я бы использовал:


if (x.intValue() == y.intValue()) 


if (x.equals(y)) 


Последнее немного менее эффективно - нет перегрузки для Integer.equals(Integer) , поэтому ему придется выполнять проверку типа времени выполнения, тогда как первый использует тот факт, что мы уже знаем, что оба объекта Integer s.


К счастью, compareTo знает о типах, поэтому:


if (x.compareTo(y) < 0) 


должен быть эффективен. Конечно, это область микрооптимизации, и вы должны использовать код, который вы найдете наиболее ясным - после того, как он будет прав:)


Как вы говорите, для любого сравнения между типом-оболочкой ( Integer , Long и т.д.) и числовым типом ( int , Long и т.д.) значение типа обертки распаковывается, и тест применяется к примитивные значения.








Это происходит как часть двоичной цифровой рекламы (JLS раздел 5.6.2). Посмотрите на каждую отдельную документацию оператора, чтобы узнать, применяется ли она. Например, из документов для == и!= (JLS 15.21.1):




Если операнды равенства оператор имеют как числовой тип, так и один имеет числовой тип, а другой является конвертируемой (п. 5.1.8) в числовой тип, двоичное числовое продвижение выполняются над операндами (§5.6.2).






Тип каждого из операндов оператор численного сравнения должен быть тип, который является конвертируемым (п. 5.1.8), к примитивный числовой тип или ошибка компиляции. двоичный числовое продвижение выполняется на операндов (§5.6.2). Если продвинутый тип операндов int или long, то целочисленное сравнение со знаком выполнено; если этот продвинутый тип float или double, затем с плавающей запятой сравнение выполняется.




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


Jon Skeet 04 окт. 2009, в 08:31

Поделиться

Есть ли какая-то причина, по которой можно написать x.compareTo(y) < 0 вместо x < y ?
Max Nanasy 29 авг. 2015, в 01:06
@MaxNanasy: Не то, чтобы я мог сразу думать.
Jon Skeet 29 авг. 2015, в 08:14



Начиная с Java 1.6.27+ в классе Integer имеется перегруженная функция equals, поэтому она должна быть такой же эффективной, как и вызов .intValue (). Он сравнивает значения как примитив int.


otterslide 22 сен. 2016, в 17:44


Как сказал @otterslide, в Java 8 это больше не нужно. Сравнение Integer с Integer по умолчанию выполняется по значению.








Axel Prieto 21 июль 2018, в 11:12


@Axel: Аксель: Добавление перегрузки не изменит поведение оператора ==, правда? Я не в состоянии проверить прямо сейчас, но я был бы очень удивлен, если это изменилось.


Jon Skeet 21 июль 2018, в 14:51

Показать ещё 3 комментария


== все равно будет проверять равномерность объекта. Однако легко обмануть:


Integer a = 10; Integer b = 10; System.out.println(a == b); //prints true Integer c = new Integer(10); Integer d = new Integer(10); System.out.println(c == d); //prints false 


Ваши примеры с неравенствами будут работать, поскольку они не определены в объектах. Однако при сравнении == все равно будет проверяться равенство. В этом случае, когда вы инициализируете объекты из примитива в штучной упаковке, используется тот же объект (для a и b). Это хорошая оптимизация, поскольку примитивные классы ящиков неизменяемы.








Adam Lewis 03 окт. 2009, в 22:02

Поделиться


Я подумал, что проверяется равенство объектов. У меня были странные результаты. Должен ли я заменить его на .equals ()? Кроме того, вы считаете, что я должен оставить неравенства такими, какие они есть, или сделать это иначе?


Samatha84 03 окт. 2009, в 21:42


Есть некоторые неочевидные крайние случаи с автобоксом. Мой IDE (Eclipse) настроен на то, чтобы распаковывать все, что было распаковано, красным, это несколько раз спасало меня от ошибок. Если вы сравниваете два целых числа, используйте .equals, если вы хотите прояснить свое неравенство, напишите приведение в явном виде: if ((int) c

Adam Lewis 03 окт. 2009, в 22:40

И если вы измените числовые литералы на 200 , оба теста выведут false .

Daniel Earwicker 03 окт. 2009, в 23:11


. в большинстве реализаций JVM. В зависимости от спецификации языка результат может отличаться в зависимости от реализации.


Daniel Earwicker 03 окт. 2009, в 23:12








Я думаю, что более понятно назвать это «ссылочным равенством» - таким образом, очевидно, что вы имеете в виду. Я обычно понимаю, что «равенство объектов» означает «результат equals ».


Jon Skeet 04 окт. 2009, в 07:03

+1 Джон 🙂 Я просто подумал: «Разве (c == d) не сравнивать ссылочную переменную объекта?»

Eddie B 28 окт. 2012, в 21:17

Но целое число а = 3000; Целое число b = 3000; System.out.println (a == b); // печатает ложь

Danil Chernokalov 05 окт. 2013, в 02:01


@AdamLewis Не могли бы вы прислать мне ссылку, которая объясняет, что делать, чтобы раскраска работала так, как вы? 🙂 Спасибо заранее!


Anton 04 сен. 2014, в 14:56


Для всех остальных, ищущих, как заставить окраску работать: в Eclipse нажмите Ctrl+3 и найдите Syntax coloring .








eee 07 нояб. 2014, в 19:40


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


Theodore Murdock 15 сен. 2015, в 00:05


Осторожно, Integer c = Integer.valueOf(10); Integer d = Integer.valueOf(10); System.out.println(c == d); //prints TRUE поскольку valueOf использует кэш от -127 до +127. Что касается Long.valueOf. Так что не полагайтесь на == за исключением Primitive или Enum


Julien Feniou 09 нояб. 2018, в 11:00

Показать ещё 9 комментариев








== проверяет ссылочное равенство, однако при написании кода вроде:


Integer a = 1; Integer b = 1; 


Java достаточно умен, чтобы использовать одно и то же неизменяемое для a и b , поэтому это верно: a == b . Любопытно, что я написал небольшой пример, показывающий, где java останавливает оптимизацию таким образом:


public class BoxingLol < public static void main(String[] args) < for (int i = 0; i < Integer.MAX_VALUE; i++) < Integer a = i; Integer b = i; if (a != b) < System.out.println("Done: " + i); System.exit(0); >> System.out.println("Done, all values equal"); > > 


Когда я компилирую и запускаю это (на моей машине), я получаю:


Done: 128 


Cory Kendall 15 июль 2015, в 22:19

Поделиться


tl; dr -1 для ручной работы; stackoverflow.com/questions/15052216/… stackoverflow.com/questions/20897020/… stackoverflow.com/questions/3131136/integers-caching-in-java и т. д. подробно объясняют упомянутый вами вопрос; лучше читать документы (или исходный код lib), чем создавать псевдотесты с риском высокой локализации результатов - вы не только полностью забыли о нижней границе кэша (то есть по умолчанию -128), не только у вас есть по одному (максимум 127, а не 128),








vaxquis 22 дек. 2015, в 00:08


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


vaxquis 22 дек. 2015, в 00:08


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


Cory Kendall 22 дек. 2015, в 03:06








это не мнение или восприятие - это факты , которые вы искренне упустили. Проведение псевдотестирования, ничего не доказывающего, без каких-либо твердых данных (документов, источников и т. Д.) И без ответов на вопросы OP, не заслуживает того, чтобы называться ни хорошими вопросами и ответами, ни CS. Что касается «другого подхода» - КС по определению является наукой ; то, что вы сделали наукой, не является ; это вводящие в заблуждение пустяки (или это будет интригующий комментарий , если он будет правильно сформулирован) - если вы хотите, чтобы это был научный подход , исправьте фундаментальные недостатки в вашем ответе или разумно опровергните их, так как именно так работает экспертная проверка


vaxquis 22 дек. 2015, в 15:02


Конечно, я постараюсь устранить недостатки. Я не забыл о нижней границе, я не чувствовал, что это интересно, и решил не включать ее. Я не верю, что у меня отключена одна ошибка, я указал способ, которым java (который я разъяснил на моей машине, в моей ситуации) прекратил оптимизировать, это было на уровне 128. Если бы я указал максимальное значение, это сделало это для того, чем вы правы, ответ был бы 127.


Cory Kendall 23 дек. 2015, в 22:29


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








Cory Kendall 23 дек. 2015, в 22:32


при написании ответа в Q / A формате, ваш ответ musn't быть о том, что вы чувствуете себя лично интересно, но о том, что OP (и , таким образом, сам вопрос) нуждается / требует и / или то , что случайный посетитель этого заданного Q / A мог бы рассмотреть либо очень полезную, ясную и проверяемую информацию по этому вопросу - опять же, ваш код вводит в заблуждение будущих посетителей (по причинам, изложенным в моем первом комментарии), и подход, который вы представите, может стать источником многих вредных привычек программирования , относительно того, почему -


vaxquis 24 дек. 2015, в 14:28


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


vaxquis 24 дек. 2015, в 14:32

Показать ещё 6 комментариев








Начиная с Java 1.7 вы можете использовать Objects.equals:


java.util.Objects.equals(oneInteger, anotherInteger); 




Возвращает true, если аргументы равны друг другу, а false - в противном случае. Следовательно, если оба аргумента равны null, возвращается true, и если только один аргумент имеет значение null, возвращается false. В противном случае равенство определяется с помощью метода equals первого аргумента.




Justas 22 март 2018, в 15:52

Поделиться


if (a == b) 


Будет работать большую часть времени, но он не гарантирует, что он всегда будет работать, поэтому не используйте его.


Самый правильный способ сравнения двух классов Integer для равенства, считая, что они называются 'a' и 'b', это вызвать:


if(a != null && a.equals(b))


Вы также можете использовать этот способ, который немного быстрее.


 if(a != null && b != null && (a.intValue() == b.intValue()))


На моей машине 99 миллиардов операций заняли 47 секунд, используя первый метод, и 46 секунд, используя второй метод. Вам нужно будет сравнивать миллиарды значений, чтобы увидеть разницу.


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


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


if (a != null && b!=null) < int compareValue = a.compareTo(b); if (compareValue >0) < System.out.println("a is greater than b"); >else if (compareValue < 0) < System.out.println("b is greater than a"); >else < System.out.println("a and b are equal"); >> else


otterslide 22 сен. 2016, в 19:46

Поделиться

if (a==b) работает только для небольших значений и не будет работать большую часть времени.

Tony 30 авг. 2017, в 15:04


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


otterslide 31 авг. 2017, в 15:53


 tl; dr Мое мнение заключается в использовании унарного + для запуска unboxing на одном из операндов при проверке равенства значений и просто использовании операторов математики в противном случае. Обоснование следует:


Уже упоминалось, что сравнение == для Integer - это сравнение идентичности, которое обычно не то, что хочет программист, и что целью является сравнение значений; Тем не менее, я сделал небольшую науку о том, как сделать это сравнение наиболее эффективно, как с точки зрения компактности, правильности и скорости кода.


Я использовал обычный набор методов:


public boolean method1() < Integer i1 = 7, i2 = 5; return i1.equals( i2 ); >public boolean method2() < Integer i1 = 7, i2 = 5; return i1.intValue() == i2.intValue(); >public boolean method3() < Integer i1 = 7, i2 = 5; return i1.intValue() == i2; >public boolean method4() < Integer i1 = 7, i2 = 5; return i1 == +i2; >public boolean method5() < // obviously not what we want.. Integer i1 = 7, i2 = 5; return i1 == i2; >


и получил этот код после компиляции и декомпиляции:


public boolean method1() < Integer var1 = Integer.valueOf( 7 ); Integer var2 = Integer.valueOf( 5 ); return var1.equals( var2 ); >public boolean method2() < Integer var1 = Integer.valueOf( 7 ); Integer var2 = Integer.valueOf( 5 ); if ( var2.intValue() == var1.intValue() ) < return true; >else < return false; >> public boolean method3() < Integer var1 = Integer.valueOf( 7 ); Integer var2 = Integer.valueOf( 5 ); if ( var2.intValue() == var1.intValue() ) < return true; >else < return false; >> public boolean method4() < Integer var1 = Integer.valueOf( 7 ); Integer var2 = Integer.valueOf( 5 ); if ( var2.intValue() == var1.intValue() ) < return true; >else < return false; >> public boolean method5() < Integer var1 = Integer.valueOf( 7 ); Integer var2 = Integer.valueOf( 5 ); if ( var2 == var1 ) < return true; >else < return false; >> 


Как вы можете легко видеть, метод 1 вызывает Integer.equals() (очевидно), методы 2-4 приводят к точному же коду, разворачивая значения с помощью .intValue() , а затем сравнивая их напрямую, а метод 5 просто запускает сравнение идентичности, являющееся неправильным способом сравнения значений.


Поскольку (как уже упоминалось, например, JS) equals() берет накладные расходы (он должен делать instanceof и неконтролируемый отбор), методы 2-4 будут работать с точно такой же скоростью, заметно лучше, чем метод 1, когда используется в жестких петлях, поскольку HotSpot вряд ли оптимизирует отливки и instanceof .


Это очень похоже на другие операторы сравнения (например, < / >) - они вызовут unboxing, а использование compareTo() не будет - но на этот раз операция очень оптимизирована HS, поскольку intValue() это просто метод геттера (основной кандидат на оптимизацию).


По-моему, редко используемая версия 4 является наиболее кратким способом - каждый опытный разработчик C/Java знает, что унарный плюс в большинстве случаев равен ставке int / .intValue() - хотя это может быть немного Время WTF для некоторых (в основном тех, кто не использовал унарный плюс в своей жизни), он, возможно, показывает намерение наиболее четко и наименее - он показывает, что мы хотим иметь значение int одного из операндов, заставляя другое значение для удаления. Также неоспоримо наиболее похоже на обычные i1 == i2 сравнения используются для примитивного int значения.


Мое голосование за стиль i1 == +i2 и i1 > i2 для объектов Integer , как по соображениям производительности, так и по последовательности. Он также переносит код в примитивы, не изменяя ничего, кроме объявления типа. Использование названных методов похоже на введение семантического шума для меня, похоже на сильно критикуемый стиль bigInt.add(10).multiply(-3) .





Похожие публикации:
    

  1. Event shelljacket us что это
    2. 

  2. Fallout 2 элдридж в какой части нью рено
    3. 

  3. Распознавание текстов очень важная задача которая возникает
    4. 

  4. Что написать на c новичку
    5.

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *