Яка різниця між int та Integer на Java та C #?

Я читав Більше Джоела про програмне забезпечення, коли натрапив на Джоела Спольського, який-небудь розповів про певний тип програміста, знаючи різницю між intта Integerв Java / C # (об'єктно-орієнтовані мови програмування).

Отже, у чому різниця?

У Java тип 'int' є примітивом, тоді як тип 'Integer' є об'єктом.

У C # тип '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 - один з небагатьох примітивів на Яві (поряд із char та деякими іншими). Я не впевнений на 100%, але думаю, що об'єкт Integer в більшій чи меншій мірі просто має властивість int і цілу купу методів взаємодії з цим властивістю (як, наприклад, метод toString ()). Таким чином, Integer - це фантазійний спосіб роботи з int (Так само, як, можливо, String - це фантазійний спосіб роботи з групою символів).

Я знаю, що Java не є C, але оскільки я ніколи не програмував на C, це найближче, я міг прийти до відповіді. Сподіваюсь, це допомагає!

Цілий об'єкт javadoc

Integer Ojbect vs int примітивне порівняння

Я додам до відмінних відповідей, наведених вище, і поговоримо про бокс та unboxing, і про те, як це стосується Java (хоча C # теж має). Я буду використовувати лише термінологію Java, тому що мені більше до вподоби .

Як було сказано у відповідях, intце просто число (називається unboxed тип), тоді 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 та автобоксингу, то тут важлива «химерність», яка виникає при зіставленні об'єктів Integer.

У Java об'єкти Integer зі значеннями від -128 до 127 є незмінними (тобто для одного конкретного цілого значення, скажімо, 23, всі об'єкти Integer, ініційовані у вашій програмі зі значенням 23 вказує на точно такий же об'єкт).

Наприклад, це повертає істину:

Integer i1 = new Integer(127);
Integer i2 = new Integer(127);
System.out.println(i1 == i2); //  true

Хоча це повертає помилку:

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

Ви бачите різницю зараз?

У C #, int - це лише псевдонім для System.Int32, string для System.String, double для System.Doubleтощо ...

Особисто я віддаю перевагу int, string, double і т. Д., Тому що вони не вимагають using System;заяви :) Дурна думка, я знаю ...

Існує багато причин використовувати класи обгортки:

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

На це вже відповіли 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;
}

int використовується для оголошення примітивної змінної

e.g. int i=10;

Integer використовується для створення контрольної змінної класу Integer

Integer a = new Integer();

У таких платформах, як Java, ints - примітиви, а Integerоб'єкт, який містить ціле поле. Важлива відмінність полягає в тому, що примітиви завжди передаються за значенням і за визначенням незмінні.

Будь-яка операція, що включає примітивну змінну, завжди повертає нове значення. З іншого боку, об'єкти передаються навколо посилання. Можна стверджувати, що точка на об’єкт (AKA посилання) також передається за значенням, але вміст - ні.

Ще одне, чого я не бачу в попередніх відповідях: у Java такі примітивні класи обгортки, як Integer, Double, Float, Boolean ... і String мають бути інваріантними, так що при передачі екземпляра цих класів викликається метод не міг жодним чином змінити ваші дані в опозиції з більшістю інших класів, внутрішні дані яких могли бути змінені його публічними методами. Таким чином, що в цих класах є крім методів «getter», без «setters», крім конструктора.

У програмі java Строкові літерали зберігаються в окремій частині пам'яті купи, лише екземпляр для літералу, щоб зберегти пам'ять, використовуючи ці екземпляри

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

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

int x;
Integer y; 

x і y - обидві змінні типу int, але y обернуто класом Integer і має кілька методів, якими ви користуєтесь, але у випадку, якщо вам потрібно викликати деякі функції класу обгортки Integer, ви можете це зробити просто.

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 включила дві дуже корисні функції: автобокс та автобокс. Автобоксинг / розпакування значно спрощує та впорядковує код, який повинен перетворювати примітивні типи в об’єкти, і навпаки.

Приклад конструкторів:

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

Книга П.С.Герберта Шильдта була взята як орієнтир.

Змінна int містить ціле ціле значення, підписане 32 бітами. Цілий (з великим капіталом I) містить посилання на об'єкт (класу) типу Integer або на нуль.

Java автоматично переходить між ними; від Integer до int всякий раз, коли об'єкт Integer виникає як аргумент оператору int або присвоюється змінній int або значенню int присвоюється змінна Integer. Цей кастинг називається бокс / розпакування.

Якщо змінна Integer, що посилається на null, не є коробкою, явно або неявно, передається NullPointerException.

Int і Integer в Java та C # - це два різних терміни, які використовуються для представлення різних речей. Це один із примітивних типів даних, який може бути призначений змінній, яка може точно зберігати. Одне значення задекларованого типу за один раз.

Наприклад:

int number = 7;

Де intтип даних присвоюється змінному номеру, який містить значення сім. Тож а intпросто примітив, а не предмет.

У той час Integerяк клас - це обгортка для примітивного типу даних, який має статичні методи. Це може бути використано як аргумент методу, який вимагає об'єкта, де int може бути використаний як аргумент методу, який вимагає цілого значення, яке може бути використане для арифметичного вираження.

Наприклад:

Integer number = new Integer(5);

В обох мовах (Java та C #) intє чотирибайтове підписане ціле число.

На відміну від Java, C # Надає як підписані, так і неподписані цілі значення. Оскільки Java і C # є об'єктно-орієнтованими, деякі операції на цих мовах не відображаються безпосередньо в інструкціях, передбачених часом виконання, і тому їх слід визначати як частину об'єкта певного типу.

C # надає System.Int32тип значення, використовуючи частину пам'яті, що належить до опорного типу на купі.

java забезпечує, java.lang.Integerякий є еталонним типом, що працює на int. Методи в Integerне можеш бути скомпільовані безпосередньо під час виконання instructions.So ми боксувати цілочисельне значення , щоб перетворити його в екземпляр Integer і використовувати методи , які очікують екземпляр деякого типу (як toString(), parseInt(), і valueOf()т.д.).

У змінній C # int посилається на System.Int32.Any4-байтне значення в пам'яті, може трактуватися як примітивний int, яким можна керувати примірником System.Int32.So int є псевдонімом для System.Int32.Whenвикористання методів, пов'язаних з цілими числами int.Parse(), int.ToString()тощо. ГКЛ System.Int32STRUCT викликаючи відповідні методи , такі як Int32.Parse(), Int32.ToString().

У Java intтип - це примітивний тип даних, де як Integerтип є об'єктом.

У C # intтип також є типом даних таким же, як System.Int32. integer(Так само , як і будь-які інші типи значень) можуть бути в штучної упаковці ( «обгорнутий») в об'єкт.

У Java int - це примітивний тип даних, тоді як Integer - це клас Helper, він використовується для перетворення одного типу даних в інший.

Наприклад:

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

Примітивні типи даних зберігають найшвидшу пам’ять, де клас Helper складний, і зберігають у пам'яті heep.

посилання від "Девід Гасснер" Java Essential Training.

"int" - це примітивний тип даних, а "Integer" - у класі Wrapper на Java. "Цілий" може бути використаний як аргумент методу, який вимагає об'єкта, де "int" може бути використаний як аргумент методу, який вимагає цілого значення, яке може бути використане для арифметичного вираження.

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 правильно, маяче autoboxing.

Автобоксинг - це автоматичне перетворення, яке компілятор java робить між примітивним типом та відповідним класом обгортки.

Потім 5 конвертуйте як цілісне значення за допомогою автозавантаження.

int визначено в функції бібліотеки c #, але в Java ми можемо створити об'єкт Integer

(Версія Java) Простими словами int є примітивним, а Integer - об’єктом обгортки для 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використовується. тому там така різниця.

int - примітивний тип даних. Integer - клас обгортки. Він може зберігати дані int як об’єкти.

int - це примітивний тип даних, тоді як Integer - це об'єкт. Створення об'єкта за допомогою Integer надасть вам доступ до всіх методів, доступних у класі Integer. Але, якщо ви створите примітивний тип даних з int, ви не зможете використовувати ці методи вбудови, і вам доведеться їх визначити самостійно. Але якщо ви не хочете жодних інших методів і хочете зробити програму більш ефективною, пам'ять можна скористатися примітивним типом даних, оскільки створення об’єкта збільшить споживання пам'яті.