在Java和c#中，int和Integer的区别是什么?

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

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

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

例如，返回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的更多信息

在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传递。而在

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的对象。

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

当increment被调用时，它传递一个指向变量一个的引用(指针)。而增量函数直接修改变量一个。

对于对象类型，它的工作方式如下:

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

现在你看到区别了吗?

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

在Java等平台中，__abc0是基本类型，而Integer是一个包含整数字段的对象。重要的区别是，原语总是通过值传递，并且通过定义是不可变的。

任何涉及基本变量的操作总是返回一个新值。另一方面，对象是通过引用传递的。有人可能会说指向对象的点(又名引用)也通过值传递，但内容不是。

Int用于声明原始变量

e.g. int i=10;

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

Integer a = new Integer();

你以前编程过吗? (int)是你可以为变量设置的基本类型之一(就像char, float，…)

int x;
Integer y;

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

Integer.toString(x);

但请注意，x和y都是正确的，但如果您想将它们仅作为基本类型使用，请使用简单形式(用于定义x)。

在这两种语言(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()等。Integer被编译成FCL System.Int32结构体，调用相应的方法，如Int32.Parse()， Int32.ToString()。

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

1. 我们得到了额外的行为(例如，我们可以使用方法)
2. 我们可以存储空值，而在原语中则不能
3. 集合支持存储对象，而不支持存储原语。

在Java和c#中，int和Integer是用来表示不同事物的两个不同术语。它是可以赋值给可以精确存储的变量的基本数据类型之一。每次只声明其类型的一个值。

例如:

int number = 7;

其中int是赋给值为7的变量number的数据类型。所以int只是一个原语而不是一个对象。

而Integer是具有静态方法的基元数据类型的包装器类。That可以用作需要对象的方法的参数，其中as int可以用作需要整数值的方法的参数，可用于算术表达式。

例如:

Integer number = new Integer(5);

int变量保存一个32位有符号整数值。Integer(大写I)保存对(类)类型Integer或null对象的引用。

Java自动在两者之间进行类型转换;当Integer对象作为int操作符的参数出现，或者被赋值给int变量，或者一个int值被赋值给Integer变量时，从Integer到int。这种类型转换称为装箱/解装箱。

如果一个引用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类是复杂的，存储在heep内存中。

参考“David Gassner”Java基本训练。

Java:

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

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

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

附注:赫伯特·斯希尔特的书被作为参考。

在java中，根据我的知识，如果你学习然后，当你写int;然后在java泛型中，它将编译类似Integer a = new Integer()的代码。 因此，根据泛型，Integer没有被使用，而int被使用。 所以这里有这样的区别

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

在Java中，int类型是一个基本数据类型，而Integer类型是一个对象。

在c#中，int类型也是与System.Int32相同的数据类型。integer(就像任何其他值类型一样)可以被装箱(“包装”)到对象中。

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

一个使用Integer和int的例子，当你想比较int变量时，它会抛出错误。

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

01. 整数可以为空。但是int不能为null。

Integer value1 = null; //OK


int value2 = null      //Error

02. 只能将包装器类类型值传递给任何集合类。

(包装类-布尔，字符，字节，短，整数，长，浮动，双)

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是基本数据类型。 >是一个包装器类。它可以将int型数据存储为对象。