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

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

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

В C# нет целочисленного типа.

Judah Gabriel Himango 05.03.2010 05:58
Стоит ли изучать PHP в 2023-2024 годах?
Стоит ли изучать PHP в 2023-2024 годах?
Привет всем, сегодня я хочу высказать свои соображения по поводу вопроса, который я уже много раз получал в своем сообществе: "Стоит ли изучать PHP в...
Поведение ключевого слова "this" в стрелочной функции в сравнении с нормальной функцией
Поведение ключевого слова "this" в стрелочной функции в сравнении с нормальной функцией
В JavaScript одним из самых запутанных понятий является поведение ключевого слова "this" в стрелочной и обычной функциях.
Приемы CSS-макетирования - floats и Flexbox
Приемы CSS-макетирования - floats и Flexbox
Здравствуйте, друзья-студенты! Готовы совершенствовать свои навыки веб-дизайна? Сегодня в нашем путешествии мы рассмотрим приемы CSS-верстки - в...
Тестирование функциональных ngrx-эффектов в Angular 16 с помощью Jest
В системе управления состояниями ngrx, совместимой с Angular 16, появились функциональные эффекты. Это здорово и делает код определенно легче для...
Концепция локализации и ее применение в приложениях React ⚡️
Концепция локализации и ее применение в приложениях React ⚡️
Локализация - это процесс адаптации приложения к различным языкам и культурным требованиям. Это позволяет пользователям получить опыт, соответствующий...
Пользовательский скаляр GraphQL
Пользовательский скаляр GraphQL
Листовые узлы системы типов GraphQL называются скалярами. Достигнув скалярного типа, невозможно спуститься дальше по иерархии типов. Скалярный тип...
267
1
242 870
26
Перейти к ответу Данный вопрос помечен как решенный

Ответы 26

Ответ принят как подходящий

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

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


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

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

Утверждение, что «объекты [...] передаются по ссылке» сбивает с толку и неверно, ИМО. Точнее сказать, что «Ссылки на объекты передаются по значению». (Также примитивы не всегда выделяются из стека - рассмотрите примитивное поле внутри объекта ...)

Jon Skeet 27.10.2008 14:18

По крайней мере, в C# int - это ключевое слово языка, эквивалентное типу Int32 CLR (фактически CTS).

Scott Dorman 31.01.2009 06:36

@Jon Skeet, я знаю, что вас считают гуру C#, но из-за того, как работает АНГЛИЙСКИЙ ЯЗЫК, вы можете просто сказать, что передано по ссылке, поскольку это точно такое же значение, не связанное с программированием. Да, я знаю, что передача по ссылке в C# просто приводит к тому, что ссылка передается по ссылке.

Tim Matthews 05.02.2009 10:14

К сожалению, в английском языке нет эквивалентных операторов «передать что-то по ссылке» и «передать ссылку на что-то по значению», и они не имеют эквивалентного значения в контексте языка программирования.

Alan Krueger 07.07.2010 19:59

‒1. Это может точно описать, как Java справляется с этим, но для C# это совершенно неправильно.

Joey 12.01.2011 14:40

Я не знаю Java, но нет типа Integer, а Int32, Int64, и все они являются структурой, которая является типом значения. Примитивный означает в C#, что типы определены в FCL (Framework Class Library) командой CLR, и поэтому они называются примитивными. В этом случае даже объект Date называется примитивным типом. int - это ключевое слово, которое в точности то же самое, что и Int32, а single - это Int16 и т. д. Они становятся объектами, когда они помещены в коробку, однако это не то, что сказал OP.

Tarik 24.04.2012 22:07

Почему это проголосовало? Ответ неверный. Это не совсем подходит для Java и даже близко не подходит для C#. Тот, кто читает это, будет знать меньше по теме, чем раньше.

Thom Smith 17.09.2012 18:03

Я взял на себя смелость добавить аспект C# к этому ответу (вместо создания нового ответа).

Isak Savo 24.09.2013 13:18

просто подумал, что стоит упомянуть, что, по крайней мере, в Java Integer также может быть нулевым, в то время как int не может быть нулевым и приведет к nullPointerException, если это так. Это еще одно ключевое различие между ними, которое может помочь тем, кто не знаком с терминологией.

ghoulfolk 25.08.2016 09:48

@ghoulfolk Просто чтобы добавить к этому, хотя примитивные типы в Java и аналогично типы значений в C# (например, int) не может быть null, в C# вы можете разрешить значения null, используя типы, допускающие значение NULL (например, int?).

Ruben9922 28.03.2017 14:08

Ну, в 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 является синонимом Int32, см. stackoverflow.com/questions/62503/c-int-or-int32-should-i-ca‌ re

ripper234 19.09.2008 15:13

Я не знаю Java, но нет типа Integer, а Int32, Int64, и все они являются структурой, которая является типом значения. Примитивный означает в C#, что типы определены в FCL (Framework Class Library) командой CLR, и поэтому они называются примитивными. В этом случае даже объект Date называется примитивным типом.

Tarik 24.04.2012 22:05

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

Лично я предпочитаю int, string, double и т.д., потому что они не требуют инструкции using System; :) Глупая причина, я знаю ...

И это должно быть добавлено, C# int / Int32 - это нет, то же самое, что и Java Integer.

Judah Gabriel Himango 05.03.2010 06:02

Я добавлю к приведенным выше отличным ответам и расскажу о упаковке и распаковке, а также о том, как это применимо к 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.

Leo Izen 19.09.2010 06:54

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

Peter Meyer 01.10.2008 00:00

Собственно, в C# Int32 - это объект. Это объект структуры типа valuetype, производный от system.object. Он не обрабатывается особенно иначе, чем другие объекты значений, как "int" в Java.

Wedge 01.10.2008 00:46

Что касается 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)

McDowell 15.09.2008 22:22

Примечание: значение по умолчанию 127 извлекается из sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache‌​.high");.

KNU 02.10.2014 20:04

@andnil - Я работал с Bex в Stellent. Он отличный ресурс, чтобы процитировать +1 для справки на bexhuff.com!

bcar 18.01.2016 19:44
stackoverflow.com/questions/20877086/…
Ciro Santilli TRUMP BAN IS BAD 17.02.2016 15:16

В 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 передача по ссылке - это передача значения ссылки (указателя). Я немного запутался.?

WolfmanDragon 31.01.2009 06:12

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

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

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

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

@peter Mortense, Как (int a; Integer a;) влияет на программу, я имею в виду, как они влияют на выполнение.

Anuj Masand 27.06.2017 14:19

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().

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

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

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 ответов на этот вопрос. Ваш добавляет что-то, что упустили другие? Не помогает то, что здесь нет грамматики.

Teepeemm 23.09.2016 22:21

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

Другие вопросы по теме