В чем разница между int и Integer в Java и C #?

Я читал « Больше Джоэла о программном обеспечении», когда натолкнулся на то, что Джоэл Спольски что-то говорил о программистах определенного типа, знающих разницу между intи Integerв Java / C # (объектно-ориентированных языках программирования).

Так в чем же разница?

В 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, это самый близкий ответ. Надеюсь это поможет!

Целочисленный объект javadoc

Целочисленное сравнение Ojbect и int примитивное

Я добавлю к превосходным ответам, приведенным выше, и расскажу о боксе и распаковке, и о том, как это применимо к Java (хотя в C # она тоже есть). Я буду использовать только терминологию Java, потому что я более в этом разбираюсь .

Как уже упоминалось в ответах, intэто просто число (называемое unboxed типом), тогда 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;утверждения :) Глупая причина, я знаю ...

Есть много причин использовать классы-оболочки:

1. Мы получаем дополнительное поведение (например, мы можем использовать методы)
2. Мы можем хранить нулевые значения, тогда как в примитивах мы не можем
3. Коллекции поддерживают хранение объектов, а не примитивов.

Это уже было дано для 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, ints - это примитивы, а Integerобъект - это целочисленное поле. Важным отличием является то, что примитивы всегда передаются по значению и по определению являются неизменными.

Любая операция с примитивной переменной всегда возвращает новое значение. С другой стороны, объекты передаются по ссылке. Можно утверждать, что точка на объект (AKA ссылка) также передается по значению, а содержимое - нет.

Еще одна вещь, которую я не вижу в предыдущих ответах: в Java примитивные классы-обертки, такие как Integer, Double, Float, Boolean ... и String, предполагаются инвариантными, поэтому при передаче экземпляра этих классов вызываемый Метод не может каким-либо образом изменить ваши данные, в отличие от большинства других классов, чьи внутренние данные могут быть изменены его открытыми методами. Так что в этих классах есть только методы «getter», но нет «setters», кроме конструктора.

В 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, относятся к типу Wrappers, упакованы в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 содержит 32-разрядное целое число со знаком. Integer (с заглавной I) содержит ссылку на объект (класса) типа Integer или на ноль.

Java автоматически приводит между ними; от Integer до int всякий раз, когда объект Integer встречается в качестве аргумента оператора int или назначается переменной int, или значение int присваивается переменной Integer. Этот кастинг называется бокс / распаковка.

Если целочисленная переменная, ссылающаяся на null, является явной или неявной, без нее, создается исключение NullPointerException.

Int и Integer в Java и C # - это два разных термина, используемых для обозначения разных вещей. Это один из примитивных типов данных, который может быть назначен переменной, которая может хранить точно. Одно значение его объявленного типа за один раз.

Например:

int number = 7;

Где intтип данных, назначенный переменной номер, который содержит значение семь. Так что intэто просто примитив, а не объект.

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

Например:

Integer number = new Integer(5);

На обоих языках (Java и C #) intиспользуется 4-байтовое целое число со знаком.

В отличие от Java, C # предоставляет целые значения со знаком и без знака. Поскольку Java и C # являются объектно-ориентированными объектами, некоторые операции в этих языках не отображаются непосредственно на инструкции, предоставляемые во время выполнения, и поэтому должны быть определены как часть объекта некоторого типа.

C # обеспечивает System.Int32 тип значения, использующий часть памяти, принадлежащую ссылочному типу в куче.

Java предоставляет, java.lang.Integerкоторый является ссылочным типом, работающим на int. Методы в Integerне могут быть скомпилированы напрямую для выполнения инструкций во время выполнения. Таким образом, мы упаковываем значение int для преобразования его в экземпляр Integer и используем методы, которые ожидают экземпляр некоторого типа (например toString(), parseInt()и valueOf()т. Д.).

В C # переменная int относится к System.Int32.Any4-байтовому значению в памяти и может интерпретироваться как примитив int, которым можно манипулировать с помощью экземпляра System.Int32. Так что int - это псевдоним для System.Int32.Whenиспользования целочисленных методов, таких как int.Parse(), int.ToString()и т. Д. Integer компилируется в ГКЛ System.Int32STRUCT вызывая соответствующие методы , такие как Int32.Parse(), Int32.ToString().

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

В C # 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.

ссылка от "David Gassner" Java Essential Training.

«int» - это примитивный тип данных и «Integer» в классе Wrapper в Java. «Integer» может использоваться в качестве аргумента для метода, который требует объекта, где «int» может использоваться в качестве аргумента для метода, который требует целочисленного значения, которое может использоваться для арифметического выражения.

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 правильно, beacouse autoboxing.

Автобокс - это автоматическое преобразование, которое делает компилятор Java между типом примитива и соответствующим им классом-оболочкой.

Затем 5 конвертировать в целочисленное значение путем автобокса.

int предопределено в библиотечной функции c #, но в Java мы можем создать объект Integer

(Java версия) В простых словах int является примитивным, а Integer является объектом-оболочкой для int.

Один пример, где использовать Integer vs 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...}

В Java согласно моим знаниям, если вы учитесь, то, когда вы пишете Int; то в Java родового будет компилировать код , как Integer a = new Integer(). Так что согласно дженерикам Integerне используется, а intиспользуется. так что там такая разница.

int является примитивным типом данных. Integer - это класс-оболочка. Он может хранить данные int как объекты.

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