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

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

Итак, в чем разница?

Ответов (25)

Решение

В Java тип int является примитивом, а тип Integer - объектом.

В C# тип int совпадает с типом значения System.Int32 и является типом значения (т. Е. Больше похож на java int). Целое число (как и любые другие типы значений) может быть упаковано («завернуто») в объект.


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

Объекты предоставляют возможности для полиморфизма, передаются по ссылке (или, точнее, имеют ссылки, переданные по значению) и выделяются из кучи . И наоборот, примитивы - это неизменяемые типы, которые передаются по значению и часто выделяются из стека .

int используется для объявления примитивной переменной

e.g. int i=10;

Целое число используется для создания ссылочной переменной класса Integer

Integer a = new Integer();

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

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

int x;
Integer y; 

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

Integer.toString(x);

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

В обоих языках (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, которым можно управлять с помощью экземпляра System.Int32.So int - это псевдоним для System.Int32.When использования методов, связанных с целыми числами, например int.Parse(), int.ToString() и т. Д. Integer компилируется в ГКЛ System.Int32 STRUCT вызывая соответствующие методы , такие как Int32.Parse(), Int32.ToString() .

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

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

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

Например:

int number = 7;

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

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

Например:

Integer number = new Integer(5);

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

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

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

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

Например:

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

Примитивные типы данных хранят самую быструю доступную память, а класс Helper сложен и хранятся в heep-памяти.

ссылка на "Основное обучение Java" Дэвида Гасснера.

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

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

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

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

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

Джава:

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

Double, Float, Long, Integer, Short, Byte, Character, И Boolean, относятся к типу Упаковщики, расфасованные в java.lang . Все оболочки числового типа определяют конструкторы, которые позволяют создавать объект из заданного значения или строкового представления этого значения. Использование объектов может добавить накладных расходов даже к самым простым вычислениям.

Начиная с JDK 5, Java включает в себя две очень полезные функции: автобоксинг и автоответчик. Autoboxing / unboxing значительно упрощает и оптимизирует код, который должен преобразовывать примитивные типы в объекты и наоборот.

Пример конструкторов:

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, так и Integer, основное различие между ними состоит в том, что тип int является примитивным, а Integer имеет тип класса.

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

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

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

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

Надеюсь это поможет!

В C# int - это просто псевдоним для System.Int32, string для System.String, double для и System.Double т. Д.

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

Ну, в 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 примитивное сравнение

Я просто опубликую здесь, поскольку некоторые другие сообщения немного неточны в отношении 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, вот ответ C#:

«Целое число» не является допустимым именем типа в 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;
}

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

В Java, Integer объекты со значениями -128 до 127 неизменны (то есть, для одного конкретного целого значения, скажем , 23, все объекты Integer экземпляр через программу со значением 23 указывает на точное же объекта).

Пример, это возвращает истину:

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 всегда следует использовать метод 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

Теперь вы видите разницу?

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

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

На таких платформах, как Java, int s являются примитивами, а 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...}