Java和C#中的int和Integer有什么区别?

时间:2008-08-02 21:47:35

标签: c# java integer int

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

那么,有什么区别?

26 个答案:

答案 0 :(得分:233)

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

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


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

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

答案 1 :(得分:147)

嗯,在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

答案 2 :(得分:37)

我将添加上面给出的优秀答案,并讨论装箱和拆箱,以及这如何适用于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版本简洁,但两个版本都生成相同的字节码。因此,尽管自动装箱和自动拆箱非常方便,因为您编写的代码较少,但这些操作在幕后发生,运行成本相同,因此您仍需要了解它们的存在

希望这有帮助!

答案 3 :(得分:28)

我会在这里发帖,因为其他一些帖子与C#有些不准确。

正确: intSystem.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#中轻松更改堆上的对象。 (呃,这一段并不容易理解。)

答案 4 :(得分:19)

关于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

上的示例

答案 5 :(得分:19)

在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

你现在看到了区别吗?

答案 6 :(得分:11)

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

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

答案 7 :(得分:9)

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

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

答案 8 :(得分:8)

这已经得到了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;
}

答案 9 :(得分:8)

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

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

答案 10 :(得分:8)

int用于声明原始变量

e.g. int i=10;

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

Integer a = new Integer();

答案 11 :(得分:7)

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

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

int x;
Integer y; 

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

Integer.toString(x);

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

答案 12 :(得分:7)

Java:

intdoublelongbytefloatdoubleshortbooleanchar - 原语。用于保存基本数据类型 语言支持。原始类型不属于 对象层次结构,它们不继承Object。它可以通过引用传递给方法。

DoubleFloatLongIntegerShortByteCharacter和{{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的书被作为参考。

答案 13 :(得分:7)

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

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

答案 14 :(得分:4)

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

答案 15 :(得分:4)

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

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

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

答案 16 :(得分:4)

在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(就像任何其他值类型一样)可以装箱(“包装”)到对象中。

答案 17 :(得分:4)

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

例如:

int number = 7;

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

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

例如:

Integer number = new Integer(5);

答案 18 :(得分:3)

在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的参考资料。

答案 19 :(得分:1)

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

答案 20 :(得分:1)

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

答案 21 :(得分:0)

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

答案 22 :(得分:0)

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

答案 23 :(得分:0)

<强> 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转换为整数值。

答案 24 :(得分:0)

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

答案 25 :(得分:0)

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