Я читал " Больше Джоэла о программном обеспечении", когда натолкнулся на то, что Джоэл Спольски что-то говорил о конкретном типе программиста, знающего разницу между int и Integer в Java/С# (объектно-ориентированные языки программирования).
Так в чем же разница?
В Java тип 'int' является примитивным, тогда как тип Integer является объектом.
В С#, тип 'int' совпадает с System.Int32 и тип значения ( т.е. больше похоже на java 'int'). Целое число (как и любые другие типы значений) может быть в коробке ( "завернуто" ) в объект.
Различия между объектами и примитивами несколько выходят за рамки этого вопроса, но суммируют:
Объекты предоставляют средства для полиморфизма, передаются по ссылке (или, точнее, имеют ссылки, переданные по значению) и выделяются из куча. И наоборот, примитивы являются неизменяемыми типами, которые передаются по значению и часто выделяются из stack.
Ну, в Java int является примитивным, а Integer - объектом. Значение, если вы создали новый Integer:
Integer i = new Integer(6);
Вы можете вызвать некоторый метод для i:
String s = i.toString();//sets s the string representation of i
В то время как с int:
int i = 6;
Вы не можете вызывать на нем какие-либо методы, потому что это просто примитив. Итак:
String s = i.toString();//will not work!!!
приведет к ошибке, потому что int не является объектом.
int является одним из немногих примитивов в Java (наряду с char и некоторыми другими). Я не уверен на 100%, но я думаю, что объект Integer более или менее имеет свойство int и целую кучу методов для взаимодействия с этим свойством (например, метод toString()). Таким образом, Integer является причудливым способом работы с int (так же, как возможно, String - это причудливый способ работы с группой символов).
Я знаю, что Java не является C, но поскольку я никогда не программировал в C, это самое близкое, что я мог бы прийти к ответу. Надеюсь, это поможет!
Я добавлю к превосходным ответам, приведенным выше, и расскажу о боксе и распаковке, и как это относится к Java (хотя у С# тоже есть). Я буду использовать только терминологию Java, потому что я более уверен в этом.
Как упоминалось в ответах, int - это просто номер (называемый unboxed type), тогда как Integer - это объект (который содержит число, следовательно, тип в виде коробочного типа). В терминах Java это означает (кроме того, что вы не можете вызывать методы на int), вы не можете хранить int или другие типы не-объектов в коллекциях (List, Map и т.д.). Чтобы сохранить их, вы должны сначала разместить их в соответствующем поле в коробке.
На Java 5 есть нечто вроде автоматического бокса и автоматического распаковки, которые позволяют делать бокс /unboxing за кулисами. Сравнение и отличие: версия Java 5:
Deque<Integer> queue;
void add(int n) {
queue.add(n);
}
int remove() {
return queue.remove();
}
Java 1.4 или ранее (без дженериков):
Deque queue;
void add(int n) {
queue.add(Integer.valueOf(n));
}
int remove() {
return ((Integer) queue.remove()).intValue();
}
Следует отметить, что, несмотря на краткость версии Java 5, обе версии генерируют одинаковый байт-код. Таким образом, хотя автоматическое боксирование и автоматическая распаковка очень удобны, потому что вы пишете меньше кода, эти операции происходят за кулисами с одинаковыми затратами времени выполнения, поэтому вам все равно нужно знать о их существовании.
Надеюсь, это поможет!
Я просто опубликую здесь, так как некоторые другие сообщения немного неточны по отношению к С#.
Правильно: int является псевдонимом для System.Int32.
Неверно: float не является псевдонимом для System.Float, но для System.Single
В принципе, int является зарезервированным ключевым словом на языке программирования С# и является псевдонимом для типа значения System.Int32.
float и Float не совпадают, так как правильный тип системы для '' float '' - System.Single. Существуют такие типы, которые содержат зарезервированные ключевые слова, которые, по-видимому, не соответствуют именам типов напрямую.
В С# нет разницы между '' int '' и '' System.Int32 '' или любой другой пар или ключевыми словами/системными типами, за исключением тех случаев, когда заданы перечисления. С перечислениями вы можете указать размер хранилища для использования, и в этом случае вы можете использовать только зарезервированное ключевое слово, а не имя типа рабочей среды.
Wether значение в int будет храниться в стеке, в памяти или в качестве ссылочного объекта кучи зависит от контекста и того, как вы его используете.
Это объявление в методе:
int i;
определяет переменную i типа System.Int32, живущую в регистре или в стеке, в зависимости от оптимизации. Такое же объявление в типе (struct или class) определяет поле члена. Такая же декларация в списке аргументов метода определяет параметр с теми же параметрами хранения, что и для локальной переменной. (обратите внимание, что этот параграф недействителен, если вы начинаете вытягивать методы итератора в микс, это совсем другие животные)
Чтобы получить объект кучи, вы можете использовать бокс:
object o = i;
это создаст коробочную копию содержимого i в куче. В IL вы можете напрямую обращаться к методам объекта кучи, но на С# вам нужно вернуть его обратно в int, который создаст другую копию. Таким образом, объект в куче не может быть легко изменен на С# без создания новой вставной копии нового значения int. (Ugh, этот абзац не читает все это легко.)
В отношении Java 1.5 и autoboxing существует важная "причуда", которая появляется при сравнении объектов Integer.
В Java объекты Integer со значениями от -128 до 127 неизменяемы (то есть для одного определенного целочисленного значения, скажем, 23, все объекты Integer, созданные через вашу программу со значением 23, указывают на тот же объект).
Например, это возвращает true:
Integer i1 = new Integer(127);
Integer i2 = new Integer(127);
System.out.println(i1 == i2); // true
Пока это возвращает false:
Integer i1 = new Integer(128);
Integer i2 = new Integer(128);
System.out.println(i1 == i2); // false
Параметр == сравнивается по ссылке (переменные указывают на один и тот же объект).
Этот результат может отличаться в зависимости от того, какой JVM вы используете. Автобоксирование спецификации для Java 1.5 требует, чтобы целые числа (от -128 до 127) всегда были привязаны к одному и тому же оберточному объекту.
Решение? =) Всегда нужно использовать метод Integer.equals() при сравнении объектов Integer.
System.out.println(i1.equals(i2)); // true
Дополнительная информация на java.net Пример bexhuff.com
В Java есть два основных типа в JVM. 1) примитивные типы и 2) ссылочные типы. int - примитивный тип, а Integer - тип класса (который является типом ссылочного типа).
Примитивные значения не разделяют состояние с другими примитивными значениями. Переменная, тип которой является примитивным типом, всегда содержит примитивное значение этого типа.
int aNumber = 4;
int anotherNum = aNumber;
aNumber += 6;
System.out.println(anotherNum); // Prints 4
Объект - это динамически созданный экземпляр класса или массив. Референтные значения (часто просто ссылки) являются указателями на эти объекты и специальной нулевой ссылкой, которая не относится к объекту. Может быть много ссылок на один и тот же объект.
Integer aNumber = Integer.valueOf(4);
Integer anotherNumber = aNumber; // anotherNumber references the
// same object as aNumber
Также в Java все передается по значению. С объектами переданное значение является ссылкой на объект. Таким образом, другая разница между int и Integer в java заключается в том, как они передаются в вызовах методов. Например, в
public int add(int a, int b) {
return a + b;
}
final int two = 2;
int sum = add(1, two);
Переменная two передается как примитивный целочисленный тип 2. Если в
public int add(Integer a, Integer b) {
return a.intValue() + b.intValue();
}
final Integer two = Integer.valueOf(2);
int sum = add(Integer.valueOf(1), two);
Переменная two передается как ссылка на объект, который содержит целочисленное значение 2.
@WolfmanDragon: Передача по ссылке будет работать так:
public void increment(int x) {
x = x + 1;
}
int a = 1;
increment(a);
// a is now 2
Когда приращение называется, оно передает ссылку (указатель) на переменную a. И функция increment непосредственно изменяет переменную a.
И для типов объектов он будет работать следующим образом:
public void increment(Integer x) {
x = Integer.valueOf(x.intValue() + 1);
}
Integer a = Integer.valueOf(1);
increment(a);
// a is now 2
Вы видите разницу сейчас?
В С# int - это просто псевдоним для System.Int32, строка для System.String, double для System.Double и т.д.
Лично я предпочитаю int, string, double и т.д., потому что они не требуют оператора using System;:) Глупый разум, я знаю...
Существует множество причин использования классов-оболочек:
Это уже ответили на Java, здесь ответ С#:
"Целое число" не является допустимым именем типа в С#, а "int" является просто псевдонимом для System.Int32. Кроме того, в отличие от Java (или С++) в С# нет каких-либо специальных примитивных типов, каждый экземпляр типа в С# (включая int) является объектом. Вот какой-то демонстративный код:
void DoStuff()
{
System.Console.WriteLine( SomeMethod((int)5) );
System.Console.WriteLine( GetTypeName<int>() );
}
string SomeMethod(object someParameter)
{
return string.Format("Some text {0}", someParameter.ToString());
}
string GetTypeName<T>()
{
return (typeof (T)).FullName;
}
В таких платформах, как Java, int являются примитивами, а Integer - объектом, который содержит целое поле. Важным отличием является то, что примитивы всегда передаются по значению и по определению неизменяемы.
Любая операция с примитивной переменной всегда возвращает новое значение. С другой стороны, объекты передаются по ссылке. Можно утверждать, что точка к объекту (ссылка AKA) также передается по значению, но содержимое не является.
int используется для объявления примитивной переменной
e.g. int i=10;
Целое используется для создания ссылочной переменной класса Integer
Integer a = new Integer();
Еще одна вещь, которую я не вижу в предыдущих ответах: В Java классы примитивных оболочек, такие как Integer, Double, Float, Boolean... и String, считаются инвариантными, так что, когда вы передаете экземпляр этих классов, вызываемый метод не может каким-либо образом изменить ваши данные, в opositión с большинством других классов, которые внутренние данные могут быть изменены его общедоступными методами. Так что у этих классов есть только методы "getter", а не "сеттеры", кроме конструктора.
В java-программе строковые литералы хранятся в отдельной части памяти кучи, только экземпляр для литерала, чтобы сохранить повторное использование этих экземпляров
Вы когда-либо программировали до этого (int) - это один из примитивных типов, которые вы можете установить для своих переменных (например, char, float,...).
но Integer - это класс-оболочка, который вы можете использовать для выполнения некоторых функций в переменной int (например, преобразовать ее в строку или наоборот), но обратите внимание, что методы в классах-оболочках являются статическими, поэтому вы могут использовать их в любое время без создания экземпляра класса Integer. в качестве примера:
int x;
Integer y;
x и y являются обе переменными типа int, но y обертывается классом Integer и имеет несколько методов, которые вы используете, но если вам нужно вызвать некоторые функции класса обертки Integer, вы можете сделать это просто.
Integer.toString(x);
но имейте в виду, что оба x и y являются corect, но если вы хотите использовать их как примитивный тип, используйте простую форму (используемую для определения x).
Джава:
int, double, long, byte, float, double, short, boolean, char - примитивы. Используется для хранения основных типов данных, поддерживаемых языком. примитивные типы не являются частью иерархии объектов и не наследуют объект. Это нельзя передать ссылкой на метод.
Double, Float, Long, Integer, Short, Byte, Character и Boolean - это оболочки типа, упакованные в java.lang. Все оболочки числовых типов определяют конструкторы, которые позволяют объекту быть построенным из данного значения или строкового представления этого значения. Использование объектов может добавить накладные расходы даже к самым простым расчетам.
Начиная с JDK 5, Java включала в себя две очень полезные функции: автоматическую коробку и автоматическую коробку. Автобокс/распаковка значительно упрощает и оптимизирует код, который должен преобразовывать примитивные типы в объекты, и наоборот.
Пример конструкторов:
Integer(int num)
Integer(String str) throws NumberFormatException
Double(double num)
Double(String str) throws NumberFormatException
Пример упаковки/распаковки:
class ManualBoxing {
public static void main(String args[]) {
Integer objInt = new Integer(20); // Manually box the value 20.
int i = objInt.intValue(); // Manually unbox the value 20
System.out.println(i + " " + iOb); // displays 20 20
}
}
Пример автобокса/автобокса:
class AutoBoxing {
public static void main(String args[]) {
Integer objInt = 40; // autobox an int
int i = objInt ; // auto-unbox
System.out.println(i + " " + iOb); // displays 40 40
}
}
PS Книга Герберта Шильдта была взята в качестве справочной.
В обоих языках (Java и С#) int - 4-байтовое целое число со знаком.
В отличие от Java, С# Обеспечивает как целочисленные, так и беззнаковые значения. Поскольку Java и С# объектно-ориентированные объекты, некоторые операции на этих языках не отображаются непосредственно на инструкции, предоставляемые временем выполнения, поэтому их необходимо определить как часть объекта определенного типа.
С# предоставляет System.Int32, который является типом значения, используя часть памяти, принадлежащую ссылочному типу в куче.
java предоставляет java.lang.Integer, который является ссылочным типом, работающим на int. Методы в Integer не могут быть скомпилированы непосредственно для выполнения инструкций времени выполнения. Таким образом, мы помещаем значение int, чтобы преобразовать его в экземпляр Integer и использовать методы, которые ожидают экземпляр какого-либо типа (например, toString(), parseInt(), valueOf() и т.д.).
В С# переменная int относится к System.Int32.Any 4-байтовое значение в памяти может быть интерпретировано как примитивный int, который может быть обработан экземпляром System.Int32.So int является псевдонимом для System.Int32.When с использованием целочисленных методы, такие как int.Parse(), int.ToString() и т.д. Integer скомпилирован в структуру FCL System.Int32, вызывающую соответствующие методы, такие как Int32.Parse(), Int32.ToString().
int и Integer в Java и С# - это два разных термина, используемых для представления разных вещей. Это один из примитивных типов данных, которые могут быть назначены переменной, которая может хранить точно. Одно значение его объявленного типа за раз.
Например:
int number = 7;
Где int - тип данных, присвоенный номеру переменной, который содержит значение семь. Таким образом, int - это просто примитив, а не объект.
Пока Integer является классом-оболочкой для примитивного типа данных, который имеет статические методы. Это можно использовать в качестве аргумента для метода, который требует объект, где, поскольку int может использоваться как аргумент метода, который требует целочисленного значения, которое может использоваться для арифметического выражения.
Например:
Integer number = new Integer(5);
Переменная int содержит 32-значное целое число со знаком. Целое число (с капиталом I) содержит ссылку на объект типа (класса) Integer или null.
Java автоматически отбрасывает между ними; от Integer до int всякий раз, когда объект Integer возникает как аргумент для оператора int или присваивается переменной int, или значение int присваивается переменной Integer. Это литье называется бокс/распаковка.
Если переменная Integer, ссылающаяся на null, распаковывается, явно или неявно, генерируется исключение NullPointerException.
В Java тип int является примитивным типом данных, где, поскольку тип Integer является объектом.
В С# тип int также является типом данных, похожим на System.Int32. Integer (как и любые другие типы значений) может быть помещен в коробку ( "завернут" ) в объект.
В Java int является примитивным типом данных, в то время как Integer является классом Helper, используется преобразование для одного типа данных в другое.
Например:
double doubleValue = 156.5d;
Double doubleObject = new Double(doubleValue);
Byte myByteValue = doubleObject.byteValue ();
String myStringValue = doubleObject.toString();
Примитивные типы данных хранят самую быструю доступную память, где класс Helper является сложным и хранится в памяти heep.
ссылка на "Java Essential Training" Дэвида Гасснера.
"int" - это примитивный тип данных и "Integer" в классе Wrapper в Java. "Целое число" может использоваться в качестве аргумента для метода, который требует объекта, где "int" может использоваться как аргумент метода, который требует целочисленного значения, которое может использоваться для арифметического выражения.
int предопределен в библиотечной функции С#, но в Java мы можем создать объект Integer
01. Целое число может быть нулевым. Но int не может быть нулевым.
Integer value1 = null; //OK
int value2 = null //Error
02. Только может передать значения типа Wrapper Classes любому классу коллекции.
(Wrapper Classes - Boolean, Символ, Байт, Короткое, Целое, Длинное, Плавающее, Двойное)
List<Integer> element = new ArrayList<>();
int valueInt = 10;
Integer valueInteger = new Integer(value);
element.add(valueInteger);
Но обычно мы добавляем примитивные значения в класс коллекции? Точка 02 верна?
List<Integer> element = new ArrayList<>();
element.add(5);
Да, 02 верный, из-за autoboxing.
Автобокс - это автоматическое преобразование, которое делает компилятор Java между типом примитива и соответствующим им классом-оболочкой.
Затем 5 конвертировать в целочисленное значение путем автобокса.
В Java согласно моим знаниям, если вы учитесь, то, когда вы пишете Int; тогда в java generic он скомпилирует код, такой как Integer a = new Integer(). Таким образом, в общем случае Integer не используется, но используется int. так что там такая разница.
(Java версия) В простых словах int является примитивным, а Integer является объектом-оболочкой для int.
Один пример, где использовать Integer против int. Когда вы захотите сравнить переменную int и переменную null снова, будет выдано сообщение об ошибке.
int a;
//assuming a value you are getting from data base which is null
if(a ==null) // this is wrong - cannot compare primitive to null
{
do something...}
Instead you will use,
Integer a;
//assuming a value you are getting from data base which is null
if(a ==null) // this is correct/legal
{ do something...}
int является примитивным типом данных. Integer - это класс-оболочка. Он может хранить данные int как объекты.
int является примитивным типом данных, тогда как Integer является объектом. Создание объекта с помощью Integer даст вам доступ ко всем методам, которые доступны в классе Integer. Но если вы создадите примитивный тип данных с помощью int, вы не сможете использовать эти встроенные методы, и вам придется определять их самостоятельно. Но если вам не нужны какие-либо другие методы и вы хотите повысить эффективность использования памяти программой, вы можете использовать примитивный тип данных, поскольку создание объекта увеличивает потребление памяти.