Java 和 C# 中 int 和 Integer 有什么区别?
题
我正在读书 更多 Joel 关于软件的内容 当我遇到 乔尔·斯波尔斯基 谈论特定类型的程序员,了解不同类型的程序员之间的区别 int
和 Integer
Java/C#(面向对象编程语言)。
那么区别是什么呢?
其他提示
嗯,在 Java 中,int 是基元,而 Integer 是对象。意思是,如果你创建了一个新的整数:
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 编程过,所以这是我能得到的最接近的答案。希望这可以帮助!
我将补充上面给出的出色答案,并讨论装箱和拆箱,以及这如何应用于 Java(尽管 C# 也有)。我将仅使用 Java 术语,因为我更了解 事实 接着就,随即。
正如答案提到的, int
只是一个数字(称为 拆箱的 类型),而 Integer
是一个对象(其中包含数字,因此 盒装的 类型)。用 Java 术语来说,这意味着(除了无法调用方法之外) int
),你不能存储 int
或集合中的其他非对象类型(List
, Map
, , ETC。)。为了存储它们,您必须首先将它们装入相应的盒装类型中。
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;
定义一个变量 i
类型的 System.Int32
, ,位于寄存器或堆栈中,具体取决于优化。类型(结构或类)中的相同声明定义成员字段。方法参数列表中的相同声明定义了一个参数,具有与局部变量相同的存储选项。(请注意,如果您开始将迭代器方法纳入混合中,则本段无效,这些完全是不同的野兽)
要获取堆对象,可以使用装箱:
object o = i;
这将创建内容的盒装副本 i
在堆上。在 IL 中,您可以直接访问堆对象上的方法,但在 C# 中,您需要将其强制转换回 int,这将创建另一个副本。因此,在 C# 中,如果不创建新 int 值的新装箱副本,则无法轻松更改堆上的对象。(呃,这一段读起来不太容易。)
关于 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 示例位于 bexhuff.com
在Java中有两种基本类型 虚拟机. 。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
当调用增量时,它会将引用(指针)传递给变量 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
ETC...
我个人更喜欢 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();
在Java这样的平台上, int
s 是原语,而 Integer
是一个包含整数字段的对象。重要的区别是原语总是按值传递,并且根据定义是不可变的。
任何涉及原始变量的操作总是返回一个新值。另一方面,对象是通过引用传递的。有人可能会争辩说,对象的指向(又名引用)也是通过值传递的,但内容却不是。
我在之前的答案中没有看到的另一件事:在 Java 中,原始包装类如 Integer、Double、Float、Boolean...和 String 应该是不变的,因此当您传递这些类的实例时,调用的方法不能以任何方式更改您的数据,与大多数其他类相反,内部数据可以通过其公共方法更改。因此,除了构造函数之外,此类只有“getter”方法,没有“setter”。
在java程序中,字符串文字存储在堆内存的单独部分中,仅存储文字的一个实例,以节省内存重用这些实例
您以前编程过吗? (int) 是您可以为变量设置的基本类型之一(就像 char、float 等)。
但 Integer 是一个包装类,您可以使用它对 int 变量执行一些函数(例如,将其转换为字符串,反之亦然,...),但请注意包装类中的方法是静态的,因此您可以使用它们随时无需创建 Integer 类的实例。回顾一下:
int x;
Integer y;
x 和 y 都是 int 类型的变量,但 y 由 Integer 类包装,并且有多种您使用的方法,但如果您需要调用 Integer 包装类的一些函数,您可以简单地做到这一点。
Integer.toString(x);
但请注意,x 和 y 都是正确的,但如果您想将它们用作基本类型,请使用简单形式(用于定义 x)。
爪哇:
int
, double
, long
, byte
, float
, double
, short
, boolean
, char
- 基元。用于保存语言支持的基本数据类型。原始类型不是对象层次结构的一部分,也不是继承对象。它们可以通过引用方法来传递。
Double
, Float
, Long
, Integer
, Short
, Byte
, Character
, , 和 Boolean
, ,是 Wrappers 类型,封装在 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 的书被用作参考。
整数 是一种原始数据类型。整数 是一个包装类。它可以将 int 数据存储为对象。
int 变量保存 32 位有符号整数值。Integer(大写 I)保存对(类)类型 Integer 的对象或 null 的引用。
Java 自动在两者之间进行转换;每当 Integer 对象作为 int 运算符的参数出现或分配给 int 变量,或者将 int 值分配给 Integer 变量时,从 Integer 到 int。这种铸造称为装箱/拆箱。
如果引用 null 的 Integer 变量被显式或隐式取消装箱,则会引发 NullPointerException。
Java 和 C# 中的 int 和 Integer 是两个不同的术语,用于表示不同的事物。它是可以分配给可以精确存储的变量的原始数据类型之一。一次一个其声明类型的值。
例如:
int number = 7;
在哪里 int
是分配给变量 number 的数据类型,该变量保存值 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()
ETC)。
在C#中变量int指的是 System.Int32.Any
内存中的 4 字节值可以解释为原始 int,可以通过 System.Int32 的实例进行操作。因此 int 是 System.Int32.When
使用与整数相关的方法,例如 int.Parse()
, int.ToString()
ETC。整数编译成FCL System.Int32
结构体调用各自的方法,例如 Int32.Parse()
, Int32.ToString()
.
在Java中, int
type 是原始数据类型,其中 Integer
类型是一个对象。
在 C# 中, int
type 也是一种数据类型,与 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 Essential Training。
“int”是原始数据类型,“Integer”是Java中的包装类。“Integer”可以用作需要对象的方法的参数,而“int”可以用作需要整数值的方法的参数,可用于算术表达式。
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.
Autoboxing是Java编译器在原始类型和相应的包装器类之间进行的自动转换。
然后 5 通过自动装箱转换为整数值。
int
在 C# 库函数中预定义,但在 Java 中我们可以创建对象 Integer
(Java版本)简单单词Int是原始的,整数是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...}
在java中,根据我的知识,如果你是学习者,那么当你写 int a; 时然后在java generic中它将编译如下代码 Integer a = new Integer()
。所以,根据泛型 Integer
没有被使用但是 int
用来。所以那里有如此大的差异。