My<cod/>.net
В чем разница между int и целым числом в Java и C#?
Я читал больше Джоэла о программном обеспечении, когда наткнулся на Джоэла Сполски , говорящего что-то о конкретном типе программиста, знающего разницу между int и Integer в Java/C# (объектно-ориентированные языки программирования).
Так в чем же разница?
В Java тип 'int' является примитивом, а тип 'Integer'-объектом.
В C#, тип 'int' совпадает с типом System.Int32 и является типом значения (т. е. больше похож на java 'int'). Целое число (как и любые другие типы значений) может быть вставлено в объект ( "wrapped" ).
Различия между объектами и примитивами несколько выходят за рамки этого вопроса, но подводя итог:
Объекты предоставляют средства для полиморфизма, передаются по ссылке (или точнее имеют ссылки, передаваемые по значению) и выделяются из кучи . И наоборот, примитивы -это неизменяемые типы, которые передаются по значению и часто выделяются из стека .
Ну, в 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%, но я думаю, что целочисленный объект более или менее просто имеет свойство int и целую кучу методов для взаимодействия с этим свойством (например, метод toString()). Таким образом, Integer-это причудливый способ работы с int (так же, как, возможно, String-это причудливый способ работы с группой символов).
Я знаю, что Java-это не C, но поскольку я никогда не программировал в C, это самое близкое, что я мог бы найти. Надеюсь, это поможет!
Целое число объекта документации
Число Ojbect и int примитивное сравнение
Я добавлю к отличным ответам, приведенным выше, и расскажу о боксе и распаковке, и как это относится к Java (хотя у C# тоже есть). Я использую только Java терминологию, потому что я больше au fait с этим.
Как уже упоминалось в ответах, int -это просто число (так называемый распакованный тип), тогда как 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", или любой из других пар или ключевых слов/системных типов, кроме как при определении enums. С помощью параметра enums можно указать размер используемого хранилища,и в этом случае можно использовать только ключевое слово reserved, а не имя типа среды выполнения system.
Будет ли значение int сохранено в стеке, в памяти или в виде объекта кучи со ссылкой, зависит от контекста и способа его использования.
Это объявление в методе:
int i;
определяет переменную i типа System.Int32, живущую в регистре или в стеке, в зависимости от оптимизаций. Одно и то же объявление в типе (структуре или классе) определяет поле члена. Одно и то же объявление в списке аргументов метода определяет параметр с теми же параметрами хранения, что и для локальной переменной. (обратите внимание, что этот абзац не является допустимым, если вы начинаете вытягивать методы итератора в смесь, это совершенно разные звери)
Чтобы получить объект кучи, можно использовать бокс:
object o = i;
это создаст коробочную копию содержимого i в куче. В IL вы можете получить доступ к методам объекта кучи напрямую, но в C# вам нужно привести его обратно к int, который создаст другую копию. Таким образом, объект в куче не может быть легко изменен в C# без создания новой коробочной копии нового значения int. (Фу, этот абзац не так-то легко читается.)
Что касается Java 1.5 и autoboxing , то есть важный "quirk", который играет при сравнении целых объектов.
В 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) всегда вставлялись в один и тот же объект-оболочку.
Какое-то решение? = ) При сравнении целочисленных объектов всегда следует использовать метод 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
Объект-это динамически создаваемый экземпляр класса или массив. Ссылочные значения (часто просто ссылки) являются указателями на эти объекты и специальной ссылкой null, которая не ссылается ни на один объект. Может быть много ссылок на один и тот же объект.
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);
Переменная 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);
Переменная two передается как ссылка на объект, который содержит целое значение 2.
@WolfmanDragon: Pass by reference будет работать примерно так:
public void increment(int x) {
x = x + 1;
}
int a = 1;
increment(a);
// a is now 2
При вызове инкремента он передает ссылку (указатель) на переменную a . И приращения функции непосредственно изменяет переменную .
А для типов объектов это будет работать следующим образом:
public void increment(Integer x) {
x = Integer.valueOf(x.intValue() + 1);
}
Integer a = Integer.valueOf(1);
increment(a);
// a is now 2
Теперь вы видите разницу?
В таких платформах, как Java, int s являются примитивами, а Integer -объектом, который содержит целое поле. Важное различие заключается в том, что примитивы всегда передаются по значению и по определению являются неизменными.
Любая операция, включающая примитивную переменную, всегда возвращает новое значение. С другой стороны, объекты передаются по ссылке. Можно было бы возразить, что точка на объект (AKA ссылка) также передается по значению, но содержание не передается.
На это уже был дан ответ для 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;
}
Еще одна вещь, которую я не вижу в предыдущих ответах: В Java примитивных классов фантики, как целое число, вещественное число вещественное, логическое... а строки считаются инвариантными, так что при передаче экземпляра этих классов вызываемый метод никак не может изменить ваши данные, в отличие от большинства других классов, внутренние данные которых могут быть изменены его открытыми методами. Так что этот класс имеет только 'getter' методов, но не 'setters', кроме конструктора.
В программе java строковые литералы хранятся в отдельной части памяти кучи, только экземпляр для литерала, чтобы сохранить память, повторно использующую эти экземпляры
вы когда-нибудь программировали до этого (int) - это один из примитивных типов, которые вы можете установить для своих переменных (например, char, float,...).
но Integer-это класс-оболочка, который можно использовать для выполнения некоторых функций над переменной int (например, преобразовать ее в строку или наоборот,...), но имейте в виду, что методы в классах-оболочках являются статическими, поэтому вы можете использовать их в любое время, не создавая экземпляр целого класса. в качестве резюме :
int x;
Integer y;
x и y-это переменные типа int, но y обернут целочисленным классом и имеет несколько методов,которые вы используете, но в случае, если вам нужно вызвать некоторые функции класса Integer wrapper, вы можете сделать это просто.
Integer.toString(x);
но имейте в виду, что и x, и y-это corect, но если вы хотите использовать их только как примитивный тип, используйте простую форму (используется для определения x).
Java :
int , double , long , byte , float , double , short , boolean , char - примитивы. Используется для хранения основных типов данных
поддерживается языком. примитивные типы не являются частью
иерархия объектов, и они не наследуют объект. Это может быть передано по ссылке на метод.
Double , Float , Long , Integer , Short , Byte , Character , а Boolean - это типовые обертки, упакованные в java.lang . Все оболочки числовых типов определяют конструкторы, позволяющие создавать объект из заданного значения или строкового представления этого значения.
Использование объектов может добавить накладные расходы даже к самым простым вычислениям.
Начиная с JDK 5, Java включил две очень полезные функции: автоупаковка и autounboxing. Автобоксинг / распаковка значительно упрощает и упрощает код, который должен преобразовывать примитивные типы в объекты, и наоборот.
Пример конструкторов:
Integer(int num)
Integer(String str) throws NumberFormatException
Double(double num)
Double(String str) throws NumberFormatException
Пример boxing/unboxing:
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
}
}
Пример autoboxing/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
}
}
P.S. В качестве примера была взята книга Герберта Шильдта.
В обоих языках (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 компилируется в структуру FCL System.Int32 , вызывая соответствующие методы, такие как Int32.Parse() , Int32.ToString() .
Int и Integer в Java и C# - это два разных термина, используемых для представления разных вещей. Это один из примитивных типов данных, которые могут быть назначены переменной, которая может хранить точно. По одному значению его объявленного типа за раз.
Например:
int number = 7;
Где int - тип данных, присвоенный переменной number, которая содержит значение seven. Таким образом, int -это просто примитив, а не объект.
В то время как Integer -это класс-оболочка для примитивного типа данных, который имеет статические методы. Это может быть использовано в качестве аргумента к методу, который требует объект, где as int может быть использован в качестве аргумента к методу, который требует целое значение, которое может быть использовано для арифметического выражения.
Например:
Integer number = new Integer(5);
Переменная int содержит 32-битное целое число со знаком. Целое число (с большой буквы I) содержит ссылку на объект типа Integer (класс) или на null.
Java автоматически выполняет приведение между ними; от Integer к int всякий раз, когда целочисленный объект возникает в качестве аргумента оператора int или присваивается переменной int, или значение int присваивается целочисленной переменной. Этот кастинг называется boxing/unboxing.
Если целочисленная переменная, ссылающаяся на null, распаковывается явно или неявно, то выбрасывается NullPointerException.
В Java int-это примитивный тип данных, а Integer-вспомогательный класс, он используется для преобразования одного типа данных в другой.
Например:
double doubleValue = 156.5d;
Double doubleObject = new Double(doubleValue);
Byte myByteValue = doubleObject.byteValue ();
String myStringValue = doubleObject.toString();
Примитивные типы данных хранят самую быструю доступную память, где вспомогательный класс является сложным и хранится в памяти heep.
ссылка из "David Gassner" Java основной тренинг.
"int"-примитивный тип данных, а "Integer"-класс-оболочка в Java. "Integer" может быть использован в качестве аргумента для метода, который требует объект, где as "int" может быть использован в качестве аргумента для метода, который требует целое значение, которое может быть использовано для арифметического выражения.
(Версия 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. Только можно передать значения типов классов-оболочек в любой класс коллекции.
(Классы-Обертки - Логический,Характер,Байт,Короткое Целое,Длинное Целое,С Плавающей Точкой Двойной)
List<Integer> element = new ArrayList<>();
int valueInt = 10;
Integer valueInteger = new Integer(value);
element.add(valueInteger);
Но обычно мы добавляем примитивные значения в класс collection? Верен ли пункт 02?
List<Integer> element = new ArrayList<>();
element.add(5);
Да 02 правильно, beacouse autoboxing.
Autoboxing-Это автоматическое преобразование, которое делает компилятор java между примитивным типом и соответствующим ему классом-оболочкой.
Затем 5 преобразуются в целочисленное значение с помощью автобокса.