爪哇和C的整数和整数的区别是什么?

在Java中, “int”类型是基元,而“integer”类型是对象。

在C, “int”类型与 System.Int32 而且是 a value type (更像Java'int)。整数(就像任何其他值类型一样)可以是 boxed (包装)成一个物体。

对象和原语之间的差异在一定程度上超出了这个问题的范围,但要总结一下:

物体 为多态性提供工具,通过引用传递(或者更准确地说,通过值传递引用),并从 heap . 相反地, 基元 是通过值传递的不可变类型,通常从 stack .

在Java中,int是一个本原,而整数是一个对象。也就是说,如果您生成了一个新的整数:

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%确定,但我认为整数对象或多或少有一个int属性和一组与该属性交互的方法(例如toString()方法)。所以整数是一种处理int的奇特方法(就像字符串是处理一组char的奇特方法一样)。

我知道Java不是C,但是因为我从来没有用C编程,这是我最接近的答案。希望这有帮助!

Integer object javadoc

Integer Ojbect vs. int primitive comparison

我将添加上面给出的优秀答案,并讨论拳击和解题,以及如何应用于Java(尽管C语言也有)。我会使用JAVA术语,因为我更 澳菲特 就这样。

正如上面提到的答案, 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编程语言中的保留关键字,是 系统32 值类型。

但是,float和float与“”的正确系统类型不同。 浮动 “”是System.Single。有一些这样的类型具有保留的关键字,这些关键字似乎与类型名称不直接匹配。

在c中,“”之间没有区别 int “和” 系统32 “”,或任何其他对或关键字/系统类型,定义枚举时除外。使用枚举可以指定要使用的存储大小,在这种情况下,只能使用保留关键字,而不能使用系统运行时类型名称。

int中的值将存储在堆栈、内存中,还是作为引用的堆对象存储,这取决于上下文和您如何使用它。

方法中的此声明:

int i;

定义变量 i 类型的 系统32 ,在寄存器或堆栈中,取决于优化。类型(结构或类)中的同一声明定义了成员字段。方法参数列表中的同一声明定义了一个参数,与局部变量具有相同的存储选项。(请注意,如果您开始将迭代器方法拉入混合中,则此段落无效,这些方法完全是不同的野兽)

要获取堆对象,可以使用装箱:

object o = i;

这将创建 我 堆上。在IL中,您可以直接访问堆对象上的方法,但在C中,您需要将其转换回int,这将创建另一个副本。因此,如果不创建新int值的新装箱副本,堆上的对象就无法在c中轻松更改。(啊,这段话读起来不那么容易。)

关于Java 1.5和 autoboxing 在比较整数对象时,有一个很重要的“怪癖”。

在爪哇中,值为128到127的整数对象是不可变的(也就是说,对于一个特定的整数值,如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.equals()方法。

System.out.println(i1.equals(i2)); //  true

更多信息 java.net 例 bexhuff.com

在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和整数之间的另一个区别是它们如何在方法调用中传递。例如在

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的对象的引用传递。

@ WolfmanDragon: 传递引用的工作方式如下:

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

你现在看到区别了吗?

在c中,int只是一个 别名 对于 System.Int32 字符串 System.String 双倍的 System.Double 等。。。

我个人喜欢int、string、double等,因为它们不需要 using System; 声明:)一个愚蠢的理由,我知道…

使用包装类有很多原因:

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

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 是包含整数字段的对象。重要的区别在于原语总是按值传递,并且按定义传递是不可变的。

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

爪哇:

int , double , long , byte , float , 双重的 , short , boolean , char -基元。用于保存基本数据类型 语言支持。基元类型不是 对象层次结构,它们不继承对象。不能通过引用传递给方法。

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

P.S.Herbert Schildt的书作为参考。

还有一件事我在之前的回答中没有看到: 在Java中,原始包装类如整数、双、浮点、布尔…字符串被认为是不变的,所以当你传递这些类的一个实例时,被调用的方法不能以任何方式改变你的数据,在opositi_3 n中,与大多数其他类一起,内部数据可以被它的公共方法改变。这样,除了构造函数之外,这个类只有“getter”方法,没有“setters”。

在Java程序中,字符串文本存储在堆内存的单独部分中,仅用于文本的实例,以保存内存重用这些实例。

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

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

int x;
Integer y; 

x和y都是int类型的变量,但是y被一个整型类包装,并且有几个方法可以使用,但是我想您需要调用整型包装类的一些函数,您可以简单地做到这一点。

Integer.toString(x);

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

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

Java自动在两个之间进行转换;每当整数对象作为int参数出现或被分配给int变量时,从整数到int,或者int值被赋给整型变量。这种铸造称为装箱/拆箱。

如果引用空值的整数变量未绑定、显式或隐式,则会引发NullPointerException。

爪哇和C中的int和整数是用来表示不同事物的两个不同的术语。它是一种基本数据类型,可以分配给一个可以精确存储的变量。一次一个声明类型的值。

例如:

int number = 7;

在哪里? int 是分配给保存值7的变量号的数据类型。所以一个 int 只是一个原语而不是一个物体。

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

例如:

Integer number = new Integer(5);

在两种语言中(Java语言和C语言) int 是4字节有符号整数。

与Java不同,C语言提供了有符号和无符号整数值。由于Java和C语言是面向对象的,所以这些语言中的某些操作不直接映射到运行时提供的指令,因此需要定义为某种类型的对象的一部分。

C提供 System.Int32 它是使用属于堆上引用类型的内存部分的值类型。

Java提供 java.lang.Integer 它是在 int . 中的方法 Integer 无法直接编译为运行时指令。因此,我们将一个int值框起来,将其转换为整数实例,并使用需要某种类型的实例的方法(如 toString() , parseInt() , valueOf() 等)。

在c变量int中指 System.Int32.Any 内存中的4字节值可以解释为基元int,它可以由System.Int32的实例操作。因此int是的别名 System.Int32.When 使用整数相关的方法,如 int.Parse() , int.ToString() 等,整数被编译成fcl 系统32 结构调用各自的方法,如 Int32.Parse() , Int32.ToString() .

在Java中 int 类型是基元数据类型,其中 Integer 类型是一个对象。

在C语言中, int 类型也是与相同的数据类型 System.Int32 . 安 integer (就像其他值类型一样)可以装箱(“包装”)到对象中。

Java INT是一种原始数据类型,而整数是辅助类,它用于将一种数据类型转换为其他类型。

例如:

double doubleValue = 156.5d;
Double doubleObject  = new Double(doubleValue);
Byte myByteValue = doubleObject.byteValue ();
String myStringValue = doubleObject.toString();

原始数据类型存储最快的可用内存,其中helper类比较复杂,并存储在heep内存中。

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

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

int 在函数库C中是预先定义的,但是在Java中我们可以创建对象 Integer

(Java版本) 简单来说,int是基元,integer是int的包装对象。

举一个例子,当您想再次比较int变量为空时,使用integer和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不能为空。

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通过自动氧化转换为整数值。

在Java中,根据我的知识,如果你学习者,当你写int A时,那么在Java泛型中,它将编译代码。 Integer a = new Integer() . 所以,根据一般性 Integer 不使用但 int 使用。 所以有这么大的区别。