Pergunta

eu estava lendo Mais Joel sobre software quando me deparei Joel Spolsky dizer algo sobre um tipo específico de programador sabendo a diferença entre um int e um Integer em Java/C# (linguagens de programação orientadas a objetos).

Então qual é a diferença?

Foi útil?

Solução

Em Java, o tipo 'int' é primitivo, enquanto o tipo 'Integer' é um objeto.

Em C#, o tipo 'int' é o mesmo que System.Int32 e é um tipo de valor (ou seja, mais parecido com o java 'int').Um número inteiro (assim como qualquer outro tipo de valor) pode ser encaixotado ("embrulhado") em um objeto.


As diferenças entre objetos e primitivos estão um pouco além do escopo desta questão, mas para resumir:

Objetos fornecem recursos para polimorfismo, são passados ​​por referência (ou, mais precisamente, têm referências passadas por valor) e são alocados a partir do amontoar.Por outro lado, primitivos são tipos imutáveis ​​que são passados ​​​​por valor e geralmente são alocados do pilha.

Outras dicas

Bem, em Java, um int é um primitivo, enquanto um inteiro é um objeto.Ou seja, se você criou um novo inteiro:

Integer i = new Integer(6);

Você poderia chamar algum método em i:

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

Considerando que com um int:

int i = 6;

Você não pode chamar nenhum método nele, porque é simplesmente um primitivo.Então:

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

produziria um erro, porque int não é um objeto.

int é um dos poucos primitivos em Java (junto com char e alguns outros).Não tenho 100% de certeza, mas estou pensando que o objeto Integer tem mais ou menos apenas uma propriedade int e vários métodos para interagir com essa propriedade (como o método toString(), por exemplo).Portanto, Integer é uma maneira sofisticada de trabalhar com um int (assim como talvez String seja uma maneira sofisticada de trabalhar com um grupo de caracteres).

Eu sei que Java não é C, mas como nunca programei em C, isso é o mais próximo que pude chegar da resposta.Espero que isto ajude!

Objeto inteiro javadoc

Objeto inteiro vs.comparação primitiva int

Acrescentarei as excelentes respostas fornecidas acima e falarei sobre boxing e unboxing e como isso se aplica ao Java (embora o C# também o tenha).Usarei apenas a terminologia Java, porque sou mais de fato com isso.

Como as respostas mencionaram, int é apenas um número (chamado de sem caixa tipo), enquanto Integer é um objeto (que contém o número, portanto, um encaixotado tipo).Em termos Java, isso significa (além de não poder chamar métodos em int), você não pode armazenar int ou outros tipos não-objetos em coleções (List, Map, etc.).Para armazená-los, você deve primeiro embalá-los em seu tipo de caixa correspondente.

Java 5 em diante tem algo chamado boxe automático e desembalagem automática que permitem que o boxe/unboxing seja feito nos bastidores.Compare e contraste:Versão Java 5:

Deque<Integer> queue;

void add(int n) {
    queue.add(n);
}

int remove() {
    return queue.remove();
}

Java 1.4 ou anterior (sem genéricos):

Deque queue;

void add(int n) {
    queue.add(Integer.valueOf(n));
}

int remove() {
    return ((Integer) queue.remove()).intValue();
}

Deve-se notar que apesar da brevidade da versão Java 5, ambas as versões geram bytecode idênticos.Assim, embora o auto-boxing e o auto-unboxing sejam muito convenientes porque você escreve menos código, essas operações fazer acontecem nos bastidores, com os mesmos custos de execução, então você ainda precisa estar ciente de sua existência.

Espero que isto ajude!

Vou apenas postar aqui, pois alguns dos outros posts são um pouco imprecisos em relação ao C#.

Correto: int é um apelido para System.Int32.
Errado: float não é um apelido para System.Float, mas pelo System.Single

Basicamente, int é uma palavra-chave reservada na linguagem de programação C# e é um alias para o System.Int32 tipo de valor.

float e Float não são iguais, porém, como o tipo de sistema correto para ''float'' é System.Single.Existem alguns tipos como este que possuem palavras-chave reservadas que não parecem corresponder diretamente aos nomes dos tipos.

Em C# não há diferença entre ''int'' e ''System.Int32'', ou qualquer um dos outros pares ou palavras-chave/tipos de sistema, exceto ao definir enums.Com enums você pode especificar o tamanho de armazenamento a ser usado e, neste caso, você pode usar apenas a palavra-chave reservada e não o nome do tipo de tempo de execução do sistema.

Se o valor no int será armazenado na pilha, na memória ou como um objeto heap referenciado depende do contexto e de como você o usa.

Esta declaração em um método:

int i;

define uma variável i do tipo System.Int32, residindo em um registrador ou na pilha, dependendo das otimizações.A mesma declaração em um tipo (struct ou classe) define um campo membro.A mesma declaração em uma lista de argumentos de método define um parâmetro, com as mesmas opções de armazenamento de uma variável local.(observe que este parágrafo não é válido se você começar a incluir métodos iteradores na mistura, esses são animais completamente diferentes)

Para obter um objeto heap, você pode usar o boxe:

object o = i;

isso criará uma cópia em caixa do conteúdo de i na pilha.Em IL você pode acessar métodos diretamente no objeto heap, mas em C# você precisa convertê-lo de volta para um int, o que criará outra cópia.Portanto, o objeto no heap não pode ser facilmente alterado em C# sem criar uma nova cópia em caixa de um novo valor int.(Ugh, este parágrafo não pode ser lido tão facilmente.)

Em relação ao Java 1.5 e boxe automático há uma "peculiaridade" importante que surge ao comparar objetos inteiros.

Em Java, objetos inteiros com os valores -128 a 127 são imutáveis ​​(ou seja, para um valor inteiro específico, digamos 23, todos os objetos inteiros instanciados por meio de seu programa com o valor 23 apontam para o exato mesmo objeto).

Exemplo, isso retorna verdadeiro:

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

Embora isso retorne falso:

Integer i1 = new Integer(128);
Integer i2 = new Integer(128);
System.out.println(i1 == i2); //  false

O == compara por referência (as variáveis ​​apontam para o mesmo objeto).

Este resultado pode ou não ser diferente dependendo de qual JVM você está usando.A especificação autoboxing para Java 1.5 requer que números inteiros (-128 a 127) sempre caibam no mesmo objeto wrapper.

Uma solução?=) Deve-se sempre usar o método Integer.equals() ao comparar objetos Integer.

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

Mais informações em java.net Exemplo em bexhuff.com

Em Java existem dois tipos básicos no JVM.1) Tipos primitivos e 2) Tipos de referência.int é um tipo primitivo e Integer é um tipo de classe (que é uma espécie de tipo de referência).

Os valores primitivos não compartilham estado com outros valores primitivos.Uma variável cujo tipo é primitivo sempre contém um valor primitivo desse tipo.

int aNumber = 4;
int anotherNum = aNumber;
aNumber += 6;
System.out.println(anotherNum); // Prints 4

Um objeto é uma instância de classe criada dinamicamente ou um array.Os valores de referência (geralmente apenas referências) são ponteiros para esses objetos e uma referência nula especial, que não se refere a nenhum objeto.Pode haver muitas referências ao mesmo objeto.

Integer aNumber = Integer.valueOf(4);
Integer anotherNumber = aNumber; // anotherNumber references the 
                                 // same object as aNumber

Também em Java tudo é passado por valor.Com objetos, o valor passado é a referência ao objeto.Portanto, outra diferença entre int e Integer em java é como eles são passados ​​nas chamadas de método.Por exemplo em

public int add(int a, int b) {
    return a + b;
}
final int two = 2;
int sum = add(1, two);

A variável dois é passado como o inteiro primitivo tipo 2.Considerando que em

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);

A variável dois é passado como uma referência a um objeto que contém o valor inteiro 2.


@WolfmanDragão:Passar por referência funcionaria assim:

public void increment(int x) {
  x = x + 1;
}
int a = 1;
increment(a);
// a is now 2

Quando o incremento é chamado, ele passa uma referência (ponteiro) para a variável a.E a incremento função modifica diretamente a variável a.

E para tipos de objetos funcionaria da seguinte forma:

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

Você vê a diferença agora?

Em C#, int é apenas um apelido para System.Int32, sequência para System.String, duplo para System.Double etc...

Pessoalmente prefiro int, string, double, etc.porque eles não exigem um using System; declaração :) Um motivo bobo, eu sei...

Existem muitos motivos para usar classes wrapper:

  1. Obtemos comportamento extra (por exemplo, podemos usar métodos)
  2. Podemos armazenar valores nulos, enquanto nas primitivas não podemos
  3. As coleções suportam o armazenamento de objetos e não de primitivos.

Isso já foi respondido para Java, aqui está a resposta em C#:

"Integer" não é um nome de tipo válido em C# e "int" é apenas um alias para System.Int32.Além disso, diferentemente de Java (ou C++), não existem tipos primitivos especiais em C#, cada instância de um tipo em C# (incluindo int) é um objeto.Aqui está um código demonstrativo:

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 é usado para declarar variável primitiva

e.g. int i=10;

Inteiro é usado para criar variável de referência da classe Inteiro

Integer a = new Integer();

Em plataformas como Java, ints são primitivos enquanto Integer é um objeto que contém um campo inteiro.A distinção importante é que os primitivos são sempre transmitidos por valor e, por definição, são imutáveis.

Qualquer operação envolvendo uma variável primitiva sempre retorna um novo valor.Por outro lado, os objetos são transmitidos por referência.Pode-se argumentar que o ponto para o objeto (também conhecido como referência) também está sendo transmitido por valor, mas o conteúdo não.

Mais uma coisa que não vejo nas respostas anteriores:Em Java, as classes wrappers primitivas como Integer, Double, Float, Boolean...e String são supostamente invariáveis, de modo que quando você passa uma instância dessas classes o método invocado não pode alterar seus dados de forma alguma, ao contrário da maioria das outras classes, cujos dados internos podem ser alterados por seus métodos públicos.Para que esta classe possua apenas métodos 'getter', não 'setters', além do construtor.

Em um programa Java, literais de string são armazenados em uma parte separada da memória heap, apenas uma instância de literal, para economizar memória reutilizando essas instâncias

você já programou antes disso (int) é um dos tipos primitivos que você pode definir para suas variáveis ​​(assim como char, float, ...).

mas Integer é uma classe wrapper que você pode usá-la para executar algumas funções em uma variável int (por exemplo, convertê-la em string ou vice-versa,...), mas observe que os métodos nas classes wrapper são estáticos, então você pode usá-los a qualquer momento sem criar uma instância da classe Integer.como recapitulação:

int x;
Integer y; 

xey são variáveis ​​​​do tipo int, mas y é encapsulado por uma classe Integer e possui vários métodos que você usa, mas caso você precise chamar algumas funções da classe wrapper Integer, você pode fazer isso de forma simples.

Integer.toString(x);

mas esteja ciente de que x e y estão corretos, mas se você quiser usá-los apenas como um tipo primitivo, use a forma simples (usada para definir x).

Java:

int, double, long, byte, float, double, short, boolean, char - primitivos.Usado para manter os tipos de dados básicos suportados pelo idioma.Os tipos primitivos não fazem parte da hierarquia de objetos e não herdam o objeto.Eles não podem ser passados ​​por referência a um método.

Double, Float, Long, Integer, Short, Byte, Character, e Boolean, são do tipo Wrappers, embalados em java.lang.Todos os wrappers de tipo numérico definem construtores que permitem que um objeto seja construído a partir de um determinado valor ou de uma representação de string desse valor.O uso de objetos pode adicionar uma sobrecarga até mesmo aos cálculos mais simples.

A partir do JDK 5, o Java incluiu dois recursos muito úteis:autoboxing e autounboxing.Autoboxing/unboxing simplifica e agiliza muito o código que deve converter tipos primitivos em objetos e vice-versa.

Exemplo de construtores:

Integer(int num)
Integer(String str) throws NumberFormatException
Double(double num)
Double(String str) throws NumberFormatException

Exemplo de boxe/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
    }
}

Exemplo de 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.O livro de Herbert Schildt foi tomado como referência.

interno é um tipo de dados primitivo.Inteiro é uma classe wrapper.Ele pode armazenar dados internos como objetos.

Uma variável int contém um valor inteiro com sinal de 32 bits.Um Inteiro (com I maiúsculo) contém uma referência a um objeto do tipo (classe) Inteiro ou nulo.

Java converte automaticamente entre os dois;de Integer para int sempre que o objeto Integer ocorre como um argumento para um operador int ou é atribuído a uma variável int, ou um valor int é atribuído a uma variável Integer.Esse casting é chamado de boxe/unboxing.

Se uma variável inteira que faz referência a nulo for retirada da caixa, explícita ou implicitamente, uma NullPointerException será lançada.

Um int e Integer em Java e C# são dois termos diferentes usados ​​para representar coisas diferentes.É um dos tipos de dados primitivos que podem ser atribuídos a uma variável que pode armazenar exatamente.Um valor do seu tipo declarado por vez.

Por exemplo:

int number = 7;

Onde int é o tipo de dados atribuído à variável number que contém o valor sete.Então um int é apenas um primitivo, não um objeto.

Enquanto um Integer é uma classe wrapper para um tipo de dados primitivo que possui métodos estáticos.Isso pode ser usado como argumento para um método que requer um objeto, enquanto as int pode ser usado como argumento para um método que requer um valor inteiro, que pode ser usado para expressões aritméticas.

Por exemplo:

Integer number = new Integer(5);

Em ambas as linguagens (Java e C#) int é um número inteiro assinado de 4 bytes.

Ao contrário do Java, C# fornece valores inteiros assinados e não assinados.Como Java e C# são orientados a objetos, algumas operações nessas linguagens não são mapeadas diretamente nas instruções fornecidas pelo tempo de execução e, portanto, precisam ser definidas como parte de algum tipo de objeto.

C# fornece System.Int32 que é um tipo de valor que usa uma parte da memória que pertence ao tipo de referência no heap.

java fornece java.lang.Integer que é um tipo de referência operando em int.Os métodos em Integer não pode ser compilado diretamente para instruções de tempo de execução. Portanto, colocamos um valor int para convertê-lo em uma instância de Integer e usamos os métodos que esperam uma instância de algum tipo (como toString(), parseInt(), valueOf() etc).

Em C#, a variável int refere-se a System.Int32.Any O valor de 4 bytes na memória pode ser interpretado como um int primitivo, que pode ser manipulado pela instância de System.Int32.So int é um alias para System.Int32.When usando métodos relacionados a números inteiros, como int.Parse(), int.ToString() etc.Inteiro é compilado no FCL System.Int32 struct chamando os respectivos métodos como Int32.Parse(), Int32.ToString().

Em Java, o int tipo é um tipo de dados primitivo, onde como o Integer tipo é um objeto.

Em C#, o int type também é um tipo de dados igual a System.Int32.Um integer (assim como qualquer outro tipo de valor) pode ser encaixado ("envolvido") em um objeto.

Em Java, int é um tipo de dados primitivo, enquanto Integer é uma classe auxiliar, é usada para converter um tipo de dados para outro.

Por exemplo:

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

Os tipos de dados primitivos armazenam a memória mais rápida disponível onde a classe Helper é complexa e armazenam na memória heep.

referência do treinamento Java Essential "David Gassner".

“int” é um tipo de dados primitivo e “Inteiro” na classe Wrapper em Java."Inteiro" pode ser usado como argumento para um método que requer um objeto, enquanto "int" pode ser usado como argumento para um método que requer um valor inteiro, que pode ser usado para expressões aritméticas.

01.O número inteiro pode ser nulo.Mas int não pode ser nulo.

Integer value1 = null; //OK

int value2 = null      //Error

02.Só pode passar valores do tipo Classes Wrapper para qualquer classe de coleção.

(Classes 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);

Mas normalmente adicionamos valores primitivos à classe de coleção?O ponto 02 está correto?

List<Integer> element = new ArrayList<>();
element.add(5);

Sim, 02 está correto, porque autoboxing.

O AutoBoxing é a conversão automática que o compilador Java faz entre o tipo primitivo e sua classe de wrapper correspondente.

Em seguida, 5 é convertido como valor inteiro por autoboxing.

int é predefinido na função de biblioteca c#, mas em java podemos criar objeto de Integer

(Versão java) em palavras simples int é primitiva e o número inteiro é um objeto de wrapper para int.

Um exemplo de onde usar Integer vs int. Quando você deseja comparar uma variável int novamente nula, ocorrerá um erro.

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

Em java, de acordo com meu conhecimento, se você for aluno, quando escrever int a;então em java genérico ele irá compilar código como Integer a = new Integer().Então, de acordo com os genéricos Integer não é usado, mas int é usado.então há tanta diferença aí.

Licenciado em: CC-BY-SA com atribuição
Não afiliado a StackOverflow
scroll top