Question

当我遇到More Joel on Software时，我正在阅读 Joel Spolsky ，说明某种类型的程序员知道int和{{1}之间的区别在Java / C＃（面向对象的编程语言）中。

那么，有什么区别？

Answer 1

在Java中，'int'类型是基元，而'Integer'类型是对象。

在C＃中，'int'类型与System.Int32相同，并且是a value type（即更像java'int'）。整数（就像任何其他值类型一样）可以boxed（“换行”）到对象中。

对象和基元之间的差异有些超出了这个问题的范围，但总结一下：

对象提供多态性的工具，通过引用传递（或者更准确地说，通过值传递引用），并从heap分配。相反，原语是按值传递的不可变类型，通常从stack分配。

Answer 2

嗯，在Java中，int是基元，而Integer是Object。意思是，如果你做了一个新的整数：

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中编程，所以这是我能得到答案的最接近的。希望这有帮助！

Integer object javadoc

Integer Ojbect vs. int primitive comparison

Answer 3

我将添加上面给出的优秀答案，并讨论装箱和拆箱，以及这如何适用于Java（尽管C＃也有）。我将只使用Java术语，因为我更喜欢 au fait 。

正如所提到的答案，int只是一个数字（称为未装箱的类型），而Integer是一个对象（包含数字，因此是盒装类型）。在Java术语中，这意味着（除了无法调用int上的方法），您无法在集合中存储int或其他非对象类型（List，{{1}等等）。为了存储它们，您必须先将它们装入相应的盒装类型中。

Java 5以后有一些名为自动装箱和自动拆箱的东西，它允许在幕后进行装箱/拆箱。比较和对比：Java 5版本：

Map

Java 1.4或更早版本（也没有泛型）：

Deque<Integer> queue;

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

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

必须注意的是，尽管Java 5版本简洁，但两个版本都生成相同的字节码。因此，尽管自动装箱和自动拆箱非常方便，因为您编写的代码较少，但这些操作做在幕后发生，运行成本相同，因此您仍需要了解它们的存在

希望这有帮助！

Answer 4

我会在这里发帖，因为其他一些帖子与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，这将创建另一个副本。因此，如果不创建新int值的新盒装副本，则无法在C＃中轻松更改堆上的对象。（呃，这一段并不容易理解。）

Answer 5

关于Java 1.5和autoboxing，在比较Integer对象时会有一个重要的“怪癖”。

在Java中，值为-128到127的Integer对象是不可变的（也就是说，对于一个特定的整数值，比如23，所有通过程序实例化的Integer对象，其值为23，指向 exact 同一个对象）。

示例，返回true：

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

上的示例

Answer 6

在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中，所有内容都按值传递。对于对象，传递的值是对象的引用。因此java中int和Integer之间的另一个区别是它们在方法调用中的传递方式。例如在

中

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

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

变量 two 作为对包含整数值2的对象的引用传递。

@WolfmanDragon：通过引用传递将如下工作：

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

当调用increment时，它将引用（指针）传递给变量 a 。 increment 函数直接修改变量 a 。

对于对象类型，它将按如下方式工作：

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

你现在看到了区别吗？

Answer 7

在C＃中，int只是System.Int32的别名，System.String的字符串，System.Double的双倍等。

我个人更喜欢int，string，double等，因为它们不需要using System;语句:)一个愚蠢的理由，我知道......

Answer 8

使用包装类的原因有很多：

我们获得了额外的行为（例如我们可以使用方法）
我们可以存储空值，而在原语中我们不能
集合支持存储对象而非基元。

Answer 9

在像Java这样的平台中，int是原始的，而Integer是一个包含整数字段的对象。重要的区别在于原语总是按值传递，按定义是不可变的。

任何涉及原始变量的操作总是返回一个新值。另一方面，对象通过引用传递。有人可能会争辩说，对象的指向（参考的AKA）也是按值传递的，但内容却没有。

Answer 10

int用于声明原始变量

e.g. int i=10;

Integer用于创建Integer类的引用变量

Integer a = new Integer();

Answer 11

这已经得到了Java的回答，这是C＃答案：

“Integer”不是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;
}

Answer 12

Java：

int，double，long，byte，float，double，short，boolean ，char - 原语。用于保存基本数据类型语言支持。原始类型不属于对象层次结构，它们不继承Object。它可以通过引用传递给方法。

Double，Float，Long，Integer，Short，Byte，Character和{{1}是类型Wrappers，打包在Boolean中。所有数值类型包装器都定义了构造函数，这些构造函数允许从给定值构造对象，或者使用该值的字符串表示形式。即使是最简单的计算，使用对象也会增加开销。

从JDK 5开始，Java包含两个非常有用的功能：autoboxing和autounboxing。自动装箱/拆箱大大简化并简化了必须将原始类型转换为对象的代码，反之亦然。

构造函数示例：

java.lang

装箱/拆箱示例：

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

P.S。 Herbert Schildt的书被作为参考。

Answer 13

我在之前的答案中没有看到的另一件事：在Java中，原始包装类（如Integer，Double，Float，Boolean ...和String）是不变的，因此当您传递这些类的实例时，调用的方法无法以任何方式更改您的数据，在opositión中与大多数其他类一样，内部数据可以通过其公共方法进行更改。因此，除了构造函数之外，这些类只有'getter'方法，没有'setter'。

在java程序中，字符串文字存储在堆内存的单独部分中，只有文字实例，以节省重用这些实例的内存

Answer 14

你之前编程过吗（int）是你可以为变量设置的原始类型之一（就像char，float，...）。

但是Integer是一个包装类，您可以使用它来对int变量执行某些函数（例如将其转换为字符串或反之亦然，...），但请注意包装类中的方法是静态的，因此您可以随时使用它们而无需创建Integer类的实例。作为回顾：

int x;
Integer y;

x和y都是int类型的变量，但是y由Integer类包装并且有几个你使用的方法，但是我需要调用一些Integer包装类的函数，你可以简单地完成它。

Integer.toString(x);

但要注意x和y都是corect，但如果你想将它们用作基本类型，请使用简单形式（用于定义x）。

Answer 15

在两种语言（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()。

Answer 16

Java和C＃中的int和Integer是用于表示不同内容的两个不同术语。它是可以分配给可以精确存储的变量的原始数据类型之一。一次声明类型的一个值。

例如：

int number = 7;

其中int是分配给保存值7的变量号的数据类型。所以int只是一个原语而不是一个对象。

虽然Integer是具有静态方法的原始数据类型的包装类。这可以用作需要对象的方法的参数，其中int可以用作需要整数值的方法的参数，可以用于算术表达式。

例如：

Integer number = new Integer(5);

Answer 17

int变量保存32位有符号整数值。 Integer（使用大写I）保存对（类）Integer类型的对象的引用，或者为null。

Java自动在两者之间进行转换;每当Integer对象作为int运算符的参数出现或被赋值给int变量，或者int值被赋值给Integer变量时，从Integer到int。这个演员称为装箱/拆箱。

如果引用null的Integer变量被显式或隐式地取消装箱，则抛出NullPointerException。

Answer 18

在Java中，handler(date) { console.log(this.params) if (date.start) { this.params.from = moment(date.start, "YYYY/MM/DD") } if (date.end) { this.params.to = moment(date.end, "YYYY/MM/DD") } }.bind(this)类型是原始数据类型，其中int类型是对象。

在C＃中，Integer类型也是与int相同的数据类型。 System.Int32（就像任何其他值类型一样）可以装箱（“包装”）到对象中。

Answer 19

在Java中，int是一种原始数据类型，而Integer是一个Helper类，它用于将一种数据类型转换为另一种数据类型。

例如：

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

原始数据类型存储Helper类复杂且存储在内存中的最快可用内存。

来自“David Gassner”Java Essential Training的参考资料。

Answer 20

int是在库函数c＃中预定义的，但在java中我们可以创建Integer的对象

Answer 21

“int”是原始数据类型，Java中的Wrapper类是“Integer”。 “Integer”可以用作需要对象的方法的参数，其中“int”可以用作需要整数值的方法的参数，可以用于算术表达。

Answer 22

在java中根据我的知识，如果你学习的话，当你写一个int;然后在java泛型中，它将编译像Integer a = new Integer()这样的代码。因此，根据泛型Integer未使用，但使用int。所以那里存在这样的差异。

Answer 23

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

Answer 24

<强> 01。整数可以为null。但是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.

Autocoxing是java编译器自动转换在原始类型和它们对应的包装类之间。

然后通过自动装箱将5转换为整数值。

Answer 25

int 是原始数据类型。 Integer 是包装器类。它可以将int数据存储为对象。

Answer 26

int是原始数据类型，而Integer是对象。使用Integer创建对象将使您可以访问Integer类中可用的所有方法。但是，如果使用int创建原始数据类型，则将无法使用这些inbuild方法，而必须自己定义它们。但是，如果您不希望使用任何其他方法并希望提高程序的内存使用效率，则可以使用原始数据类型，因为创建对象会增加内存消耗。

Java和C＃中的int和Integer有什么区别？

26 个答案: