Я читал Подробнее Джоэл о программном обеспечении, когда наткнулся на Джоэл Спольски, говорящий о каком-то конкретном типе программистов, знающих разницу между int
и Integer
на Java / C# (объектно-ориентированные языки программирования).
Итак, в чем разница?
В Java тип int является примитивом, тогда как тип Integer является объектом.
В C# тип int совпадает с System.Int32
и является тип значения (т.е. больше похож на java int). Целое число (как и любые другие типы значений) может быть в штучной упаковке («завернутым») в объект.
Различия между объектами и примитивами несколько выходят за рамки этого вопроса, но суммируем:
Объекты предоставляют возможности для полиморфизма, передаются по ссылке (или, точнее, имеют ссылки, переданные по значению), и выделяются из куча. И наоборот, примитивы - это неизменяемые типы, которые передаются по значению и часто выделяются из куча.
Утверждение, что «объекты [...] передаются по ссылке» сбивает с толку и неверно, ИМО. Точнее сказать, что «Ссылки на объекты передаются по значению». (Также примитивы не всегда выделяются из стека - рассмотрите примитивное поле внутри объекта ...)
По крайней мере, в C# int - это ключевое слово языка, эквивалентное типу Int32 CLR (фактически CTS).
@Jon Skeet, я знаю, что вас считают гуру C#, но из-за того, как работает АНГЛИЙСКИЙ ЯЗЫК, вы можете просто сказать, что передано по ссылке, поскольку это точно такое же значение, не связанное с программированием. Да, я знаю, что передача по ссылке в C# просто приводит к тому, что ссылка передается по ссылке.
К сожалению, в английском языке нет эквивалентных операторов «передать что-то по ссылке» и «передать ссылку на что-то по значению», и они не имеют эквивалентного значения в контексте языка программирования.
‒1. Это может точно описать, как Java справляется с этим, но для C# это совершенно неправильно.
Я не знаю Java, но нет типа Integer
, а Int32
, Int64
, и все они являются структурой, которая является типом значения. Примитивный означает в C#, что типы определены в FCL (Framework Class Library) командой CLR, и поэтому они называются примитивными. В этом случае даже объект Date называется примитивным типом. int
- это ключевое слово, которое в точности то же самое, что и Int32
, а single
- это Int16
и т. д. Они становятся объектами, когда они помещены в коробку, однако это не то, что сказал OP.
Почему это проголосовало? Ответ неверный. Это не совсем подходит для Java и даже близко не подходит для C#. Тот, кто читает это, будет знать меньше по теме, чем раньше.
Я взял на себя смелость добавить аспект C# к этому ответу (вместо создания нового ответа).
просто подумал, что стоит упомянуть, что, по крайней мере, в Java Integer также может быть нулевым, в то время как int не может быть нулевым и приведет к nullPointerException, если это так. Это еще одно ключевое различие между ними, которое может помочь тем, кто не знаком с терминологией.
@ghoulfolk Просто чтобы добавить к этому, хотя примитивные типы в Java и аналогично типы значений в C# (например, int
) не может быть null
, в C# вы можете разрешить значения null
, используя типы, допускающие значение NULL (например, 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 - это интересный способ работы с int (так же, как, возможно, String - это интересный способ работы с группой символов).
Я знаю, что Java - это не C, но, поскольку я никогда не программировал на C, это лучшее, что я мог найти. Надеюсь это поможет!
Целочисленный Ojbect против примитивного сравнения int
в C# int является синонимом Int32, см. stackoverflow.com/questions/62503/c-int-or-int32-should-i-ca re
Я не знаю Java, но нет типа Integer, а Int32, Int64, и все они являются структурой, которая является типом значения. Примитивный означает в C#, что типы определены в FCL (Framework Class Library) командой CLR, и поэтому они называются примитивными. В этом случае даже объект Date называется примитивным типом.
В C# int - это просто псевдоним для System.Int32
, строка для System.String
, double для System.Double
и т. д.
Лично я предпочитаю int, string, double и т.д., потому что они не требуют инструкции using System;
:) Глупая причина, я знаю ...
И это должно быть добавлено, C# int / Int32 - это нет, то же самое, что и Java Integer.
Я добавлю к приведенным выше отличным ответам и расскажу о упаковке и распаковке, а также о том, как это применимо к Java (хотя в C# это тоже есть). Я буду использовать только терминологию Java, потому что мне больше нравится au fait.
Как упоминалось в ответах, 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, обе версии генерируют идентичный байт-код. Таким образом, хотя автоматическая упаковка и автоматическая распаковка очень удобны, потому что вы пишете меньше кода, эти операции делать выполняются за кулисами с теми же затратами времени выполнения, поэтому вам все равно нужно знать об их существовании.
Надеюсь это поможет!
Deque отсутствует в java 1.5 или 1.4. Он был добавлен в 1.6.
Я просто опубликую здесь, поскольку некоторые другие сообщения немного неточны в отношении 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;
}
Чтобы было ясно, в C# int, как и System.Int32, не являются объектами. Это типы значений, и среда CLR обрабатывает их иначе, чем объекты.
Собственно, в C# Int32 - это объект. Это объект структуры типа valuetype, производный от system.object. Он не обрабатывается особенно иначе, чем другие объекты значений, как "int" в Java.
Что касается Java 1.5 и автобокс, есть важная особенность, которая проявляется при сравнении объектов Integer.
В 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
Объекты, созданные с помощью оператора new, всегда будут возвращать false по сравнению с ==. Андреас путает Integer.valueOf (int) с новым Integer (int)
Примечание: значение по умолчанию 127
извлекается из sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
.
@andnil - Я работал с Bex в Stellent. Он отличный ресурс, чтобы процитировать +1 для справки на 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
Теперь вы видите разницу?
По вашему определению прохода по ссылке нет. Все, что передается, должно иметь значение (даже null является значением), даже если это просто значение указателя, в противном случае это просто пустой набор. По условиям CS передача по ссылке - это передача значения ссылки (указателя). Я немного запутался.?
Еще одна вещь, которую я не вижу в предыдущих ответах: В Java примитивные классы-оболочки, такие как Integer, Double, Float, Boolean ... и String, считаются инвариантными, так что, когда вы передаете экземпляр этих классов, вызванный метод не мог каким-либо образом изменить ваши данные, в opositión с большинством других классов, внутренние данные которых могут быть изменены его общедоступными методами. Таким образом, у этого класса есть только методы получения, а не методы установки, кроме конструктора.
В java-программе строковые литералы хранятся в отдельной части кучи, только экземпляр для литерала, чтобы сохранить память, повторно используя эти экземпляры.
На таких платформах, как Java, int
- это примитивы, а Integer
- это объект, содержащий целочисленное поле. Важное отличие состоит в том, что примитивы всегда передаются по значению и по определению неизменяемы.
Любая операция с примитивной переменной всегда возвращает новое значение. С другой стороны, объекты передаются по ссылке. Можно утверждать, что точка на объект (также известная как ссылка) также передается по значению, а содержимое - нет.
@peter Mortense, Как (int a; Integer a;) влияет на программу, я имею в виду, как они влияют на выполнение.
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. Таким образом, int является псевдонимом для System.Int32.When
с использованием целочисленных методов, таких как int.Parse()
, int.ToString()
и т. д. Целое число компилируется в структуру FCL System.Int32
, вызывая соответствующие методы, такие как Int32.Parse()
, Int32.ToString()
.
Есть много причин использовать классы-оболочки:
Int и Integer в Java и C# - это два разных термина, используемых для обозначения разных вещей. Это один из примитивных типов данных, которые можно присвоить переменной, которая может точно хранить. Одно значение объявленного типа за раз.
Например:
int number = 7;
Где int
- тип данных, присвоенный номеру переменной, которая содержит значение семь. Итак, int
- это просто примитив, а не объект.
В то время как 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" Дэвида Гасснера.
Ява:
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
}
}
P.S. Книга Герберта Шильдта была взята за образец.
В java, насколько мне известно, если вы ученик, тогда, когда вы пишете int a; тогда в java generic он будет компилировать код вроде Integer a = new Integer()
.
Таким образом, в соответствии с родовыми типами Integer
не используется, но используется int
.
так что там такая разница.
Есть еще 18 ответов на этот вопрос. Ваш добавляет что-то, что упустили другие? Не помогает то, что здесь нет грамматики.
int
предопределен в библиотечной функции C#, но в java мы можем создать объект Integer
В Java тип int
является примитивным типом данных, а тип Integer
- объектом.
В C# тип int
также является типом данных, аналогичным System.Int32
. integer
(как и любые другие типы значений) может быть упакован («завернут») в объект.
«int» - это примитивный тип данных, а «Целое число» в классе Wrapper в Java. «Целое число» может использоваться в качестве аргумента метода, которому требуется объект, а «целое число» может использоваться в качестве аргумента метода, которому требуется целочисленное значение, которое может использоваться для арифметического выражения.
(Версия 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. Целое число может быть нулевым. Но int не может быть нулевым.
Integer value1 = null; //OK
int value2 = null //Error
02. В любой класс коллекции можно передавать только значения типа Wrapper Classes.
(Классы оболочки - логические, символьные, байтовые, короткие, целые, длинные, с плавающей запятой, двойные)
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 is the automatic conversion that the java compiler makes between the primitive type and their corresponding wrapper class.
Затем 5 преобразовать в целочисленное значение с помощью автобокса.
int - примитивный тип данных. Целое число - это класс-оболочка. Он может хранить данные типа int как объекты.
int - это примитивный тип данных, а Integer - это объект. Создание объекта с помощью Integer предоставит вам доступ ко всем методам, доступным в классе Integer. Но если вы создадите примитивный тип данных с помощью int, вы не сможете использовать эти встроенные методы, и вам придется определять их самостоятельно. Но если вам не нужны другие методы и вы хотите сделать программу более эффективной с точки зрения памяти, вы можете использовать примитивный тип данных, потому что создание объекта увеличит потребление памяти.
В C# нет целочисленного типа.