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

Ну, в Java int является примитивом, в то время как целое число является объектом. Значение, если вы сделали новое целое число:

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, потому что я больше au fait С этим.

как упоминалось в ответах,int - это просто число (называемое неупакованное type), тогда как Integer является объектом (который содержит число, следовательно,коробочной type). В терминах Java это означает (помимо невозможности вызывать методы на int), вы не можете хранить int или другие типы объектов в коллекции (List, Map, etc.). Чтобы сохранить их, вы должны сначала упаковать их в соответствующий коробочный тип.

Java 5 и далее есть что-то под названием авто-бокс и авто-распаковка которые позволяют бокс / распаковку, чтобы быть сделано за кулисами. Сравнение и контраст: 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, обе версии генерируют идентичный байт-код. Таким образом, хотя авто-бокс и авто-распаковка очень удобны, потому что вы пишете меньше кода, эти операции do происходят за кулисами, с теми же затратами времени выполнения, поэтому вы все равно должны знать об их существовании.

надеюсь, что это помогает!

я просто опубликую здесь, так как некоторые из других сообщений немного неточны по отношению к c#.

правильно: int псевдоним System.Int32.
неправильно: float это не псевдоним System.Float, но и System.Single

в основном, int является зарезервированным ключевым словом на языке программирования C# и является псевдонимом для System.Int32 тип значения.

float и Float не совпадают, однако, как правильный тип системы для "float" система.Одиночный. Есть некоторые типы, подобные этому, которые зарезервировали ключевые слова, которые, похоже, не соответствуют именам типов напрямую.

в C# нет никакой разницы между"int" и "System.Int32", или любые другие пары или ключевые слова / системные типы, за исключением при определении перечислений. С помощью перечислений можно указать размер используемого хранилища, и в этом случае можно использовать только ключевое слово reserved, а не имя типа среды выполнения системы.

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

это объявление в методе:

int i;

определяет переменную i типа System.Int32, живущий в регистре или в стеке, в зависимости от оптимизации. Одно и то же объявление в типе (структуре или классе) определяет поле-член. То же объявление в списке аргументов метода определяет параметр с теми же параметрами хранения, что и для локального переменная. (обратите внимание, что этот абзац недействителен, если вы начинаете вытягивать методы итератора в микс, это разные звери)

чтобы получить объект кучи, вы можете использовать бокс:

object o = i;

это создаст коробочную копию содержимого i в куче. В IL вы можете получить доступ к методам объекта кучи напрямую, но в C# вам нужно вернуть его в int, который создаст другую копию. Таким образом, объект в куче не может быть легко изменен в C# без создания новой коробочной копии нового значения int. (Фу, этот абзац не так-то легко прочитать.)

относительно Java 1.5 и автоупаковка существует важная "причуда", которая появляется при сравнении целых объектов.

в Java целочисленные объекты со значениями от -128 до 127 неизменяемы (то есть для одного конкретного целочисленного значения, скажем, 23, все целочисленные объекты, созданные через вашу программу со значением 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

The == сравнивает по ссылке (указывает ли переменные на один и тот же объект).

этот результат может отличаться или не отличаться в зависимости от того, какую JVM вы используете. Спецификация autoboxing для Java 1.5 требует, чтобы целые числа (от -128 до 127) всегда вставлялись в один и тот же объект-оболочку.

решение? =) Всегда следует использовать целое число.метод 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 etc...

лично я предпочитаю int, string, double и т. д. потому что они не требуют using System; утверждение :) глупая причина, я знаю...

в таких платформах, как Java,ints являются примитивами в то время как Integer - объект, который содержит целое поле. Важное различие состоит в том, что примитивы всегда передаются по значению и по определению неизменны.

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

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

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:

int, double, long, byte, float, double, short, boolean, char - примитивы. Используется для хранения основных типов данных поддерживается языком. примитивные типы не являются частью иерархия объектов, и они не наследуют объект. Thet может пройти по ссылке на метод.

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
    }
}

пример автоупаковка/autounboxing:

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
    }
}

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

в строковые литералы программы java хранятся в отдельной части памяти кучи, только экземпляр для литерала, чтобы сохранить память, повторно используя эти экземпляры

вы когда-нибудь программировали до этого (int) - один из примитивных типов, которые вы можете установить для своих переменных (так же, как char, float,...).

но Integer-это класс-оболочка, который вы можете использовать для выполнения некоторых функций в переменной int (e.G преобразуйте его в строку или наоборот...), но обратите внимание, что методы в классах-оболочках статичны, поэтому вы можете использовать их в любое время без создания экземпляра класса Integer. в качестве резюме:

int x;
Integer y; 

x и y оба переменные типа int, но y обернуты целочисленным классом и имеют несколько методов,которые вы используете, но в случае, если вам нужно вызвать некоторые функции целочисленного класса-оболочки, вы можете сделать это просто.

Integer.toString(x);

но имейте в виду, что x и y являются corect, но если вы хотите использовать их как примитивный тип, используйте простую форму (используется для определения x).

переменная int содержит 32-разрядное целое число со знаком. Целое число (с заглавной буквы I) содержит ссылку на объект (класс) типа Integer или null.

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

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

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

например:

int number = 7;

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

а Integer является классом-оболочкой для примитивного типа данных, который имеет статические методы. Это может использоваться в качестве аргумента метода, который требует объекта, где As 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.Any 4-байтовое значение в памяти можно интерпретировать как примитивный int, которым можно манипулировать экземпляром Система.Int32.Таким образом, int-это псевдоним для System.Int32.When использование методов, связанных с целыми числами, таких как int.Parse(), int.ToString() etc. Целое число компилируется в FCL System.Int32 struct вызывает соответствующие методы, такие как Int32.Parse(), Int32.ToString().

в Java int type-примитивный тип данных, где в качестве Integer type-это объект.

в C#int type также является типом данных, таким же, как System.Int32. Ан integer (как и любые другие типы значений) могут быть упакованы ("обернуты") в объект.

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

например:

double doubleValue = 156.5d;
Double doubleObject  = new Double(doubleValue);
Byte myByteValue = doubleObject.byteValue ();
String myStringValue = doubleObject.toString();

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

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...}

01. Целое число может быть null. Но int не может быть null.

Integer value1 = null; //OK

int value2 = null      //Error

02. Только можно передать значения типов классов-оболочек в любой класс коллекции.

(Классы Оболочки-Boolean, Character, Byte, Short, Integer, Long, Float, Double)

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.

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

затем 5 преобразовать в целое значение с помощью autoboxing.

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