Ну, в 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 это просто псевдоним for System.Int32, string for System.String, double for и 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, относятся к типу Упаковщики, расфасованные в 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 или null.

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 против 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, вы не сможете использовать эти встроенные методы, и вам придется определять их самостоятельно. Но если вам не нужны какие-либо другие методы и вы хотите повысить эффективность использования памяти программой, вы можете использовать примитивный тип данных, поскольку создание объекта увеличивает потребление памяти.