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

08-06-2019
|

Вопрос

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

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

Решение

На Яве, тип int является примитивом, тогда как тип Integer является объектом.

В С#, тип '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 — это необычный способ работы с целым числом (точно так же, как, возможно, String — это необычный способ работы с группой символов).

Я знаю, что Java — это не C, но, поскольку я никогда не программировал на C, это самый близкий ответ, который я мог бы найти.Надеюсь это поможет!

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

Целочисленный объект против.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.
Неправильный: 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 и автобокс есть важная «причуда», которая возникает при сравнении целочисленных объектов.

В 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

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

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

Решение?=) При сравнении целочисленных объектов всегда следует использовать метод 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

Когда вызывается приращение, оно передает ссылку (указатель) на переменную. а.И приращение функция напрямую изменяет переменную а.

А для типов объектов это будет работать следующим образом:

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; заявление :) Глупая причина, я знаю...

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

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

На этот вопрос уже был дан ответ для Java, вот ответ С#:

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

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

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

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

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

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

int x;
Integer y;

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

Integer.toString(x);

но имейте в виду, что и x, и y являются правильными, но если вы хотите использовать их просто как примитивный тип, используйте простую форму (используемую для определения 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
    }
}

P.S.В качестве справочника была взята книга Герберта Шилдта.

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

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

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

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

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

Например:

int number = 7;

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

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

На Яве int тип — это примитивный тип данных, где, как Integer тип — это объект.

В 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();

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

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

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

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

Integer value1 = null; //OK

int value2 = null      //Error

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

(Классы-оболочки — логическое значение, символ, байт, короткое, целое, длинное, с плавающей запятой, двойное)

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 правильный, потому что autoboxing.

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

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

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

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

Один из примеров использования Integer vs int. Когда вы хотите снова сравнить переменную int с нулевым значением, это выдаст ошибку.

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 a;тогда в Java Generic он скомпилирует код типа Integer a = new Integer().Итак, согласно дженерикам Integer не используется, но int используется.так вот там такая разница.

Лицензировано под: CC-BY-SA с атрибуция

Не связан с StackOverflow