我在看书 当我遇到 Joel Spolsky的时候，更多关于软件的 Joel》，他说了一种有关特定类型的程序员的一些知识，他们知道Java / C＃（面向对象的编程语言）中anint和an之间的区别Integer。
那么区别是什么呢？
Answers:
在Java中， “ int”类型是基元，而“ Integer”类型是对象。
在C＃中， “ int”类型System.Int32与值类型相同，并且是值类型（即更像Java的“ int”类型）。可以将整数（就像任何其他值类型一样）装箱（“包装”）到对象中。
对象和基元之间的区别在某种程度上超出了此问题的范围，但可以总结一下：
对象为多态提供了便利，通过引用传递（或更准确地说，通过值传递引用），并从堆中分配对象。相反，基元是不可变的类型，它们按值传递，并且通常是从堆栈分配的。
好吧，在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可能是使用一组char的一种理想方式）一样。
我知道Java不是C，但是由于我从未使用C编程，因此这是我能找到的最接近的答案。希望这可以帮助！
我将添加到上面给出的出色答案中，并讨论装箱和拆箱，以及它如何适用于Java（尽管C＃也是如此）。因为我比较，我会用纯Java术语AU既成事实这一点。
作为答案中提到，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版本简短，但是两个版本都生成相同的字节码。因此，尽管自动装箱和自动拆箱非常方便，因为您只需编写较少的代码，但是这些操作确实在幕后发生，并且运行时成本相同，因此您仍然必须意识到它们的存在。
希望这可以帮助！
我将仅在此处发布，因为其他一些帖子相对于C＃来说有点不准确。
正确： int是的别名System.Int32。
错误： float不是的别名System.Float，而是的别名System.Single
基本上，int是C＃编程语言中的保留关键字，并且是System.Int32值类型的别名。
float和Float是不同的，因为“”的正确系统类型float是System.Single。像这样的某些类型具有保留的关键字，这些关键字似乎与类型名称不直接匹配。
在C＃中，除了定义枚举时，int“”和“” System.Int32或其他任何对或关键字/系统类型之间没有区别。使用枚举，您可以指定要使用的存储大小，在这种情况下，您只能使用reserved关键字，而不能使用系统运行时类型名称。
是否将int中的值存储在堆栈中，内存中还是作为引用的堆对象取决于上下文以及如何使用它。
该声明的方法：
int i;定义一个变量 i类型，System.Int32位于寄存器中或堆栈中，具体取决于优化。类型（结构或类）中的同一声明定义一个成员字段。方法参数列表中的相同声明定义了一个参数，具有与局部变量相同的存储选项。（请注意，如果您开始将迭代器方法引入组合中，则本段无效，因为它们完全是不同的野兽）
要获取堆对象，可以使用装箱：
object o = i;这将i在堆上创建盒装内容的副本。在IL中，您可以直接访问堆对象上的方法，但是在C＃中，您需要将其强制转换回int，这将创建另一个副本。因此，如果不创建新的int值的新框式副本，就无法在C＃中轻松更改堆上的对象。（糟糕，本段内容并不太容易理解。）
关于Java 1.5和自动装箱，比较Integer对象时有一个重要的“怪癖”起作用。
在Java中，值-128到127的Integer对象是不可变的（也就是说，对于一个特定的整数值（例如23），通过程序实例化的所有Integer对象的值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)); // truejava.net上的更多信息bexhuff.com上的示例
127是从sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
在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。而增量函数直接修改变量一个。
对于对象类型，它的工作方式如下：
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等...
我个人更喜欢int，string，double等，因为它们不需要using System;声明:)一个愚蠢的原因，我知道...
对于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;
}int用于声明原始变量
e.g. int i=10;Integer用于创建Integer类的引用变量
Integer a = new Integer();您曾经编程过吗（int）是可以为变量设置的原始类型之一（就像char，float等）。
但是Integer是包装器类，您可以使用它对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-图元。用于保存语言支持的基本数据类型。基本类型不属于对象层次结构，并且它们不继承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的书被作为参考。
一个int变量保存一个32位带符号整数值。一个Integer（大写I）持有对（类）Integer类型的对象的引用，或对null的引用。
Java自动在两者之间进行转换。从Integer到int，只要Integer对象作为int运算符的参数出现或被分配给int变量，或将int值分配给Integer变量。这种转换称为装箱/拆箱。
如果将引用null的Integer变量显式或隐式取消装箱，则将引发NullPointerException。
Java和C＃中的int和Integer是用于表示不同事物的两个不同术语。它是可以分配给可以精确存储的变量的原始数据类型之一。一次声明其类型的一个值。
例如：
int number = 7;其中int，分配给变量编号的数据类型是七，它的值是。因此，an int只是一个原始而不是一个对象。
而an Integer是具有静态方法的原始数据类型的包装器类。可以将其用作需要对象的方法的参数，而将int用作需要整数值的方法的参数，可以将其用于算术表达式。
例如：
Integer number = new Integer(5);在两种语言（Java和C＃）中，int都是4字节有符号整数。
与Java不同，C＃提供有符号和无符号整数值。由于Java和C＃是面向对象的对象，因此这些语言中的某些操作不会直接映射到运行时提供的指令上，因此需要将其定义为某种类型的对象的一部分。
C＃System.Int32使用属于堆上引用类型的一部分内存提供了一种值类型。
java提供java.lang.Integer了在上运行的引用类型int。在这些方法Integer不能instructions.So我们框中int值把它转换成整数的实例，并使用它期望某种类型的实例方法（如直接编译运行时间toString()，parseInt()，valueOf()等）。
在C＃变量int是指System.Int32.Any4字节的值在存储器中可被解释为一种原始INT，可以由System.Int32.So INT的实例被操纵为别名System.Int32.When使用整数相关方法一样int.Parse()，int.ToString()等等整数被编译成整箱System.Int32结构像调用相应的方法Int32.Parse()，Int32.ToString()。
在Java中，int类型是原始数据类型，其中Integer类型是对象。
在C＃中，int类型也是与相同的数据类型System.Int32。的integer（就像任何其他值类型）可被盒装（“包装”）转换成一个对象。
在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基础培训。
01.整数可以为null。但是int不能为null。
Integer value1 = null; //OK
int value2 = null //Error02.仅可以将Wrapper类的类型值传递给任何集合类。
（包装类-布尔，字符，字节，短整数，整数，长整数，浮点数，双精度）
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是正确的，因为 autoboxing.
自动装箱是Java编译器在原始类型及其对应的包装器类之间进行的自动转换。
然后5通过自动装箱将其转换为整数值。
int 是在库函数c＃中预定义的，但在Java中我们可以创建对象 Integer
（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...}据我所知，在Java中，如果您是学习者，那么在编写int时就可以了；然后在Java泛型中将编译类似的代码Integer a = new Integer()。因此，Integer不使用泛型，而是int使用了。所以那里是如此不同。
int是原始数据类型。 整数是包装器类。它可以将int数据存储为对象。