В чем разница между int и Integer в Java и C#?
Я читал Больше Джоэла о программном обеспечении, когда натолкнулся на Джоэла Спольски, рассказывающего что-то о программисте определенного типа, который знает разницу int и Integer в Java/C# (объектно-ориентированные языки программирования).
Так в чем же разница?
28 ответов
В Java тип int является примитивом, а тип Integer является объектом.
В C# тип int такой же, как System.Int32 и является типом значения (т. е. больше похож на Java 'Int'). Целое число (так же, как и любые другие типы значений) может быть упаковано ("обернуто") в объект.
Различия между объектами и примитивами несколько выходят за рамки этого вопроса, но подведем итог:
Объекты предоставляют средства для полиморфизма, передаются по ссылке (или, точнее, имеют ссылки, переданные по значению) и выделяются из кучи. И наоборот, примитивы являются неизменяемыми типами, которые передаются по значению и часто выделяются из стека.
Ну, в Java int - это примитив, а 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 (хотя в C# она тоже есть). Я буду использовать только терминологию Java, потому что я более в этом разбираюсь.
Как сказано в ответах, int это просто число (называемое распакованным типом), тогда как Integer является объектом (который содержит число, следовательно, в штучной упаковке типа). В терминах Java это означает (кроме невозможности вызова методов на int), вы не можете хранить int или другие необъектные типы в коллекциях (List, Map, так далее.). Чтобы сохранить их, вы должны сначала упаковать их в соответствующий тип в штучной упаковке.
В Java 5 и более поздних версиях есть что-то, называемое auto-boxing и auto-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, обе версии генерируют идентичный байт-код. Таким образом, хотя автоматическая упаковка и автоматическая распаковка очень удобны, потому что вы пишете меньше кода, эти операции действительно выполняются за кулисами при тех же затратах времени выполнения, поэтому вы все равно должны знать об их существовании.
Надеюсь это поможет!
Я просто напишу здесь, так как некоторые другие сообщения немного неточны по отношению к C#.
Правильный: int это псевдоним для System.Int32,
Неправильно: float не псевдоним для System.Float, но для System.Single
По сути, int является зарезервированным ключевым словом в языке программирования C# и является псевдонимом для System.Int32 тип ценности.
float и Float, однако, не то же самое, что и правильный тип системы для ''float'' является System.Single. Есть некоторые типы, подобные этим, которые имеют зарезервированные ключевые слова, которые не соответствуют именам типов напрямую.
В C# нет разницы между ''int'' а также ''System.Int32'' или любые другие пары или ключевые слова / системные типы, за исключением случаев определения перечислений. С помощью перечислений вы можете указать размер хранилища для использования, и в этом случае вы можете использовать только зарезервированное ключевое слово, а не имя типа среды выполнения системы.
Будет ли значение в int храниться в стеке, в памяти или как объект кучи, на который ссылаются, зависит от контекста и того, как вы его используете.
Это объявление в методе:
int i;
определяет переменную i типа System.Int32, живущих в регистре или в стеке, в зависимости от оптимизации. Одно и то же объявление в типе (структура или класс) определяет поле члена. То же объявление в списке аргументов метода определяет параметр с теми же параметрами хранения, что и для локальной переменной. (обратите внимание, что этот абзац недействителен, если вы начнете использовать методы итератора в миксе, это совершенно разные звери)
Чтобы получить объект кучи, вы можете использовать бокс:
object o = i;
это создаст коробочную копию содержимого i в кучу. В IL вы можете получить доступ к методам объекта кучи напрямую, но в C# вам нужно привести его обратно к int, который создаст другую копию. Таким образом, объект в куче не может быть легко изменен в C# без создания новой коробочной копии нового значения int. (Тьфу, этот абзац не так легко читается.)
Относительно Java 1.5 и автобоксов существует важная "причуда", которая проявляется при сравнении объектов 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
Пока это возвращает ложь:
Integer i1 = new Integer(128);
Integer i2 = new Integer(128);
System.out.println(i1 == i2); // false
== сравнивает по ссылке (переменные указывают на один и тот же объект).
Этот результат может отличаться или не различаться в зависимости от того, какую JVM вы используете. Спецификация autoboxing для Java 1.5 требует, чтобы целые числа (от -128 до 127) всегда помещались в один и тот же объект-оболочку.
Решение? =) При сравнении объектов Integer всегда следует использовать метод Integer.equals().
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);
Переменная два передается как примитивный целочисленный тип 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);
Переменная два передается как ссылка на объект, который содержит целочисленное значение 2.
@WolfmanDragon: передача по ссылке будет работать так:
public void increment(int x) {
x = x + 1;
}
int a = 1;
increment(a);
// a is now 2
Когда вызывается приращение, он передает ссылку (указатель) на переменную a. И функция приращения напрямую изменяет переменную a.
А для типов объектов это будет работать следующим образом:
public void increment(Integer x) {
x = Integer.valueOf(x.intValue() + 1);
}
Integer a = Integer.valueOf(1);
increment(a);
// a is now 2
Вы видите разницу сейчас?
В C# int это просто псевдоним для System.Int32строка для System.Stringдвойной для System.Double так далее...
Лично я предпочитаю int, string, double и т. Д., Потому что они не требуют using System; Скажите:) Глупая причина, я знаю...
Есть много причин использовать классы-оболочки:
- Мы получаем дополнительное поведение (например, мы можем использовать методы)
- Мы можем хранить нулевые значения, тогда как в примитивах мы не можем
- Коллекции поддерживают хранение объектов, а не примитивов.
Джава:
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
}
}
Книга П.С. Герберта Шильдта была взята в качестве справочной.
Если вы когда-либо программировали до этого момента, то (int) является одним из примитивных типов, которые вы можете установить для своих переменных (например, char, float,...).
но Integer - это класс-оболочка, который вы можете использовать для выполнения некоторых функций над переменной int (например, преобразовать ее в строку или наоборот,...), но имейте в виду, что методы в классах-оболочках являются статическими, поэтому вы можете использовать их в любое время без создания экземпляра класса Integer. в качестве резюме:
int x;
Integer y;
x и y обе являются переменными типа int, но y упакован в класс Integer и имеет несколько используемых вами методов, но в случае, если вам нужно вызвать некоторые функции класса-оболочки Integer, вы можете сделать это просто.
Integer.toString(x);
но имейте в виду, что x и y являются corect, но если вы хотите использовать их просто как примитивный тип, используйте простую форму (используется для определения x).
В таких платформах, как Java, intс примитивами в то время как Integer это объект, который содержит целочисленное поле. Важным отличием является то, что примитивы всегда передаются по значению и по определению являются неизменными.
Любая операция с примитивной переменной всегда возвращает новое значение. С другой стороны, объекты передаются по ссылке. Можно утверждать, что точка на объект (AKA ссылка) также передается по значению, а содержимое - нет.
Еще одна вещь, которую я не вижу в предыдущих ответах: в Java примитивные классы-обертки, такие как Integer, Double, Float, Boolean... и String, предполагаются инвариантными, поэтому при передаче экземпляра этих классов вызываемый Метод не может каким-либо образом изменить ваши данные, в отличие от большинства других классов, чьи внутренние данные могут быть изменены его общедоступными методами. Так что в этих классах есть только методы "getter", но нет "setters", кроме конструктора.
В Java-программе строковые литералы хранятся в отдельной части динамической памяти, только для литерала, чтобы сэкономить память, многократно используя эти экземпляры.
Это уже было дано для Java, вот ответ C#:
"Integer" не является допустимым именем типа в C#, а "int" является просто псевдонимом для System.Int32. Кроме того, в отличие от Java (или C++), в C# нет специальных примитивных типов, каждый экземпляр типа в C# (включая 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;
}
int используется для объявления примитивной переменной
e.g. int i=10;
Integer используется для создания ссылочной переменной класса Integer
Integer a = new Integer();
На обоих языках (Java и C#) int 4-байтовое целое число со знаком.
В отличие от Java, C# предоставляет целые значения со знаком и без знака. Поскольку Java и C# являются объектно-ориентированными объектами, некоторые операции в этих языках не отображаются непосредственно на инструкции, предоставляемые во время выполнения, и поэтому должны быть определены как часть объекта некоторого типа.
C# обеспечивает System.Int32 который является типом значения, использующим часть памяти, которая принадлежит ссылочному типу в куче.
Ява обеспечивает java.lang.Integer который является ссылочным типом, работающим на int, Методы в Integer не может быть скомпилирован непосредственно для выполнения инструкций во время выполнения. Таким образом, мы упаковываем значение типа int для преобразования его в экземпляр Integer и используем методы, которые ожидают экземпляр некоторого типа (например, toString(), parseInt(), valueOf() так далее).
В C# переменная int относится к System.Int32.Any 4-байтовое значение в памяти может интерпретироваться как примитив int, которым можно манипулировать с помощью экземпляра System.Int32. Так что int является псевдонимом для System.Int32.When используя целочисленные методы, такие как int.Parse(), int.ToString() и т. д. Integer компилируется в FCL System.Int32 Структура вызова соответствующих методов, таких как Int32.Parse(), Int32.ToString(),
На Яве int тип является примитивным типом данных, где в качестве Integer Тип это объект.
В C# int Тип также тип данных, такой же, как System.Int32, integer (как и любые другие типы значений) может быть упакован ("обернут") в объект.
Переменная int содержит 32-разрядное целое число со знаком. Integer (с заглавной I) содержит ссылку на объект (класса) типа Integer или на ноль.
Java автоматически приводит между ними; от Integer до int всякий раз, когда объект Integer встречается в качестве аргумента оператора int или назначается переменной int, или значение int присваивается переменной Integer. Этот кастинг называется бокс / распаковка.
Если целочисленная переменная, ссылающаяся на null, является явной или неявной, без нее, создается исключение NullPointerException.
Int и Integer в Java и C# - это два разных термина, используемых для обозначения разных вещей. Это один из примитивных типов данных, который может быть назначен переменной, которая может хранить точно. Одно значение его объявленного типа за один раз.
Например:
int number = 7;
куда int это тип данных, присвоенный переменной номер, который содержит значение семь. Так что int это просто примитив, а не объект.
В то время как Integer класс-оболочка для примитивного типа данных, который имеет статические методы Это может быть использовано в качестве аргумента для метода, который требует объекта, где int может использоваться в качестве аргумента для метода, который требует целочисленного значения, которое можно использовать для арифметического выражения.
Например:
Integer number = new Integer(5);
В Java int это примитивный тип данных, в то время как Integer является классом Helper, он используется для преобразования одного типа данных в другой.
Например:
double doubleValue = 156.5d;
Double doubleObject = new Double(doubleValue);
Byte myByteValue = doubleObject.byteValue ();
String myStringValue = doubleObject.toString();
Примитивные типы данных хранят самую быструю доступную память, где класс Helper сложен, и хранятся в памяти heep.
ссылка от "David Gassner" Java Essential Training.
int предопределено в библиотечной функции C#, но в Java мы можем создать объект Integer
01. Целое число может быть нулевым. Но int не может быть нулевым.
Integer value1 = null; //OK
int value2 = null //Error
02. Только может передать значения типа Wrapper Classes любому классу коллекции.
(Классы Wrapper - 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 правильно, beacouse autoboxing.
Автобокс - это автоматическое преобразование, которое делает компилятор Java между типом примитива и соответствующим им классом-оболочкой.
Затем 5 конвертировать в целочисленное значение путем автобокса.
"int" - это примитивный тип данных и "Integer" в классе Wrapper в Java. "Integer" может использоваться в качестве аргумента для метода, который требует объекта, где "int" может использоваться в качестве аргумента для метода, который требует целочисленного значения, которое может использоваться для арифметического выражения.
Int является примитивным типом данных, тогда как Integer является объектом. Создание объекта с помощью Integer даст вам доступ ко всем методам, которые доступны в классе Integer. Но если вы создадите примитивный тип данных с помощью int, вы не сможете использовать эти встроенные методы, и вам придется определять их самостоятельно. Но если вам не нужны какие-либо другие методы и вы хотите повысить эффективность использования памяти программой, вы можете использовать примитивный тип данных, поскольку создание объекта увеличивает потребление памяти.
В Java согласно моим знаниям, если вы учитесь, то, когда вы пишете Int; Затем в Java-обобщенный будет скомпилировать код, как 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 как объекты.
В Java для хранения данных целочисленного типа используются как int, так и Integer, основное различие между ними состоит в том, что тип int является примитивным, а Integer имеет тип класса.
java: int - это примитивный тип данных, а Integer - это класс Wrapper. int, будучи примитивным типом данных, имеет меньшую гибкость. C #: Integer - это класс, а int - примитив. Благодаря автоматической упаковке вы можете создать объект Integer из int, но он все равно останется объектом.