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

голоса
222

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

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

Задан 02/08/2008 в 22:47
источник пользователем
На других языках...                            


24 ответов

голоса
216

В Java, тип «INT» является примитивным, в то время как тип в «Integer» является объектом.

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


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

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

Ответил 02/08/2008 d 22:55
источник пользователем

голоса
135

Ну, в Java ИНТ является примитивным в то время как целое является объектом. Смысл, если вы сделали новый Integer:

Integer i = new Integer(6);

Вы могли бы назвать какой-либо метод на I:

String s = i.toString();//sets s the string representation of i

В то время как с междунарами:

int i = 6;

Вы не можете вызывать любые методы на него, потому что это просто примитивно. Так:

String s = i.toString();//will not work!!!

будет выдавать ошибку, потому что ИНТ не является объектом.

ИНТ один из немногих примитивов в Java (наряду с полукоксом и некоторыми другими). Я не уверен на 100%, но я думаю, что объект Integer более или менее просто имеет Int собственности и целый букет методов взаимодействия с этой собственностью (например, метода ToString (), например). Таким образом, Integer является причудливым способом работать с междунар (Подобно тому, как, возможно, строка является причудливым способом работы с группой символов).

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

Integer объект Javadoc

Integer Ojbect против Int примитивного сравнения

Ответил 02/08/2008 d 23:05
источник пользователем

голоса
32

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

Надеюсь это поможет!

Ответил 03/08/2008 d 03:32
источник пользователем

голоса
26

Я просто пост здесь, так как некоторые из других должностей немного неточные по отношению к C #.

Правильно: int это псевдоним System.Int32.
Неправильно: float это не псевдоним System.Float, а дляSystem.Single

В принципе, внутр зарезервированное ключевое слово в C # язык программирования, и является псевдонимом для System.Int32типа значения.

плавать и Float не то же самое , однако, как и правильный тип системы для «» float«» является System.Single. Есть некоторые виды , как это , что зарезервировали ключевые слова , которые , кажется, не совпадают с именами типа непосредственно.

В C # нет никакой разницы между «» int«» и «» System.Int32«», или любой из других пар или ключевых слов / типов систем, для при определении перечислений , за исключением. С перечислениями вы можете указать размер хранилища , чтобы использовать и в этом случае вы можете использовать только зарезервированное ключевое слово, а не имя типа системы во время выполнения.

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

Это заявление в методе:

int i;

определяет переменную iтипа System.Int32, живущий в регистре или в стеке, в зависимости от оптимизации. Же объявление в типе (структуры или классы) определяет поле члена. То же самое объявление в списке Метод аргумента определяет параметр, с теми же параметрами, что и для хранения локальной переменной. (обратите внимание , что этот пункт не действует , если вы начнете вытягивать методы итераторов в смесь, это разные звери вообще)

Чтобы получить объект кучи, вы можете использовать бокс:

object o = i;

это создаст коробочную копию содержимого iв куче. В IL Вы можете получить доступ методы объекта кучного непосредственно, но в C # вы должны бросить его обратно к междунар, что создаст еще одну копию. Таким образом, объект в куче не может быть легко изменен в C # без создания новой коробочной копии нового Int значения. (Тьфу, этот пункт не читает все , что легко.)

Ответил 04/08/2008 d 15:11
источник пользователем

голоса
18

Что касается Java 1.5 и Autoboxing есть важный «бзик» , который приходит играть при сравнении объектов Integer.

В Java, Integer объекты со значениями -128 до 127 неизменны (то есть, для одного конкретного целого значения, скажем , 23, все объекты Целых воплощенных с помощью вашей программы со значением 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 вы используете. Спецификация Autoboxing для Java 1.5 требует, чтобы целые числа (от -128 до 127) всегда боксировать на тот же объект обертку.

Решение? =) Всегда следует использовать Integer.equals (метод) при сравнении объектов Integer.

System.out.println(i1.equals(i2)); //  true

Более подробная информация на java.net примере на bexhuff.com

Ответил 05/08/2008 d 21:49
источник пользователем

голоса
17

В Java есть два основных типа в JVM . 1) Примитивные типы и 2) ссылочные типы. INT примитивный тип и Целое число является тип класса (который является своего рода ссылочного типа).

Примитивные значения не разделяют состояние с другими примитивными значениями. Переменная, чей тип является примитивный тип всегда имеет элементарное значение этого типа.

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 все передается по значению. С объектами значение, которое передается это ссылка на объект. Таким образом, еще одно различие между междунар и 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 .

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

public void increment(Integer x) {
  x = Integer.valueOf(x.intValue() + 1);
}
Integer a = Integer.valueOf(1);
increment(a);
// a is now 2

Видите ли вы разницу сейчас?

Ответил 06/08/2008 d 12:08
источник пользователем

голоса
11

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

Лично я предпочитаю ИНТ строку, двойной и т.д. , потому что они не требуют using System;заявление :) глупая причина, я знаю ...

Ответил 03/08/2008 d 00:37
источник пользователем

голоса
8

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

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

голоса
8

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

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

Ответил 31/01/2009 d 03:49
источник пользователем

голоса
7

Ява:

int, double, long, byte, float, double, short, boolean, char- примитивы. Используется для удержания основных типов данных , поддерживаемых языком. примитивные типы не являются частью иерархии объектов, и они не наследуют объект. Тхет can'be пройти по ссылке к способу.

Double, Float, Long, Integer, Short, Byte, Character, И Boolean, являются оболочками типа, расфасованные в java.lang. Все обертки числового типа определяет конструктор , которые позволяют объекту быть построен из заданного значения, или строкового представления этого значения. Использование объектов можно добавить накладные расходы на даже самые простые расчеты.

Начиная с JDK 5, Java включала в себя два очень полезные функции: Autoboxing и autounboxing. Autoboxing / распаковка значительно упрощает и упорядочивает код, который необходимо преобразовать примитивные типы в объекты, и наоборот.

Пример конструкторов:

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

Пример 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
    }
}

Книга П. С. Шилдта была взята в качестве эталона.

Ответил 13/06/2016 d 19:31
источник пользователем

голоса
7

INT используется для объявления примитивных переменного

e.g. int i=10;

Integer используется для создания ссылочной переменной класса Integer

Integer a = new Integer();
Ответил 11/12/2011 d 08:19
источник пользователем

голоса
7

Это уже ответили на Java, вот C # Ответ:

«Целое» не является допустимым именем типа в C # и «Int» это всего лишь псевдоним для System.Int32. Кроме того, в отличие от Java (или C ++) нет никакого специального примитивного типа в C #, каждый экземпляр типа в C # (в том числе межд) является объектом. Вот некоторые демонстративный код:

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;
}
Ответил 04/08/2008 d 22:02
источник пользователем

голоса
6

Вы когда-либо запрограммировать до этого (целое) является одним из примитивных типов, которые можно установить для переменных (так же, как полукокс, поплавок, ...).

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

int x;
Integer y; 

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

Integer.toString(x);

но имейте в виду, что оба х и у Corect, но если вы хотите использовать их только в качестве примитивного типа, используйте простую форму (используется для определения х).

Ответил 17/05/2014 d 12:56
источник пользователем

голоса
6

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

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

Ответил 06/08/2008 d 15:33
источник пользователем

голоса
4

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

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

Ответил 27/04/2017 d 07:25
источник пользователем

голоса
4

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

Например:

int number = 7;

Где intэто тип данные присваиваются переменным число , которое удерживает значение семь. Так что intэто просто примитив не является объектом.

В то время как Integerэто класс - оболочка для примитивного типа данных , который имеет статические методы. Это может быть использовано в качестве аргумента метода , который требует объекта, где , как INT может быть использован в качестве аргумента метода , который требует целого значения, которое может быть использовано для арифметического выражения.

Например:

Integer number = new Integer(5);
Ответил 07/08/2014 d 11:50
источник пользователем

голоса
4

В обоих языках (Java и C #) intявляется 4-байтовое целое число со знаком .

В отличие от Java, C # Обеспечивает как подписанных и неподписанных целочисленных значений. Как Java и C # являются объект объектно-ориентированным, некоторые операции на этих языках не отображаются непосредственно на инструкцию, предоставляемой во время выполнения и так должны быть определены как часть объекта определенного типа.

С # , System.Int32который является типом значения , используя часть памяти , которая принадлежит к опорному типу в куче.

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

В C # переменной INT относится к System.Int32.Anyзначению 4 байта в памяти может быть интерпретирован как примитивный Int, которым можно управлять с помощью экземпляра System.Int32.So Int является псевдонимом System.Int32.Whenиспользования целочисленных связанными методов , как int.Parse(), и int.ToString()т.д. Целое число компилируются в ГКЛ System.Int32STRUCT вызывая соответствующие методы , такие как Int32.Parse(), Int32.ToString().

Ответил 17/07/2014 d 07:02
источник пользователем

голоса
3

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

Например:

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

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

справка с Java Essential Training "Дэвид Gassner".

Ответил 28/02/2016 d 18:42
источник пользователем

голоса
3

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

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

Если Integer переменная реферирование нуль является распакованный, явно или неявно, NullPointerException отбрасывается.

Ответил 26/11/2015 d 10:54
источник пользователем

голоса
1

«ИНТ» примитивно типа данных и «Integer» в Упаковочный класса в Java. «Целое число» может быть использовано в качестве аргумента метода, который требует объекта, где как «Int» может быть использована в качестве аргумента метода, который требует целого значения, которое может быть использовано для арифметического выражения.

Ответил 04/08/2017 d 09:57
источник пользователем

голоса
1

ИНТ предопределен в библиотеке функции с #, но в Java мы можем создать роект из Integer

Ответил 06/03/2017 d 05:08
источник пользователем

голоса
0

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

Integer value1 = null; //OK

int value2 = null      //Error

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

(Wrapper классы - Boolean, Character, Byte, Short, Integer, Long, Float, Double)

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

Затем 5 новообращенный как значение целого числа Autoboxing.

Ответил 05/06/2018 d 11:35
источник пользователем

голоса
0

(Java версия) в простых словах междунара примитивно и Integer является объектом обертки для междунар.

Одним из примеров использование Integer против междунара, когда вы хотите, чтобы сравнить и ИНТ переменных снова обнулить он будет бросать ошибку.

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...}
Ответил 15/02/2018 d 21:04
источник пользователем

голоса
0

В Java, как мне известно, если вы учащиеся тогда, когда вы пишете Int А; то в Java родового будет компилировать код, как целое число а = новое целое. Таким образом, в соответствии с дженериков целого числа не используется, а используется внутр. поэтому есть поэтому такая разница есть.

Ответил 22/09/2016 d 09:53
источник пользователем

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more