в чем разница между int и integer java
Integer и int
В этом топике я хочу описать некоторые базовые различия между примитивными типами и соответствующими им объектными на примере int и Integer. Различия эти достаточно простые и, если немного задуматься, то вполне логичные, но, как показал опыт, программист не всегда над этим задумывается.
Основное различие, разумеется, в том, что Integer — это полнофункциональный объект, который занимает место в куче, а в коде вы пользуетесь ссылками на него, которые неявно преобразуются в значения:
Однако в большинстве случаев создаётся новый объект, и это может быть существенно. Помните так же, что объект Integer никогда не меняет своего значения. Рассмотрим такой на первый взгляд невинный код:
public class Increment
<
public static void main (String[] args)
<
Integer a= 0 ;
while(true) a++;
>
>
Попрофилируем использование памяти, к примеру, триальной версией JProfiler’а: 
Очевидно, при каждом инкременте создаётся новый объект Integer, а старые затем подчищаются сборщиком мусора, когда их накапливается порядка ста тысяч. Неплохая нагрузка на систему для обычной операции инкремента.
В целом понятно, что Integer надо использовать только тогда, когда без него не обойтись. Один из таких примеров — это параметризованные типы (generics), к примеру, стандартные коллекции. Но и тут надо быть аккуратным, чтобы использовать память разумно. Я приведу несколько утрированный пример на основе проблемы, с которой я столкнулся в реальном проекте. В некотором научном анализе требовалось ассоциировать с определёнными объектами длинные множества натуральных чисел. Можно сэмулировать это следующим кодом:
public class MapInteger
<
static Map > subSets = new HashMap >();
public static void put (Integer key, int value)
<
if(!subSets. containsKey (key)) subSets. put (key, new HashSet ());
subSets. get (key). add (value);
>
public static Collection getRandomKeys ()
<
List vals = new ArrayList ();
for( int i= 0 ; i int )(Math. random ()* 500 ); i++)
<
vals. add (( int )(Math. random ()* 1000 ));
>
return vals;
>
public static void main (String[] args)
<
new Scanner(System. in ). nextLine ();
for(Integer i= 0 ; i 100000 ; i++)
<
for(Integer key: getRandomKeys ())
put (key, i);
>
new Scanner(System. in ). nextLine ();
>
>
Для каждого числа из первых ста тысяч мы определяем набор ключей с помощью getRandomKeys (в реальной задаче ключи, конечно, были неслучайны) и добавляем текущее число в соответствующие множества subSets. Тип ключей Integer выбран для упрощения иллюстрации; в целом он неважен. Вот количества объектов до выполнения операции:
А вот после:
Принудительный запуск сборщика мусора помог несильно:
40 мегабайт памяти съедают целые числа — это печально. Причина кроется в прототипе метода put:
public static void put(Integer key, int value)
Из-за того, что здесь использован тип int, значения переменной i при передаче в метод автоматически преобразуются в int (unboxing), а затем заново в Integer (boxing), но уже создаётся новый объект. Заменим в прототипе int value на Integer value и запустим профайлер заново. В начале картина такая же:
Зато в конце значительные отличия:
И после сборки мусора:
Так, заменив один int на Integer, можно сэкономить около 40% используемой памяти. Заметим, что в for(Integer i=0; i тоже неслучайно используется Integer: напишем здесь int, и первое исправление не поможет. Видим, что правило писать int везде, где можно не писать Integer, работает не всегда: в каждом отдельном случае надо думать. Иногда также может пригодиться собственная реализация кэша целых чисел.
Разница между Integer и int в Java с примерами
Примеры:
Важные отличия:
// Java-программа для иллюстрации
// разница между
// int и Integer
public static void main(String args[])
Integer a = new Integer( «123» );
// Приведение возможно с использованием методов
// из класса Integer Wrapper
int b = Integer.parseInt( «123» );
System.out.print(a + new Float( «10.1» ));
// Java-программа для иллюстрации
// разница между
// int и Integer
public static void main(String args[])
String bin = Integer.toBinaryString( 123 );
String oct = Integer.toOctalString( 123 );
String hex = Integer.toHexString( 123 );
System.out.print(bin + «\n» + oct + «\n» + hex);
// Java-программа для иллюстрации
// разница между
// int и Integer
public static void main(String args[])
// mainethods конвертирует целое число в его двоичную форму,
// применить желаемую операцию
// а затем возвращает десятичную форму
// вновь сформированного двоичного числа
int rev = Integer.reverse( 12 );
System.out.print( «Left Rotate : » + rL
+ «\nRight rotate : » + rR + «\nReverse : » + rev);
// Java-программа для иллюстрации
// автобокс
public static void main(String args[])
Integer a = new Integer( «12» );
Integer d = new Integer( «13» );
Double f = new Double( «12.1» );
System.out.println( «Sum of 2 Integer objects :»
System.out.println(«Sum of an Integer object
and int value :» + (a + b));
System.out.println(«Sum of an Integer object
and double value :» + (a + c));
System.out.println(«Sum of an Integer object
and Double object :» + (a + f));
Помимо Integer у нас есть больше классов-оболочек в Java, соответствующих типам данных. Они даны следующим образом:
Эквивалентные классы-обертки примитивных типов в Java
В чем разница между Integer и int в Java?
например, почему вы можете сделать:
и вы можете сделать:
12 ответов:
int является примитивным типом. Переменные типа int сохраните фактическое двоичное значение для целого числа, которое вы хотите представить. int.parseInt(«1») не имеет смысла, потому что int и не класс и поэтому не имеет никаких методов.
обратите внимание, что каждый примитивный тип в Java имеет эквивалент фантик класс:
классы-оболочки наследуют от класса Object, и примитивный не. Поэтому он может быть использован в коллекции с объекта ссылка или с дженериками.
С java 5 у нас есть автобоксинг, и преобразование между примитивом и классом оболочки выполняется автоматически. Однако будьте осторожны, так как это может привести к тонким ошибкам и проблемам с производительностью; быть явным о преобразованиях никогда не повредит.
Integer-это класс, а int-примитивный тип.
читайте дальше по этим ссылкам:
целое число-это просто обертка для примитивного типа int. Это позволяет использовать все функции класса Integer, чтобы сделать жизнь немного проще для вас.
Если вы новичок в Java, то вы должны научиться ценить документацию Java. Например, все, что вы хотите знать о Integer Класс подробно документировано.
это прямо из документации для целого класса:
в Класс Integer обертывает значение примитивного типа int в объект. Объект типа Integer содержит одно поле, тип которого-int.
Integer относится к типу оболочки в Java, тогда как int является примитивным типом. Все, кроме примитивных типов данных в Java реализовано так же, как объекты, которые подразумевают, что Java является высококвалифицированным чистым объектно-ориентированным языком программирования. Если вам нужно, все типы примитивов также доступны как типы оболочки в Java. Вы можете иметь некоторое преимущество в производительности с примитивными типами, и поэтому типы обертки должны использоваться только тогда, когда это необходимо.
в вашем примере как под.
переменная int содержит 32-разрядное целое число со знаком. Целое число (с заглавной буквы I) содержит ссылку на объект (класс) типа Integer или null.
Java автоматически выполняет приведение между ними; от Integer до int всякий раз, когда объект Integer встречается в качестве аргумента оператору int или присваивается переменной int, или значение int присваивается целочисленной переменной. Это кастинг называется бокс / распаковка.
Если целочисленная переменная, ссылающаяся на null при распаковке явно или неявно создается исключение NullPointerException.
(в приведенном тексте, термин «переменная» означает локальную переменную, поле или параметр)
int-это примитивный тип, а не объект. Это означает, что нет никаких методов, связанных с ним. Integer-это объект с методами (например, parseInt).
С новой java есть функциональность для автоматического бокса (и распаковки). Это означает, что компилятор вставит целое число.метод valueOf(int) или целое число.intValue () там, где это необходимо. Это означает, что на самом деле можно написать
Integer-это класс-оболочка / объект, а int-примитивный тип. Это различие играет огромную роль, когда вы хотите хранить значения int в коллекции, потому что они принимают только объекты в качестве значений (до jdk1.4). JDK5 вперед из-за автобоксинга это совершенно другая история.
в Java int является примитивным типом данных, а Integer-вспомогательным классом, он используется для преобразования одного типа данных в другой.
примитивные типы данных хранят самую быструю память, где вспомогательный класс является сложным и хранить в памяти.
ссылка из» David Gassner » Java Essential Training.
после java 1.5 которые вводят понятие автоупаковка и анбоксинг вы можете инициализировать оба int или Integer такой.
Java использует примитивные типы (также называемых простыми типами), например,int или двойной, для хранения основных типов данных, поддерживаемых язык. примитивные типы, а не объекты, используемые для этих количество для ради производительности. Использование объектов для этих значений добавил бы недопустимо накладные расходы даже самый простой из проведенные расчеты. Таким образом,примитивные типы не являются частью объекта иерархия и они не наследуют объект.
несмотря на производительность преимущество, предлагаемое примитивными типами, есть моменты, когда вы будете нужно представление объекта. Например, вы не можете пройти примитивный введите по ссылке на метод. Кроме того, многие стандартные данные структуры, реализованные Java работайте на объектах, а это значит, что вы не можете использовать эти (объектно-ориентированные) структуры данных для хранения примитивных типов. К обрабатывая эти (и другие) ситуации, Java предоставляет оболочки типов, которые являются классами, инкапсулирующими примитивный тип внутри объекта.
классы-оболочки относятся непосредственно к Java автоупаковка особенность. Тип обертки Double, Float, Long, Integer, Short, Байт, символ и логическое значение. Эти классы предлагают широкий спектр методов, которые позволяют полностью интегрировать примитивные типы в Иерархия объектов Java.
Русские Блоги
В чем разница между int и Integer
1. Разница
2. Автоматическая упаковка и распаковка.
Как и вышеупомянутые целые числа, javac автоматически преобразует упаковку в Integer.valueOf () для нас и заменяет распаковку на Integer.intValue (), что, кстати, дает ответ на другой вопрос, поскольку вызов является Integer. ValueOf, естественно, может получить преимущества кеширования.
Проведите небольшой эксперимент: на основе среды jdk8
исходный код java:
Затем используйте javac для компиляции
Получите байт-код исходного кода Java: 
Используйте графический интерфейс JD для декомпиляции, получите декомпилированный код и найдите:
1. Автоматически помещайте значение 1, чтобы получить значение 1
2. Назначьте value1, полученное в результате автоматической упаковки, нашей целевой переменной interge (ссылка)
3. Автоматически распаковать временную переменную в 2 и назначить ее временной ссылке. Базовый тип, полученный после добавления 1, снова помещается в рамку и присваивается самому оригиналу.
4. Автоматически распаковать временную ссылку и назначить ее базовой переменной in.
Вы можете увидеть исходные 2 оператора и 3 выполненные операции:
1.integer = 1
2.in = integer
3.interger++
После декомпиляции автоматическая распаковка и автоматическая упаковка выполнялись много раз. Также используются временные ссылочные переменные (реализация ++)
Продолжайте использовать javap для декомпиляции:
Можно рисовать:
Автоматическая упаковка вызывает метод Integer.valueOf ()
Автоматическая распаковка вызывает метод Integer.intValue ()
(это также можно увидеть при декомпиляции графического интерфейса пользователя GD)
Итак, если это все основные типы и одна и та же операция, насколько велика разница между компиляцией и декомпиляцией?
Исходный код: 
Декомпилируйте через графический интерфейс JD: 
Декомпилировать с помощью Javap
Автоматической упаковки и распаковки нет вообще.
Исходя из этого, мы, кажется, можем сделать вывод:
Обработка операции базового типа ++ и операции упаковки типа ++ отличается.
другими словами:
JVM поддерживает базовые типы операций ++ (ЦП должен реализовывать операции ADD, а в сборке есть прямые инструкции для реализации ADD)
JVM не поддерживает операцию ++ для типа упаковки, поскольку тип упаковки на самом деле является объектом. ЦП может реализовывать значения ADD, но не может добавлять значения атрибутов объектов.
3. Исходный код для автоматической упаковки и распаковки.
еще есть вопрос:-128
4. Примитивная безопасность потоков
Базовые типы не являются потокобезопасными.
Приведите общий пример.
Многопоточный подсчет: небезопасно:
Выходной результат каждый раз отличается, но он не будет равен 4 Вт.
Давайте посмотрим на поточно-ориентированный:
Это должно быть 4 Вт каждый раз при выполнении.
Итак, можно ли обеспечить безопасность потоков с помощью базовых типов?
Его мощность также 4 Вт.
Используйте память, чтобы быть видимым, и используйте update для обновления. 
Его внутренняя часть реализована с использованием бесконечного цикла CAS.
Таким образом, основные типы многопоточности могут иметь следующие проблемы:
5. Ограничения примитивных типов данных и ссылочных типов.
В чем разница между int и integer в Java и C#?
Я читал больше Джоэл на программное обеспечение когда я наткнулся Джоэл Спольски говоря что-то о конкретном типе программиста, знающего разницу между int и Integer в Java / C# (объектно-ориентированные языки программирования).
Итак, в чем разница?
24 ответов
В C# тип » int » такой же, как System.Int32 и тип значения (т. е. больше похоже на java ‘int’). Целое число (как и любые другие типы значений) может быть коробочной («обернутый») в объект.
различия между объектами и примитивами, несколько выходит за рамки этого вопроса, но вкратце:
объекты предоставляют средства для полиморфизма, передаются по ссылке (или точнее имеют ссылки, переданные по значению) и выделяются из кучу. И наоборот, примитивы неизменяемые типы, передаваемые по значению и часто выделяются из стек.
Ну, в Java int является примитивом, в то время как целое число является объектом. Значение, если вы сделали новое целое число:
вы можете вызвать какой-то метод на i:
вы не можете вызывать любые методы, потому что это просто примитивно. Итак:
приведет к ошибке, потому что int-это не объект.
int является одним из немногих примитивов на Java (наряду с char и некоторыми другими). Я не на 100% уверен, но я думаю, что объект Integer более или менее просто имеет свойство int и целую кучу методов для взаимодействия с этим свойством (например, метод toString ()). Таким образом, Integer-это причудливый способ работы с int (так же, как, возможно, String-это причудливый способ работы с группой символов).
Я знаю, что Java не C, но поскольку я никогда не программировал на C, это самое близкое, что я мог бы ответить. Надеюсь, это поможет!
Я добавлю к отличным ответам, приведенным выше, и расскажу о боксе и распаковке, и как это относится к Java (хотя у C# тоже есть). Я буду использовать только терминологию Java, потому что я больше au fait С этим.
Java 5 и далее есть что-то под названием авто-бокс и авто-распаковка которые позволяют бокс / распаковку, чтобы быть сделано за кулисами. Сравнение и контраст: Java 5 версия:
Java 1.4 или более ранней (не дженерики либо):
следует отметить, что, несмотря на краткость в версии Java 5, обе версии генерируют идентичный байт-код. Таким образом, хотя авто-бокс и авто-распаковка очень удобны, потому что вы пишете меньше кода, эти операции do происходят за кулисами, с теми же затратами времени выполнения, поэтому вы все равно должны знать об их существовании.
надеюсь, что это помогает!
я просто опубликую здесь, так как некоторые из других сообщений немного неточны по отношению к c#.
в основном, int является зарезервированным ключевым словом на языке программирования C# и является псевдонимом для System.Int32 тип значения.
float и Float не совпадают, однако, как правильный тип системы для » float » система.Одиночный. Есть некоторые типы, подобные этому, которые зарезервировали ключевые слова, которые, похоже, не соответствуют именам типов напрямую.
в C# нет никакой разницы между» int » и » System.Int32 «, или любые другие пары или ключевые слова / системные типы, за исключением при определении перечислений. С помощью перечислений можно указать размер используемого хранилища, и в этом случае можно использовать только ключевое слово reserved, а не имя типа среды выполнения системы.
Wether значение в int будет храниться в стеке, в памяти или в качестве объекта кучи, на который ссылается, в зависимости от контекста и способа его использования.
это объявление в методе:
чтобы получить объект кучи, вы можете использовать бокс:
это создаст коробочную копию содержимого i в куче. В IL вы можете получить доступ к методам объекта кучи напрямую, но в C# вам нужно вернуть его в int, который создаст другую копию. Таким образом, объект в куче не может быть легко изменен в C# без создания новой коробочной копии нового значения int. (Фу, этот абзац не так-то легко прочитать.)
относительно Java 1.5 и автоупаковка существует важная «причуда», которая появляется при сравнении целых объектов.
пример, это возвращает true:
В то время как это возвращает false:
The == сравнивает по ссылке (указывает ли переменные на один и тот же объект).
решение? =) Всегда следует использовать целое число.метод Equals() при сравнении целочисленных объектов.
дополнительная информация на java.net Пример bexhuff.com
в Java есть два основных типа в JVM. 1) примитивные типы и 2) ссылочные типы. int является примитивным типом, а Integer-типом класса (который является своего рода ссылочным типом).
примитивные значения не разделяют состояние с другими примитивными значениями. Переменная, тип которой является примитивным типом, всегда содержит примитивное значение этого типа.
объект является динамически созданным экземпляром класса или массивом. Референсные значения (часто просто ссылки) являются указателями на эти объекты и специальной нулевой ссылкой, которая не относится ни к одному объекту. Причин может быть много ссылок на один и тот же объект.
также в Java все передается по значению. С объектами переданное значение является ссылкой на объект. Таким образом, другое различие между int и Integer в java-это то, как они передаются в вызовах методов. Например, в
переменная два передается как примитивное целое число тип 2. Тогда как в
переменная два передается как ссылка на объект, содержащий целое значение 2.
@WolfmanDragon: Пройти по ссылке будет работать так:
при вызове инкремента он передает ссылку (указатель) на переменную a. И инкремент функция непосредственно изменяет переменную a.
и для типов объектов, которые он будет работать, как следует:
теперь вы видите разницу?
лично я предпочитаю int, string, double и т. д. потому что они не требуют using System; утверждение 🙂 глупая причина, я знаю.
любая операция с примитивной переменной всегда возвращает новое значение. С другой стороны, объекты передаются по ссылке. Можно утверждать, что точка объекта (он же ссылка) также передается по значению, но содержимое не.
есть много причин использовать классы обертки:
на это уже ответили для Java, вот ответ C#:
тип int используется для объявления примитивной переменной
Integer используется для создания ссылочной переменной класса Integer
Java:
начиная с JDK 5, Java включила две очень полезные функции: автобоксинг и автобоксинг. Автобоксинг / распаковка значительно упрощает и упрощает код, который должен преобразовывать примитивные типы в объекты, и наоборот.
пример бокса / распаковки:
П. С. В Herbert Schildt был взят в качестве эталона.
еще одна вещь, которую я не вижу в предыдущих ответах: В Java примитивные классы-оболочки, такие как Integer, Double, Float, Boolean. и String предполагается инвариантным, так что при передаче экземпляра этих классов вызываемый метод никак не может изменить ваши данные, в opositión с большинством других классов, внутренние данные которых могут быть изменены его общедоступными методами. Так что у этих классов есть только методы «getter», никаких «сеттеров», кроме конструктора.
в строковые литералы программы java хранятся в отдельной части памяти кучи, только экземпляр для литерала, чтобы сохранить память, повторно используя эти экземпляры
но Integer-это класс-оболочка, который вы можете использовать для выполнения некоторых функций в переменной int (e.G преобразуйте его в строку или наоборот. ), но обратите внимание, что методы в классах-оболочках статичны, поэтому вы можете использовать их в любое время без создания экземпляра класса Integer. в качестве резюме:
x и y оба переменные типа int, но y обернуты целочисленным классом и имеют несколько методов,которые вы используете, но в случае, если вам нужно вызвать некоторые функции целочисленного класса-оболочки, вы можете сделать это просто.
но имейте в виду, что x и y являются corect, но если вы хотите использовать их как примитивный тип, используйте простую форму (используется для определения x).
переменная int содержит 32-разрядное целое число со знаком. Целое число (с заглавной буквы I) содержит ссылку на объект (класс) типа Integer или null.
Java автоматически бросает между ними; от Integer до int всякий раз, когда целочисленный объект возникает в качестве аргумента оператору int или присваивается переменной int, или значение int присваивается целочисленной переменной. Это кастинг называется бокс / распаковка.
Если целочисленная переменная, ссылающаяся на null unboxed, явно или неявно, создается исключение NullPointerException.
например:
а Integer является классом-оболочкой для примитивного типа данных, который имеет статические методы. Это может использоваться в качестве аргумента метода, который требует объекта, где As int может использоваться в качестве аргумента метода, который требует целочисленного значения, которое может использоваться для арифметического выражения.
например:
в отличие от Java, C# предоставляет целочисленные значения со знаком и без знака. Поскольку Java и C# являются объектно-ориентированными, некоторые операции на этих языках не сопоставляются непосредственно с инструкциями, предоставляемыми временем выполнения, и поэтому должны быть определены как часть объекта некоторого типа.
C# предоставляет System.Int32 который является типом значения, использующим часть памяти, принадлежащую ссылочному типу на куча.
в Java int type-примитивный тип данных, где в качестве Integer type-это объект.
в Java int является примитивным типом данных, в то время как Integer является вспомогательным классом, он используется для преобразования одного типа данных в другой.
примитивные типы данных хранят самую быструю доступную память, где вспомогательный класс сложен, и хранят в памяти heep.
ссылка из» David Gassner » Java Essential Training.
» int «является примитивным типом данных и» Integer » в классе оболочки в Java. «Integer «может использоваться в качестве аргумента метода, требующего объекта, где as» int » может использоваться в качестве аргумента метода, требующего целочисленного значения, которое может использоваться для арифметического выражения.
int предопределено в библиотечной функции c#, но в java мы можем создать объект Integer
(Версия Java) Простыми словами int является примитивным, а Integer-объектом-оболочкой для int.
один пример, где использовать Integer vs int, когда вы хотите сравнить и переменная int снова null, это вызовет ошибку.
01. Целое число может быть null. Но int не может быть null.
02. Только можно передать значения типов классов-оболочек в любой класс коллекции.
(Классы Оболочки-Boolean, Character, Byte, Short, Integer, Long, Float, Double)
но обычно мы добавляем примитивные значения в класс коллекции? Точка 02 правильно?
да 02 правильно, beacouse autoboxing.
Autoboxing автоматическое преобразование, которое делает компилятор java между примитивным типом и соответствующим классом-оболочкой.
затем 5 преобразовать в целое значение с помощью autoboxing.