Java和C＃中的int和Integer有什么区别？
当我遇到Joel Spolsky谈到一个特定类型的程序员知道int / int和Integer在Java / C＃（面向对象的编程语言）之间的区别时，我正在阅读更多关于Joel的软件 。
那么，有什么区别？
在Java中， “int”类型是一个原语，而“Integer”类型是一个对象。
在C＃中， “int”类型与System.Int32相同，并且是一个值类型 （即更像java的“int”）。 一个整数（就像任何其他值类型）可以被装箱 （“包装”）到一个对象。
对象和基元之间的差异超出了这个问题的范围，但是总结一下：
对象提供多态的功能，通过引用传递（或者更准确地说，引用通过值传递），并从堆中分配。 相反， 基元是不可变的类型，通过值传递，通常从堆栈中分配。
那么，在Java中，int是一个原语，而Integer是一个Object。 意思是，如果你做了一个新的整数：
Integer i = new Integer(6);
你可以调用我的一些方法：
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（）方法）。 所以整数是一个奇特的方式来处理一个整数（就像也许字符串是一个奇特的方式与一组字符）。
我知道Java不是C，但是因为我从来没有用C语言编程，所以这是最接近我的答案。 希望这可以帮助！
整数对象javadoc
整数Ojbect与int原始比较
我将添加上面给出的优秀答案，并谈论拳击和拆箱，以及这如何适用于Java（虽然C＃也有）。 我只会使用Java术语，因为我更喜欢这个。
正如所提到的答案， int只是一个数字（称为unboxed类型），而Integer是一个对象（包含数字，因此是一个盒装类型）。 在Java中，这意味着（除了不能在int上调用方法），你不能在集合（ List ， Map等）中存储int或其他非对象类型。 为了储存它们，你必须先将它们装入相应的盒装类型中。
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版本中简洁，两个版本都会生成相同的字节码。 因此，虽然自动装箱和自动拆箱非常方便，因为您编写的代码较少，但这些操作确实发生在幕后，运行成本相同，因此您仍然需要了解它们的存在。
希望这可以帮助！
我只是在这里发布，因为其他一些职位相对于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;
定义一个类型为System.Int32的变量i ，它存在于寄存器或堆栈中，具体取决于优化。 类型（结构或类）中的同一个声明定义了一个成员字段。 方法参数列表中的相同声明定义了一个参数，其中存储选项与局部变量相同。 （请注意，如果您开始将迭代器方法拉入混合中，则此段无效），这些是完全不同的野兽）
要获得一个堆对象，你可以使用装箱：
object o = i;
这将创建i在堆上的内容的盒装副本。 在IL中，您可以直接访问堆对象上的方法，但是在C＃中，您需要将其转换回为int，这将创建另一个副本。 因此，堆中的对象不能在C＃中轻易更改，而无需创建新的int值的新的盒装副本。 （呃，这一段不是那么容易读到的。）
关于Java 1.5和自动装箱 ，在比较Integer对象时，会出现一个重要的“怪癖”。
在Java中，值为-128到127的Integer对象是不可变的（也就是说，对于一个特定的整数值，例如23，所有通过程序实例化的整数对象，其值23指向完全相同的对象）。
例如，这将返回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上的示例
在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);
变量2作为基本整数类型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作为引用传递给保存整数值2的对象。
@WolfmanDragon：通过引用可以这样工作：
public void increment(int x) { x = x + 1; } int a = 1; increment(a); // a is now 2
当调用增量时，它将一个引用（指针）传递给变量a 。 增量函数直接修改变量a 。
而对于对象类型，它的工作原理如下：
public void increment(Integer x) { x = Integer.valueOf(x.intValue() + 1); } Integer a = Integer.valueOf(1); increment(a); // a is now 2
你现在看到了区别吗？
在C＃中，int只是System.Int32的别名 ， System.String字符串， System.Double double等…
我个人更喜欢int，string，double等，因为它们不需要using System; 声明:)一个愚蠢的原因，我知道…
在像Java这样的平台中， int s是原语，而Integer是一个包含整数字段的对象。 重要的区别在于，基元总是被价值传递，定义是不变的。
涉及基本变量的任何操作总是返回一个新的值。 另一方面，对象通过引用传递。 人们可以争辩说，指向对象（AKA的参考）也是通过价值传递，但内容不是。
int用于声明原始变量
eg int i=10;
整数用于创建Integer类的引用变量
Integer a = new Integer();
有很多理由使用包装类：
- 我们得到额外的行为（例如我们可以使用方法）
- 我们可以存储空值，而在原语中，我们不能
- 集合支持存储对象而不是基元。
这已经被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; }
还有一件事情，我没有在以前的答案中看到：在Java中，像Integer，Double，Float，Boolean …和String这样的原始包装类被认为是不变的，所以当你传递这些类的实例时，调用方法不能以任何方式改变你的数据，在opositión与其他大多数类，其内部的数据可以通过其公共方法改变。 所以这个类除了构造函数外，只有“getter”方法，没有“setter”。
在一个java程序中，字符串文字被存储在堆内存的一个单独的部分，只有一个实例用于文字，以节省内存重用这些实例
（int）是你可以为你的变量设置的原始类型之一（就像char，float，…）。
但整数是一个包装类，你可以用它来做一个int变量的函数（例如，将其转换为字符串或反之亦然，…），但请注意包装类中的方法是静态的，所以你可以使用它们任何时候都不需要创建一个Integer类的实例。 作为一个回顾：
int x; Integer y;
x和y都是int类型的变量，但是y被Integer类包装，并且有几个方法可以使用，但是如果你需要调用Integer包装类的一些函数，你可以简单的做。
Integer.toString(x);
但是请注意x和y都是corect，但是如果你想把它们作为一个原始类型来使用，就使用简单的形式（用于定义x）。
Java的：
int，double，long，byte，float，double，short，boolean，char – primitives。 用于保存该语言支持的基本数据类型。 原始类型不是对象层次结构的一部分，也不会继承Object。 可以通过参考方法来传递。
Double，Float，Long，Integer，Short，Byte，Character和Boolean是包装在java.lang中的类型包装器。 所有的数字类型包装器都定义了一个构造器，它允许一个对象从给定的值或者该值的字符串表示来构造。 使用对象可能会增加开销，甚至是最简单的计算。
从JDK 5开始，Java包含两个非常有用的功能：自动装箱和自动装箱。 自动装箱/拆箱可以大大简化和简化必须将原始类型转换为对象的代码，反之亦然。
构造函数的例子：
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 } }
PS Herbert Schildt的书作为参考。
Java和C＃中的int和Integer是用于表示不同事物的两个不同的术语。 它是可以分配给可以精确存储的变量的原始数据类型之一。 一次声明其类型的一个值。
例如：
int number = 7;
其中int是分配给保存值为7的变量号的数据类型。 所以int只是一个原语而不是一个对象。
Integer是具有静态方法的基本数据类型的包装类。 这可以用作需要对象的方法的参数，其中int可以用作需要整数值的方法的参数，可以用于算术表达式。
例如：
Integer number = new Integer(5);
在这两种语言（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.So的实例来操作。int是System.Int32的别名。当使用integer-相关的方法如int.Parse() ， int.ToString()等int.ToString()被编译成FCL System.Int32结构体，调用Int32.Parse() ， Int32.ToString()等各自的方法。
在Java中， int类型是原始数据类型， Integer类型是一个对象。
在C＃中， int类型也是与System.Int32相同的数据类型。 一个integer （就像任何其他值类型）可以被装箱（“包装”）到一个对象。
一个int变量保存一个32位有符号整数值。 整数（大写I）持有对（类）类型为Integer的对象的引用，或者为null。
Java自动在两者之间转换; 从Integer到int，只要Integer对象作为int运算符的参数出现，或者被赋值给int变量，或者int值赋给Integer变量。 这个铸造被称为装箱/拆箱。
如果引用null的Integer变量被显式或隐式地解除封装，则抛出NullPointerException。
在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基础培训。
int是在库函数c＃中预定义的，但在java中我们可以创建整数的oject
“int”是Java中的Wrapper类中的原始数据类型和“整数”。 “整数”可用作需要对象的方法的参数，其中“int”可用作需要整数值的方法的参数，可用于算术表达式。
在java中，根据我的知识，如果你学习的话，当你写int a; 那么在Java通用它将编译像整数a =新整数的代码。 所以，按照泛型整数不使用，但使用int。 所以这里有这样的差别。
