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

godio 发布于 2018-02-04 c# 最后更新 2018-02-04 01:03 944 浏览

当我遇到Joel Spolsky说PLACEHOLDER_FOR_CODE_1和Integer(在面向对象的编程语言)之间的区别时,我正在阅读 More Joel on Software 。 那么区别是什么呢?

已邀请:

vomnis

赞同来自:

在Java中,类型是一个基元,而“整数”类型是一个对象。 在C#中,int类型与System.Int32相同,并且是a value type(即更像java的int)。一个整数(就像任何其他值类型)可以boxed(“包装”)到一个对象。


对象和基元之间的差异超出了这个问题的范围,但是总结一下: 对象为多态性提供工具,通过引用传递(或者更准确地说,引用通过值传递),并从heap中分配。相反,基元是通过值传递的不可变类型,通常从stack分配。

lnulla

赞同来自:

那么,在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语言编程,所以这是最接近我的答案。希望这可以帮助! Integer object javadoc Integer Ojbect vs. int primitive comparison

malias

赞同来自:

在C#中,int只是System.Int32的一个 alias System.String的字符串,System.Double的两倍等。 我个人更喜欢int,string,double等,因为它们不需要using System;语句:)一个愚蠢的理由,我知道...

eomnis

赞同来自:

我将添加上面给出的优秀答案,并谈论拳击和拆箱,以及这如何适用于Java(虽然C#也有)。我将只使用Java术语,因为我更强调这一点。 正如所提到的答案,int只是一个数字(称为 unboxed 类型),而Integer是一个对象(包含数字,因此是盒装类型)。用Java术语来说,这意味着(除了不能在int上调用方法),不能在集合中存储int或其他非对象类型(ListMap等)。为了储存它们,你必须先将它们装入相应的盒装类型中。 Java 5以后有一些叫做 auto-boxing auto-unboxing 的功能,允许在后台完成装箱/拆箱操作。比较和对比: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版本中简洁,两个版本都会生成相同的字节码。因此,尽管自动装箱和自动拆箱非常方便,因为您编写的代码少,这些操作 do 发生在后台,运行成本相同,所以您仍然需要知道它们的存在。 希望这可以帮助!

oad

赞同来自:

我只是在这里发布,因为其他一些职位相对于C#稍微不准确。 正确: intSystem.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值的新的盒装副本。 (呃,这一段不是那么容易读到的。)

pullam

赞同来自:

这已经被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;
}

sit_in

赞同来自:

关于Java 1.5和autoboxing,在比较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上的示例

hiure

赞同来自:

在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传递。而in
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
当调用增量时,它会将参考(指针)传递给变量 a 增量函数直接修改变量 a 。 而对于对象类型,它的工作原理如下:
public void increment(Integer x) {
  x = Integer.valueOf(x.intValue() + 1);
}
Integer a = Integer.valueOf(1);
increment(a);
// a is now 2
你现在看到了区别吗?

faut

赞同来自:

还有一件事,我没有在以前的答案中看到: 在Java中,像Integer,Double,Float,Boolean ...和String这样的原始包装类被认为是不变的,所以当你传递这些类的实例时,被调用的方法不能以任何方式改变你的数据,在opositión与其他大多数类别一样,内部数据可以通过公共方法进行修改。所以这个类除了构造函数外,只有“getter”方法,没有“setter”。 在一个java程序中,字符串文字被存储在堆内存的一个单独的部分,只有一个实例用于文字,以节省内存重用这些实例

yeum

赞同来自:

在像Java这样的平台中,ints是原语,而Integer是一个包含整数字段的对象。重要的区别在于,基元总是被价值传递,定义是不变的。 涉及基本变量的任何操作总是返回一个新的值。另一方面,对象通过引用传递。人们可以争辩说,指向对象(AKA的参考)也是通过价值传递,但内容不是。

siure

赞同来自:

int用于声明原始变量

e.g. int i=10;
整数用于创建Integer类的引用变量
Integer a = new Integer();

tin

赞同来自:

(int)是你可以为你的变量设置的原始类型之一(就像char,float,...)。 但整数是一个包装类,你可以用它来做一个int变量的函数(例如,将其转换为字符串或反之亦然,...),但请注意包装类中的方法是静态的,所以你可以使用它们任何时候都不需要创建一个Integer类的实例。 作为一个回顾:

int x;
Integer y; 
x和y都是int类型的变量,但是y被Integer类包装,并且有几个方法可以使用,但是如果你需要调用Integer包装类的一些函数,你可以简单地使用它。
Integer.toString(x);
但是请注意,x和y都是corect,但是如果您想将它们作为基本类型使用,请使用简单形式(用于定义x)。

taut

赞同来自:

在这两种语言(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.When的别名,使用与int.Parse()int.ToString()等整型相关的方法。将整数编译到FCL System.Int32结构中,调用诸如Int32.Parse()Int32.ToString()等各自的方法。

grem

赞同来自:

有很多理由使用包装类:

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

jalias

赞同来自:

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

int number = 7;
其中int是分配给保存值为7的变量号码的数据类型。所以int只是一个原语而不是对象。 而Integer是具有静态方法的原始数据类型的包装类。这可以用作需要对象的方法的参数,其中int可以用作需要整数值的方法的参数,可以用于算术表达式。 例如:
Integer number = new Integer(5);

funde

赞同来自:

一个int变量保存一个32位有符号整数值。整数(大写I)持有对(类)类型为Integer的对象的引用,或者为null。 Java自动在两者之间转换;从Integer到int,只要Integer对象作为int运算符的参数出现,或者被赋值给int变量,或者int值赋给Integer变量。这个铸造被称为装箱/拆箱。 如果引用null的Integer变量被显式或隐式地拆箱,则抛出NullPointerException。

fet

赞同来自:

在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基础培训。

jeum

赞同来自:

爪哇: 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
    }
}
附: Herbert Schildt的书作为参考。

prerum

赞同来自:

在java中,根据我的知识,如果你学习的话,当你写int a;那么在Java通用它将编译像整数a =新整数的代码。 所以,按照泛型整数不使用,但使用int。 所以这里有这样的差别。

jsed

赞同来自:

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

sest

赞同来自:

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

lmagni

赞同来自:

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