Java和C＃中的int和Integer有什么区别？


What is the difference between an int and an Integer in Java and C#?

我在软件上阅读了更多关于乔尔的文章，当我遇到Joel Spolsky时，他谈到了一个特定类型的程序员，他知道EDCOX1 0和爪哇中的EDCX1 1之间的区别(面向对象的编程语言)。

那么，有什么区别呢？

相关讨论

在Java中，"int"类型是一个原语，而"整数"类型是一个对象。

在C++中，"int"类型与EDCOX1(0)相同，是一种值类型(更类似于Java‘int’)。整数(就像任何其他值类型一样)可以装箱("包装")到对象中。

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

对象提供多态性的工具，通过引用传递(或者更准确地说，通过值传递引用)，并从堆中分配。相反，基元是通过值传递的不可变类型，通常从堆栈中分配。

相关讨论

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

1
Integer i = new Integer(6);

你可以在i上调用一些方法：

1
String s = i.toString();//sets s the string representation of i

鉴于，对于int：

1
int i = 6;

不能对它调用任何方法，因为它只是一个原语。所以：

1
String s = i.toString();//will not work!!!

会产生错误，因为int不是对象。

INT是Java中的少数原语之一(连同char和其他一些)。我不是100%确定，但我认为整数对象或多或少有一个int属性和一组与该属性交互的方法(例如toString()方法)。所以整数是一种处理int的奇特方法(就像字符串是处理一组char的奇特方法一样)。

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

整数对象javadoc

整数ojbect与int原语比较

相关讨论

我将添加上面给出的优秀答案，并讨论拳击和解题，以及如何应用于Java(尽管C语言也有)。我只会使用Java术语，因为我对此更感兴趣。

正如前面提到的答案，int只是一个数字(称为未装箱类型)，而Integer是一个对象(包含数字，因此是装箱类型)。在Java术语中，这意味着(除了不能调用int中的方法)，不能在集合中存储EDCOX1、5或其他非对象类型(EDCOX1、9、EDCX1、10、等等)。为了存储它们，必须首先将它们装箱到相应的装箱类型中。

Java 5有一种叫做自动装箱和自动解包的东西，它允许在后台进行装箱/拆箱。比较和对比：Java 5版本：

1
2
3
4
5
6
7
8
9
Deque<Integer> queue;

void add(int n) {
    queue.add(n);
}

int remove() {
    return queue.remove();
}

Java 1.4或更早版本(无泛型)：

1
2
3
4
5
6
7
8
9
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中，"EDOCX1"(0)和"EDOCX1"(1)或任何其他对或关键字/系统类型之间没有区别，定义枚举时除外。使用枚举可以指定要使用的存储大小，在这种情况下，只能使用保留关键字，而不能使用系统运行时类型名称。

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

方法中的此声明：

1
int i;

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

要获取堆对象，可以使用装箱：

1
object o = i;

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

关于Java 1.5和自动装箱，当比较整数对象时，有一个重要的"奇特"。

在爪哇中，值为128到127的整数对象是不可变的(也就是说，对于一个特定的整数值，如23，所有整数对象通过程序实例化，值23点到完全相同的对象)。

例如，这将返回true：

1
2
3
Integer i1 = new Integer(127);
Integer i2 = new Integer(127);
System.out.println(i1 == i2); //  true

当返回false时：

1
2
3
Integer i1 = new Integer(128);
Integer i2 = new Integer(128);
System.out.println(i1 == i2); //  false

==参照比较(变量是否指向同一对象)。

根据您使用的是什么JVM，这个结果可能不同，也可能不同。Java 1.5的规范自动装箱要求整数(-128到127)总是对同一包装对象进行装箱。

解决方案？=)比较整数对象时，应始终使用integer.equals()方法。

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

更多信息请访问java.net示例：bexhuff.com

相关讨论

在Java中，JVM中有两种基本类型。1)基元类型和2)引用类型。int是基元类型，integer是类类型(这是一种引用类型)。

基元值不与其他基元值共享状态。类型为基元类型的变量始终保存该类型的基元值。

1
2
3
4
int aNumber = 4;
int anotherNum = aNumber;
aNumber += 6;
System.out.println(anotherNum); // Prints 4

对象是动态创建的类实例或数组。引用值(通常只是引用)是指向这些对象的指针，以及一个特殊的空引用，它不引用任何对象。可能有许多对同一对象的引用。

1
2
3
Integer aNumber = Integer.valueOf(4);
Integer anotherNumber = aNumber; // anotherNumber references the
                                 // same object as aNumber

同样在Java中，所有的东西都是通过值传递的。对于对象，传递的值是对对象的引用。因此，在Java中int和整数之间的另一个区别是它们如何在方法调用中传递。例如在

1
2
3
4
5
public int add(int a, int b) {
    return a + b;
}
final int two = 2;
int sum = add(1, two);

变量2作为基元整数类型2传递。而在

1
2
3
4
5
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作为对保存整数值2的对象的引用传递。

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

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

当调用increment时，它将一个引用(指针)传递给变量A。increment函数直接修改变量A。

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

1
2
3
4
5
6
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的double等。

就我个人而言，我更喜欢int、string、double等，因为它们不需要using System;语句：)一个愚蠢的理由，我知道…

相关讨论

使用包装类有很多原因：

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

    • int用于声明基元变量

    1
    e.g. int i=10;

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

    1
    Integer a = new Integer();

    Java已经回答了这个问题，这里是C的答案：

    "integer"不是C中的有效类型名，"int"只是System.Int32的别名。此外，与Java(或C++)不同，C语言中没有任何特殊的基元类型，C类型(包括int)中的每一个实例都是一个对象。下面是一些演示代码：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    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这样的平台中，EDCOX1×0的S是基元，而EDCOX1×1是一个包含整数字段的对象。重要的区别是，原语总是按值传递，按定义传递是不可变的。

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

    相关讨论

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

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

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

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

    1
    2
    int x;
    Integer y;

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

    1
    Integer.toString(x);

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

    Java语言：

    intdoublelongbyte，，，，float，double，short，boolean，primitives char-。用于保持在基本数据类型支持的语言。该部分的原始类型是不对象层次结构，和他们不可继承的对象。他们不能被路过的方法参考。

    doublefloatlongInteger，，，，short，byte，Character和boolean型，是在java.lang包装，包装。所有的数值类型的构造函数定义了允许的包装对象，一是构建了从给定的值的字符串表示形式，或者说值。使用对象可以添加到架空的简(盈亏平衡点计算。

    用JAVA JDK 5开始，包括两个非常有特点：自动装箱和autounboxing helpful。自动装箱/拆箱和streamlines是大大simplifies代码必须转换为原始类型的对象，和反之亦然。

    例子：构造函数

    1
    2
    3
    4
    Integer(int num)
    Integer(String str) throws NumberFormatException
    Double(double num)
    Double(String str) throws NumberFormatException

    例子：装箱/拆箱

    1
    2
    3
    4
    5
    6
    7
    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
        }
    }

    例子：自动装箱/ autounboxing

    1
    2
    3
    4
    5
    6
    7
    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
        }
    }

    赫伯特：schildt’s Book是考虑的参考。

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

    例如：

    1
    int number = 7;

    其中，int是分配给变量号的数据类型，该变量号保存值7。因此，一个int只是一个原语，而不是一个物体。

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

    例如：

    1
    Integer number = new Integer(5);

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

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

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

    在Java中，int型是原始数据类型，在一个对象的Integer型。

    在C型#，int是日期型的System.Int32也一样。一Integer(就像其他任何值类型)，可以装进一("包")的对象。

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

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

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

    Java提供了EDCOX1×2的引用，这是一个在EDCOX1(0)中运行的引用类型。由于Integer中的方法不能直接编译成运行时指令，因此我们将一个in t值装箱，将其转换为整数实例，并使用希望得到某种类型实例的方法(如toString()、parseInt()、valueOf()等)。

    在c variable int中，变量int指的是内存中的System.Int32.Any4字节的值，可以解释为原始int，可以通过system.int32的实例来操作。因此int是System.Int32.When的别名，使用与整数相关的方法，如int.Parse()、int.ToString()等。整数编译到fcl System.Int32结构中，调用各自的方法。像Int32.Parse()和Int32.ToString()这样的DS。

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

    例如：

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

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

    参考"David Gassner"Java基本训练。

    这些库函数C是在int#但我们可以创建一个Java对象Integer

    是"国际"和"原始数据类型包装类的整数中的"Java"。"可以用一个整数参数的方法，对面向对象的要求，在"int"可以用来对这一问题的方法，需要的是整型值，可以使用算术表达式。

    01。整数可以为空。但不能为空。

    1
    2
    3
    Integer value1 = null; //OK

    int value2 = null      //Error

    02。的CAN型封装类，仅通值的任何集合类。

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

    1
    2
    3
    4
    List<Integer> element = new ArrayList<>();
    int valueInt = 10;
    Integer  valueInteger = new Integer(value);
    element.add(valueInteger);

    但我们通常添加到原始值的集合类？02点是正确的吗？

    1
    2
    List<Integer> element = new ArrayList<>();
    element.add(5);

    02是一autoboxing.是正确的，因为

    Autoboxing is the automatic conversion that the java compiler makes
    between the primitive type and their corresponding wrapper class.

    然后转换成整数的值由5自动装箱。

    java学习的知识，如果你按我的来，然后当你写一个Java类，它将编译码Integer a = new Integer()样。是的，但不是每Integerint泛型的使用，是用。操作系统的操作系统，如有差存在。

    相关讨论

    (JAVA版)在简单的话，是原始的int是整数int对象和包装它。

    在一个例子使用的整数与int，int当你想比较一变空，它将距离误差。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    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...}