Qual é a diferença entre um int e um número inteiro em Java e C #?

Eu estava lendo More Joel on Software quando me deparei com Joel Spolsky dizendo algo sobre um tipo específico de programador sabendo a diferença entre an inte an Integerem Java / C # (Linguagens de Programação Orientadas a Objetos).

Então qual é a diferença?

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

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

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

Os objetos fornecem facilidades para o polimorfismo, são passados ​​por referência (ou mais precisamente, têm referências passadas por valor) e são alocados do heap . Por outro lado, primitivas são tipos imutáveis ​​que são passados ​​por valor e geralmente são alocados da pilha .

Bem, em Java, um int é um primitivo, enquanto um Inteiro é um Objeto. Ou seja, se você criou um novo número inteiro:

Integer i = new Integer(6);

Você pode 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, porque é simplesmente um primitivo. Assim:

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

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

int é uma das poucas primitivas em Java (junto com char e algumas outras). 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, Inteiro é uma maneira elegante de trabalhar com um int (da mesma forma que String é uma maneira elegante de trabalhar com um grupo de caracteres).

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

Objeto inteiro javadoc

Ojbect inteiro vs. comparação primitiva int

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

Como as respostas mencionadas, inté apenas um número (chamado tipo sem caixa ), enquanto que Integeré um objeto (que contém o número, portanto, um tipo caixa ). Em termos de Java, isso significa que (para além de não ser capaz de chamar métodos int), você não pode armazenar intou outros tipos não-objeto em coleções ( List, Map, etc.). Para armazená-los, você deve primeiro encaixotá-los no tipo de encaixe correspondente.

Java 5 em diante têm algo chamado auto-boxing e auto-unboxing que permitem que o boxe / unboxing a ser 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 na versão Java 5, ambas as versões geram bytecode idêntico. Assim, embora auto-boxing e auto-unboxing são muito convenientes porque você escrever menos código, essas operações fazem acontece nos bastidores, com os mesmos custos de tempo de execução, então você ainda tem que estar ciente de sua existência.

Espero que isto ajude!

Vou postar aqui, já que algumas das outras postagens são um pouco imprecisas em relação ao C #.

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

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

No entanto, float e Float não são os mesmos, pois o tipo de sistema correto para '' float'' é System.Single. Existem alguns tipos como este que reservaram palavras-chave que parecem não corresponder diretamente aos nomes dos tipos.

No C #, não há diferença entre '' int'' e '' System.Int32'', ou qualquer outro par ou palavra-chave / tipo de sistema, exceto ao definir enumerações. Com enumerações, você pode especificar o tamanho do armazenamento a ser usado e, nesse 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 de heap referenciado, depende do contexto e de como você o usa.

Esta declaração em um método:

int i;

define uma variável ido tipo System.Int32, vivendo em um registro ou na pilha, dependendo das otimizações. A mesma declaração em um tipo (estrutura ou classe) define um campo de membro. A mesma declaração em uma lista de argumentos do método define um parâmetro, com as mesmas opções de armazenamento que para uma variável local. (observe que este parágrafo não é válido se você começar a colocar os métodos do iterador na mistura, são bestas completamente diferentes)

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

object o = i;

isso criará uma cópia em caixa do conteúdo da ipilha. Na IL, você pode acessar os métodos diretamente no objeto heap, mas no C # é necessário convertê-lo novamente em um int, o que criará outra cópia. Portanto, o objeto no heap não pode ser alterado facilmente em C # sem criar uma nova cópia em caixa de um novo valor int. (Ugh, este parágrafo não lê tudo tão facilmente.)

Em relação ao Java 1.5 e à autoboxing, existe uma "peculiaridade" importante que ocorre quando se compara 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 pelo seu programa com o valor 23 pontos exatamente para o mesmo objeto).

Exemplo, isso retorna verdadeiro:

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

Enquanto isso retorna false:

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

Esse resultado pode ou não diferir dependendo da JVM que você está usando. A caixa de seleção automática de especificação para Java 1.5 requer que números inteiros (-128 a 127) sempre encaixotem no mesmo objeto de wrapper.

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

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

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

Em Java, existem dois tipos básicos na JVM . 1) Tipos primitivos e 2) Tipos de referência. int é um tipo primitivo e Inteiro é um tipo de classe (que é o tipo de tipo de referência).

Valores primitivos não compartilham estado com outros valores primitivos. Uma variável cujo tipo é um tipo primitivo sempre manté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 uma matriz. 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 que é passado é a referência ao objeto. Portanto, outra diferença entre int e Inteiro em java é como eles são transmitidos em 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 two é passada como o número inteiro primitivo 2. Enquanto 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 two é passada como uma referência a um objeto que contém o valor inteiro 2.

@WolfmanDragon: Passar por referência funcionaria assim:

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

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

E para tipos de objetos, funcionaria da seguinte maneira:

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 alias para System.Int32, string para System.String, double para System.Doubleetc ...

Pessoalmente, prefiro int, string, double, etc., porque eles não exigem uma using System;declaração :) Uma razão boba, eu sei ...

Há muitos motivos para usar classes de wrapper:

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

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

"Inteiro" não é um nome de tipo válido em C # e "int" é apenas um alias para System.Int32. Além disso, diferentemente do Java (ou C ++), não existem tipos primitivos especiais em C #, todas as instâncias de um tipo em C # (incluindo int) são 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 primitivas enquanto Integeré um objeto que contém um campo inteiro. A distinção importante é que as primitivas são sempre repassadas por valor e por definição são imutáveis.

Qualquer operação que envolva uma variável primitiva sempre retorna um novo valor. Por outro lado, os objetos são passados ​​por referência. Alguém poderia 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 de wrappers primitivas como Integer, Double, Float, Boolean ... e String devem ser invariáveis, de modo que, quando você passa uma instância dessas classes, a chamada O método não pode alterar seus dados de nenhuma maneira, em oposição à maioria das outras classes, cujos dados internos podem ser alterados por seus métodos públicos. Para que essas classes tenham apenas métodos 'getter', sem 'setters', além do construtor.

Em um programa Java, literais de seqüência de caracteres são armazenados em uma parte separada da memória heap, apenas uma instância para 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 ​​(como char, float, ...).

mas Integer é uma classe de wrapper que você pode usá-lo para executar algumas funções em uma variável int (por exemplo, convertê-lo em string ou vice-versa, ...), mas observe que os métodos nas classes de wrapper são estáticos e 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 é agrupado por uma classe Integer e possui vários métodos que você usa, mas, caso precise chamar algumas funções da classe Wrapper Integer, você pode fazê-lo simplesmente.

Integer.toString(x);

mas lembre-se de que xey são corretos, mas se você quiser usá-los apenas como um tipo primitivo, use o formato simples (usado para definir x).

Java:

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

Double, Float, Long, Integer, Short, Byte, Character, E Boolean, são do tipo envoltórios, 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 uma representação de string desse valor. O uso de objetos pode adicionar uma sobrecarga até para os cálculos mais simples.

A partir do JDK 5, o Java incluiu dois recursos muito úteis: caixa automática e caixa automática. A caixa automática / unboxing simplifica e simplifica bastante 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 caixa automática / caixa automática:

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

O livro de PS Herbert Schildt foi tomado como referência.

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

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

Se uma variável inteira referenciando nulo estiver fora da caixa, explícita ou implicitamente, uma NullPointerException será lançada.

Um int e um inteiro 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 de seu tipo declarado por vez.

Por exemplo:

int number = 7;

Onde inté o tipo de dados atribuído ao número da variável que contém o valor sete. Portanto, an inté apenas um primitivo, não um objeto.

Enquanto an Integeré uma classe de 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 int pode ser usado como argumento para um método que requer um valor inteiro, que pode ser usado para expressão aritmética.

Por exemplo:

Integer number = new Integer(5);

Nos dois idiomas (Java e C #) inthá um número inteiro assinado de 4 bytes.

Diferentemente de 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 um objeto de algum tipo.

O C # fornece System.Int32um tipo de valor usando uma parte da memória que pertence ao tipo de referência no heap.

java fornece java.lang.Integerqual é um tipo de referência operando int. Os métodos Integernão podem ser compilados diretamente para executar tempo instructions.So que caixa um valor int para convertê-lo em uma instância de Integer e usar os métodos que espera instância de algum tipo (como toString(), parseInt(),valueOf() etc.).

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

Em Java, o inttipo é um tipo de dados primitivo, onde, como o Integertipo é um objeto.

Em C #, o inttipo também é um tipo de dados igual a System.Int32. Um integer(como qualquer outro tipo de valor) pode ser encaixotado ("empacotado") em um objeto.

Em Java, int é um tipo de dados primitivo, enquanto Integer é uma classe Helper, é usado para converter um tipo de dado em 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 disponível mais rápida, onde a classe Helper é complexa e armazenam na memória heep.

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

"int" é do 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ão aritmética.

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

Integer value1 = null; //OK

int value2 = null      //Error

02. Somente podem passar valores de tipo Wrapper Classes para qualquer classe de coleção.

(Classes de wrapper - Booleano, Caractere, Byte, Curto, Inteiro, Longo, Flutuante, Duplo)

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, beacouse autoboxing.

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

Em seguida, 5 converta como valor inteiro por caixa automática.

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

(Versão Java) Em palavras simples, int é primitivo e Inteiro é um objeto de invólucro para int.

Um exemplo onde usar Integer vs int. Quando você deseja comparar e a variável int novamente nula, isso gera 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ê aprender, quando escrever int a; então em java genérico ele irá compilar código como Integer a = new Integer(). Portanto, conforme os genéricos, Integernão é usado, mas inté usado. então há tanta diferença lá.

int é um tipo de dados primitivo. Inteiro é uma classe de invólucro. Ele pode armazenar dados int como objetos.

int é um tipo de dados primitivo, enquanto Integer é um objeto. Criar um objeto com Inteiro dará acesso a todos os métodos disponíveis na classe Inteiro. Mas, se você criar um tipo de dados primitivo com int, não poderá usar esses métodos inbuild e precisará defini-los sozinho. Mas, se você não deseja outros métodos e deseja tornar o programa mais eficiente em memória, pode usar o tipo de dados primitivo, pois a criação de um objeto aumentará o consumo de memória.