Разница между int[] и Integer[]

Существенная разница в том, что в JAVA intэто примитивный тип, а не объект, тогда как это Integerобъект или класс.

На разговорном языке: а int— это число, а а Integer— это указатель, который ссылается на класс, содержащий целое число. Или... еще более разговорно: а Integer— это коробка, а а int— то, что находится внутри этой коробки.

Что это значит?

A intнамного быстрее, когда речь идет о вычислении чисел в диапазоне -2 147 483 648 [-2 ³¹ ], то есть Integer.MIN_VALUEи +2 147 483 647 [2 ³¹ -1], то есть Integer.MAX_VALUE. Другими словами, intв нашем распоряжении есть 32 бита информации, которые можно использовать напрямую. См. спецификации .

Переменные intизменяемы. Если они не отмечены как final, они могут изменить свое значение в любое время. Типичный пример использования intдля изменения значения счетчика в циклах for, whileи т.д.

A Integer, это объект, который содержит одно поле int. A Integerнамного громоздче, чем int. Объекты Integerнеизменны. Если вы хотите повлиять на значение переменной Integer, единственный способ — создать новый объект Integerи отказаться от старого.

А. Примитив int

Переменные типа int хранят фактическое двоичное значение целого числа, которое они представляют.

Следовательно, следующий код неверен в Java:

int.parseInt("1");

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

Б. Класс Integer

Integer, как я уже сказал, является классом, как и любой другой класс Java, со своими методами.

Этот код правильный в Java:

Integer.parseInt ("1");

Это вызов статического метода parseIntкласса Integer, который возвращает a int, а не a Integer.

Можно сказать, что это Integerкласс с одним полем типа int. Этот класс используется там, где необходимо intобращаться с a как с любым другим объектом, например, в универсальных типах или в ситуациях, когда требуются нулевые значения.

Вот небольшая таблица с некоторыми показателями:

| Uso                                                         | int | Integer |
|-------------------------------------------------------------|-----|---------|
| Cálculos con + - * / % ^ etc.                               | sí  | no      |
| Pasar como parámetro                                        | sí  | sí      |
| Retornar como un valor                                      | sí  | sí      |
| Usar métodos desde java.lang.Integer                        | no  | sí      |
| Almacenarlo en un Vector o en otra Colección                | no  | sí      |
| Usarlo como una llave de HashMap                            | no  | sí      |
| Serializarlo                                                | no  | sí      |
| Pasarlo como un objeto genérico (TableCellRenderer)         | no  | sí      |
| Admitir como un valor nulo para significar que no hay valor | no  | sí      |
| Enviarse a sí mismo por RMI (Remote Method Invocation)      | no  | sí      |
| Enviarlo como parte de otro Objeto a través de RMI          | sí  | sí      |

РЕДАКТИРОВАТЬ: автобоксинг и распаковка

Не все то золото, что блестит, берегитесь!

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

Начиная с Java 1.5 разрешено автоматически преобразовывать примитивы в объекты (обертки) или наоборот. Это известно как AutoBoxing и UnBoxing.

Многое из того, что следует далее, взято из документации по Java :

А. Автобокс

Автоупаковка — это автоматическое преобразование, которое компилятор Java выполняет между примитивными типами и соответствующими классами контейнеров объектов. Например, преобразовать a intв a Integer, a doubleв a Duobleи так далее. Если преобразование выполняется другим способом, оно называется распаковкой.

Компилятор Java применяет автоупаковку, когда примитивное значение:

• Передается как параметр методу, который ожидает объект соответствующего класса контейнера.
• Присваивается переменной соответствующего класса контейнера.

Вот простейший пример автобокса:

Character ch = 'a';

В остальных примерах в этом разделе используются дженерики...

Рассмотрим следующий код:

List<Integer> li = new ArrayList<>();
for (int i = 1; i < 50; i += 2)
     li.add(i);

Хотя liзначения добавляются intкак примитивные типы, а не объекты Integer, код компилируется. Потому liчто это список объектов Integer, а не список значений int. Можно задаться вопросом, почему компилятор Java не выдает ошибку во время компиляции . Компилятор не генерирует ошибку, потому что он создает объект Integerиз iи добавляет объект вli . Поэтому компилятор преобразует приведенный выше код в следующий во время выполнения:

List<Integer> li = new ArrayList<>();
for (int i = 1; i < 50; i += 2)
    li.add(Integer.valueOf(i));

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

Некоторые считают автобоксинг — распаковку чем-то волшебным, чем-то великим. Лично я думаю, что это не так. И здесь стоит спросить, а зачем делегировать компилятору то, что может сделать программист? Будьте осторожны, потому что у нас может быть красивый код, приятный для чтения, но в нем в любой момент может быть серьезный баг.

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

Об этом, между прочим, четко сказано в документации по Java :

Упаковочное преобразование может привести к ошибке OutOfMemoryError , если необходимо выделить новый экземпляр одного из классов-оболочек (Boolean, Byte, Character, Short, Integer, Long, Float или Double) и недостаточно памяти.

B.Распаковка

Преобразование объекта из типа контейнера ( Integer) в его соответствующее примитивное значение ( int) называется распаковкой.

Компилятор Java применяет распаковку, когда объект класса-оболочки:

• Передается как параметр методу, который ожидает значение соответствующего примитивного типа.
• Присваивается переменной соответствующего примитивного типа.

Рассмотрим следующий метод:

public static int sumEven(List<Integer> li) {
    int sum = 0;
    for (Integer i: li)
        if (i % 2 == 0)
            sum += i;
        return sum;
}

Поскольку операторы (%) и (+ =) не применяются к объектам Integer, может возникнуть вопрос, почему компилятор Java компилирует метод без выдачи ошибки. Компилятор не выдает ошибку, потому что он вызывает метод intValue для преобразования a Integerв a intво время выполнения :

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

public static int sumEven(List<Integer> li) {
    int sum = 0;
    for (Integer i : li)
        if (i.intValue() % 2 == 0)
            sum += i.intValue();
        return sum;
}

Я снова спрашиваю себя: почему, если компилятор ожидает тип данных, я должен отправлять ему другой?

Согласно Java, это вопрос эстетики , а не производительности:

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

---

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

Вот почему Java говорит:

Итак, когда следует использовать автоупаковку и распаковку? Используйте их только тогда, когда есть «несоответствие импеданса» между ссылочными типами и примитивами, например, когда вам нужно поместить числовые значения в коллекцию. Не следует использовать автоупаковку и распаковку для научных вычислений или другого числового кода, чувствительного к производительности. Integer не заменяет int; автоупаковка и распаковка стирают различие между примитивными и ссылочными типами, но не устраняют его.

---

Итак, когда следует использовать автоупаковку и распаковку? Используйте их только тогда, когда существует «несоответствие импеданса (*)» между ссылочными типами и примитивами, например, когда вам нужно поместить числовые значения в коллекцию. Не следует использовать автоупаковку и распаковку для научных вычислений или другого числового кода, чувствительного к производительности . Целое число не заменяет целое; Автоупаковка и распаковка стирают различие между примитивными и ссылочными типами, но не устраняют его .

(*) Неисправность импеданса (несоответствие импеданса). Чтобы понять эту концепцию, я приведу пример: если мы ожидаем значения из столбца базы данных, допускающего нули, и присваиваем это значение переменной типа, intмы сталкиваемся со случаем, impedance mismatchпоскольку intэто не так . допустим нули, программа могла выдать ошибку , или максимум присвоит значение 0вместо NULL. Или наоборот, если мы отправляем значения из Java в БД, если мы используем intдля INSERT или UPDATE в БД, мы могли бы отправлять значение в некоторые столбцы вместо NULLзначения 0. Это может показаться глупым , но в некоторых случаях может быть чем-то очень серьезным.

Короче говоря, не делегируйте компилятору то, что вы должны делать сами. Результаты могут быть катастрофическими. Потеря контроля над типом данных, которые будут использоваться, путем делегирования — плохая практика программирования.

И давай промолчим, если придется сравнивать . У нас могут быть неожиданные результаты, поскольку автоупаковка-распаковка маскирует реальные значения, потому что a никогда Integerне заменит a int. Одно дело коробка, а другое то, что внутри коробки. Если мы путаем эти две вещи, мы можем совершить очень серьезные ошибки.

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

Следует отметить, что в Java каждый примитивный тип имеет эквивалентный класс-оболочку:

• byteимеютbyte
• shortимеютShort
• intимеютInteger
• longимеютLong
• booleanимеютBoolean
• charимеютChar
• floatимеютFloat
• doubleимеютDouble

Сначала вы должны различать, что такое примитивный тип и объект.

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

Объекту может быть присвоено значение null, например:Integer numero = null;

Тип-примитив не содержит ни атрибутов, ни методов и представляет собой минимальную единицу выражения.

Вы не можете присвоить null примитивному типу, например: (ошибка компиляции)int numero = null;

В вашем случае int — это примитивный тип, а Integer — это объект, который его представляет.