В Java существуют дискуссии вокруг Integer vs int. Значение по умолчанию для первого означает null, а в последнем - 0. Как насчет Boolean vs Boolean?
Переменная в моем приложении может иметь значения 0/1. Я хотел бы использовать Boolean/Boolean и предпочитаю не использовать int. Могу ли я использовать Boolean/Boolean вместо этого?
Да, вы можете использовать Boolean/boolean вместо этого.
Первый объект Object, а второй тип примитив.
На первом вы получите больше методов, которые будут полезны.
Второй дешевый, учитывая затраты памяти. Второй сэкономит вам больше памяти, так что дерзайте
Теперь выберите свой путь.
Boolean wraps тип логического примитива. В JDK 5 и выше Oracle (или Sun до того, как Oracle их купил) представила autoboxing/unboxing, что по сути позволяет вам сделать это
boolean result = Boolean.TRUE;
или
Boolean result = true;
Что по сути делает компилятор,
Boolean result = Boolean.valueOf(true);
Итак, для вашего ответа это ДА.
Я немного расширяю предоставленные ответы (поскольку до сих пор они концентрируются на своей "собственной" /искусственной терминологии, ориентированной на программирование определенного языка вместо того, чтобы заботиться о большей картине за сценой создания языков программирования, в общем, т.е. когда такие вещи, как соображения безопасности типа и памяти, имеют значение):
int не является логическим
Рассмотрим
boolean bar = true;
System.out.printf("Bar is %b\n", bar);
System.out.printf("Bar is %d\n", (bar)?1:0);
int baz = 1;
System.out.printf("Baz is %d\n", baz);
System.out.printf("Baz is %b\n", baz);
с выходом
Bar is true
Bar is 1
Baz is 1
Baz is true
Java-код на третьей строке (bar)?1:0 иллюстрирует, что bar (boolean) не может быть неявно преобразован (casted) в int. Я приводил это не для того, чтобы проиллюстрировать детали реализации JVM, а для того, чтобы указать, что с точки зрения соображений низкого уровня (в качестве размера памяти) нужно отдавать предпочтение значениям по типу безопасности. Особенно, если безопасность этого типа действительно/полностью не используется, как в булевых типах, где проверки выполняются в форме
если значение \in {0,1}, затем отбрасывается в булевский тип, в противном случае генерирует исключение.
Все, чтобы указать, что {0,1} < {-2 ^ 31,.., 2 ^ 31 -1}. Кажется, это перебор, верно? Безопасность типов действительно важна в пользовательских типах, а не в неявном литье примитивов (хотя последние включены в первый).
Байты не являются типами или битами
Обратите внимание, что в памяти ваша переменная из диапазона {0,1} будет по-прежнему занимать хотя бы один байт или слово (xbits в зависимости от размера регистра), если специально не позаботиться (например, упакован красиво в памяти - 8 "boolean" бит в 1 байт - назад и вперед).
Отдавая предпочтение безопасности типа (как при вводе/обертывании значения в поле определенного типа) за дополнительную упаковку значений (например, с использованием сдвигов бит или арифметики), каждый из них эффективно выбирает меньше кода для получения большего объема памяти. (С другой стороны, всегда можно определить пользовательский тип, который облегчит преобразование, не превышающее Boolean).
ключевое слово vs. type
Наконец, ваш вопрос о сравнении ключевого слова и типа. Я считаю, что важно объяснить, почему и как именно вы получите производительность, используя/предпочитая ключевые слова ( "помечены" как primitive) по типам (обычный составной пользовательский интерфейс, определяемые классы с использованием другого класса ключевых слов) или другими словами
boolean foo = true;
против.
boolean foo = true;
Первая "вещь" (тип) не может быть расширена (подклассифицирована) и не без причины. Эффективно Java-терминология классов примитивных и обертывания может быть просто переведена в встроенное значение (LITERAL или константа, которая получает напрямую замену компилятором всякий раз, когда она можно вывести подстановку, а если нет - все равно вернуть в значение значение).
Оптимизация достигается за счет тривиального:
"Меньшее время выполнения операций литья = > больше скорости".
Вот почему, когда выполняется фактический вывод типа, он может (все же) в конечном итоге создать экземпляр класса упаковки со всей информацией о типе, если это необходимо (или преобразовать/вставить в такое).
Таким образом, разница между булевыми и булевыми находится в точности Компиляция и Время выполнения (немного далеко но почти как instanceof против getClass()).
Наконец, автобоксинг медленнее, чем примитивы
Обратите внимание на то, что Java может выполнять autoboxing, всего лишь "синтаксический сахар". Это ничего не ускоряет, просто позволяет писать меньше кода. Это. Литье и упаковка в контейнер информации типа все еще выполняется. По соображениям эффективности выберите арифметику, которая всегда будет пропускать дополнительное обслуживание создания экземпляров класса с информацией типа для обеспечения безопасности типов. Недостаток типа безопасности - это цена, которую вы платите, чтобы повысить производительность. Для кода с булевозначными выражениями тип безопасности безопасности (когда вы пишете меньше и, следовательно, неявный код), будет иметь решающее значение, например. для управления потоком if-then-else.
Вы можете использовать Boolean константы - Boolean.TRUE и Boolean.FALSE вместо 0 и 1. Вы можете создать свою переменную как тип boolean, если примитив - это то, что вам нужно. Таким образом вам не придется создавать новые объекты boolean.
В основном логическое выражение представляет собой примитивный тип данных, где Boolean представляет собой ссылочный тип данных. эта история запускается, когда Java хочет стать чисто объектно-ориентированной, она предоставила концепцию класса-оболочки для использования примитивного типа данных.
boolean b1;
Boolean b2;
b1 и b2 не совпадают.
Класс java.lang.Boolean переносит значение примитивного типа boolean в объекте. Объект типа Boolean содержит одно поле, тип которого является логическим
Ниже приведена декларация, публичный конечный класс Boolean расширяет объект реализует Serializable, Comparable
Одно наблюдение: (хотя это можно думать о побочном эффекте)
Булево, будучи примитивом, может сказать да или нет.
Boolean - это объект (он может ссылаться на "да" или "нет" или "не знаю", т.е. На ноль)
Вы можете использовать Boolean/Boolean. Простота - это путь. Если вам не нужны конкретные API (коллекции, потоки и т.д.) И вы не предвидите, что они вам понадобятся - используйте примитивную версию (булево).
С примитивами вы гарантируете, что не будете передавать нулевые значения.
Вы не попадете в такие ловушки. Приведенный ниже код генерирует исключение NullPointerException (из: Booleans, условные операторы и автобокс):
public static void main(String[] args) throws Exception { Boolean b = true? returnsNull(): false;//NPE on this line. System.out.println(b); } public static Boolean returnsNull() { return null; }
Используйте Boolean, когда вам нужен объект, например: