Java와 C #에서 int와 Integer의 차이점은 무엇입니까?

내가 읽고 있던 소프트웨어에 대한 자세한 조엘를 내가 가로 질러 왔을 때 Spolsky 조엘 사이의 차이를 아는 프로그래머의 특정 유형에 대해 뭔가 말을 int하고 Integer자바 / C #에서을 (객체 지향 프로그래밍 언어).

그렇다면 차이점은 무엇입니까?

Java 에서 'int'유형은 기본이고 'Integer'유형은 객체입니다.

C # 에서 'int'형식은 값 형식System.Int32 과 동일 하며 값 형식입니다 (예 : java 'int'와 유사). 정수 (다른 값 유형과 마찬가지로 )를 개체에 상자 로 묶을 수 있습니다 ( "랩핑").

객체와 프리미티브의 차이점은이 질문의 범위를 벗어나지 만 요약하면 다음과 같습니다.

객체 는 다형성을위한 기능을 제공하고 참조로 전달되거나보다 정확하게 참조로 전달되며 힙 에서 할당됩니다 . 반대로 프리미티브 는 값에 의해 전달되고 종종 스택 에서 할당되는 불변 유형입니다 .

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로 프로그래밍 한 적이 없으므로 이것이 가장 가까운 대답입니다. 도움이 되었기를 바랍니다!

정수 객체 javadoc

정수 Ojbect 대 int 기본 비교

위에서 언급 한 훌륭한 답변에 덧붙여 권투와 언 박싱에 대해 이야기하고 이것이 C에 어떻게 적용되는지에 대해 이야기 할 것입니다 (C #에도 마찬가지 임). 좀 더이기 때문에 난 그냥 자바 용어를 사용합니다 노소 기정 그와 함께.

언급 한 답변 int은 숫자 ( unboxed type 이라고 함 )이지만 Integer객체 (숫자, 따라서 boxed type)를 포함합니다. 자바 측면에서, 그 수단 (떨어져 메소드를 호출 할 수 없다는에서이 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 버전의 간결함에도 불구하고 두 버전 모두 동일한 바이트 코드를 생성합니다. 따라서 자동 복싱과 자동 Unboxing은 코드를 적게 작성하기 때문에 매우 편리하지만 이러한 작업 은 동일한 런타임 비용으로 뒤에서 발생하므로 여전히 존재해야합니다.

도움이 되었기를 바랍니다!

다른 게시물 중 일부는 C #과 관련하여 약간 부정확하므로 여기에 게시하겠습니다.

올바른 : int 의 별칭입니다 System.Int32.
잘못됨 : float 에 대한 별칭이 아니지만에 대한 별칭입니다 System.Float.System.Single

기본적으로 int는 C # 프로그래밍 언어로 예약 된 키워드이며 System.Int32값 유형 의 별칭입니다 .

'' float'' 의 올바른 시스템 유형 은 System.Single 이므로 float 및 Float는 동일하지 않습니다 . 유형 이름과 직접 일치하지 않는 키워드를 예약 한 유형이 있습니다.

C #에서는 열거 형을 정의 할 때를 제외하고 '' int''및 '' System.Int32''또는 다른 쌍 또는 키워드 / 시스템 유형 간에 차이가 없습니다 . 열거 형을 사용하면 사용할 스토리지 크기를 지정할 수 있으며이 경우 시스템 런타임 유형 이름이 아닌 reserved 키워드 만 사용할 수 있습니다.

int의 값이 스택, 메모리 또는 참조 힙 객체로 저장되는지 여부는 컨텍스트와 사용 방법에 따라 다릅니다.

메소드의 선언 :

int i;

최적화에 따라 레지스터 또는 스택에있는 itype 의 변수 를 정의합니다 System.Int32. 유형 (struct 또는 클래스)에서 동일한 선언은 멤버 필드를 정의합니다. 메소드 인수 목록의 동일한 선언은 로컬 변수와 동일한 스토리지 옵션을 사용하여 매개 변수를 정의합니다. (이 단락은 반복기 메소드를 믹스로 가져 오기 시작하면 유효하지 않습니다. 이것은 모두 다른 짐승입니다)

힙 객체를 얻으려면 권투를 사용할 수 있습니다.

object o = i;

이것은 i힙에 내용의 박스 복사본을 만듭니다 . IL에서는 힙 객체의 메서드에 직접 액세스 할 수 있지만 C #에서는이를 int로 다시 캐스팅해야합니다. 그러면 다른 복사본이 만들어집니다. 따라서 힙에있는 객체는 새로운 int 값의 새 박스 복사본을 만들지 않고 C #에서 쉽게 변경할 수 없습니다. (이 단락은 모든 것을 쉽게 읽을 수는 없습니다.)

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

이것이 거짓을 반환하는 동안 :

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에는 JVM 에 두 가지 기본 유형이 있습니다 . 1) 기본 유형 및 2) 참조 유형. int는 기본 유형이고 Integer는 클래스 유형 (일종의 참조 유형)입니다.

기본 값은 다른 기본 값과 상태를 공유하지 않습니다. 유형이 기본 유형 인 변수는 항상 해당 유형의 기본 값을 보유합니다.

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

객체는 동적으로 생성 된 클래스 인스턴스 또는 배열입니다. 참조 값 (종종 참조)은 이러한 객체에 대한 포인터이며 객체가없는 특수 null 참조입니다. 동일한 객체에 대한 많은 참조가있을 수 있습니다.

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

또한 Java에서는 모든 것이 가치에 의해 전달됩니다. 객체의 경우 전달 된 값이 객체에 대한 참조입니다. 따라서 자바에서 int와 Integer의 또 다른 차이점은 메소드 호출에서 어떻게 전달되는지입니다. 예를 들어

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

변수 2 는 기본 정수 유형 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 는 정수 값 2를 보유한 객체에 대한 참조로 전달됩니다.

@ WolffDragon : 참조로 전달하면 다음과 같이 작동합니다.

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등 ...

개인적으로 나는 using System;진술이 필요하지 않기 때문에 int, string, double 등을 선호합니다 . :) 어리석은 이유, 나는 알고 있습니다 ...

랩퍼 클래스를 사용하는 데는 여러 가지 이유가 있습니다.

1. 우리는 추가 행동을 얻습니다 (예를 들어 우리는 방법을 사용할 수 있습니다)
2. 우리는 null 값을 저장할 수 있지만 프리미티브에서는 할 수 없습니다
3. 콜렉션은 기본 요소가 아닌 오브젝트 저장을 지원합니다.

이것은 이미 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;
}

int는 기본 변수를 선언하는 데 사용됩니다

e.g. int i=10;

Integer는 Integer 클래스의 참조 변수를 만드는 데 사용됩니다

Integer a = new Integer();

Java와 같은 플랫폼에서 ints는 프리미티브이고 Integer정수 필드를 보유하는 객체입니다. 중요한 차이점은 프리미티브가 항상 값으로 전달되고 정의에 의해 변경 될 수 없다는 것입니다.

기본 변수와 관련된 모든 작업은 항상 새로운 값을 반환합니다. 반면에 객체는 참조로 전달됩니다. 객체에 대한 포인트 (일명 참조)도 가치에 의해 전달되고 있지만 내용은 그렇지 않다고 주장 할 수 있습니다.

이전 답변에서 볼 수없는 한 가지 더 : Java에서는 Integer, Double, Float, Boolean ... 및 String과 같은 기본 래퍼 클래스가 변경되지 않으므로 해당 클래스의 인스턴스를 전달할 때 호출 된 메소드는 대부분의 다른 클래스와는 달리 어떤 방식 으로든 데이터를 변경할 수 없었으며, 내부 데이터는 공용 메소드에 의해 변경 될 수 있습니다. 따라서이 클래스에는 생성자 외에도 'getter'메서드 만 있으며 'setter'는 없습니다.

자바 프로그램에서 문자열 리터럴은 해당 인스턴스를 재사용하는 메모리를 절약하기 위해 힙 메모리의 별도 부분에 리터럴 인스턴스로 저장됩니다.

그 전에 프로그래밍 한 적이 있습니까 (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, 패키지로, 래퍼를 입력 할 수 있습니다java.lang . 모든 숫자 유형 랩퍼는 주어진 값 또는 해당 값의 문자열 표현으로 오브젝트를 구성 할 수있는 생성자를 정의합니다. 객체를 사용하면 가장 간단한 계산에도 오버 헤드가 추가 될 수 있습니다.

JDK 5부터 Java에는 두 가지 매우 유용한 기능인 autoboxing과 autounboxing이 포함되었습니다. 오토 박싱 / 언 박싱은 기본 유형을 객체로 변환하거나 그 반대로 변환해야하는 코드를 크게 단순화하고 간소화합니다.

생성자의 예 :

Integer(int num)
Integer(String str) throws NumberFormatException
Double(double num)
Double(String str) throws NumberFormatException

권투 / unboxing의 예 :

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

PS Herbert Schildt의 책은 참고로 사용되었습니다.

int 변수는 32 비트 부호있는 정수 값을 보유합니다. Integer (자본 I 포함)는 (class) 유형 Integer의 오브젝트에 대한 참조 또는 널을 보유합니다.

자바는 자동적으로 둘 사이에 캐스트를한다; Integer 객체가 int 연산자에 대한 인수로 발생하거나 int 변수에 할당되거나 int 값이 Integer 변수에 할당 될 때마다 Integer에서 int로 이 캐스팅을 박싱 / 언 박싱이라고합니다.

null을 참조하는 Integer 변수가 명시 적으로 또는 암시 적으로 언 박싱 된 경우 NullPointerException이 발생합니다.

Java와 C #의 int와 Integer는 서로 다른 것을 나타내는 데 사용되는 두 가지 용어입니다. 정확하게 저장할 수있는 변수에 할당 할 수있는 기본 데이터 유형 중 하나입니다. 한 번에 선언 된 유형의 하나의 값.

예를 들면 다음과 같습니다.

int number = 7;

int값이 7 인 변수 번호에 지정된 데이터 유형은 어디에 있습니까 ? 따라서 inta는 객체가 아닌 프리미티브입니다.

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 값을 상자 instructions.So 캔없는 시간을 실행에 직접 컴파일 toString(), parseInt(), valueOf()등).

C #에서 변수 INT가 참조 System.Int32.AnySystem.Int32.So의 INT의 인스턴스에 의해 조작 될 수있는 프리미티브 INT로 해석 할 수있는 메모리의 4 바이트 값은, 별명 인 System.Int32.When정수 관련 방법이 좋아하여 int.Parse(), int.ToString()정수로 컴파일 등 FCL이는 System.Int32등, 각 메소드를 호출 구조체 Int32.Parse(), Int32.ToString().

Java에서 int유형은 기본 데이터 유형이며 여기서 Integer유형은 오브젝트입니다.

C #에서 int형식은와 동일한 데이터 형식 System.Int32입니다. integer(다른 모든 값 유형 등)으로 물체 ( "래핑")을 박스형 수있다.

Java에서 int는 기본 데이터 유형이고 Integer는 도우미 클래스이며 한 데이터 유형을 다른 데이터 유형으로 변환하는 데 사용됩니다.

예를 들면 다음과 같습니다.

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

기본 데이터 유형은 Helper 클래스가 복잡하고 heep 메모리에 저장되는 가장 빠른 사용 가능한 메모리를 저장합니다.

"David Gassner"Java Essential Training에서 참조하십시오.

"int"는 Java의 랩퍼 클래스에서 기본 데이터 유형 및 "정수"입니다. "정수"는 객체를 필요로하는 메소드에 대한 인수로 사용될 수 있으며, "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 맞습니다, beacouse autoboxing.

오토 박싱은 자바 컴파일러가 프리미티브 유형과 해당 래퍼 클래스 사이에서 자동으로 변환하는 것입니다.

그런 다음 5는 오토 박싱에 의해 정수 값으로 변환됩니다.

int 라이브러리 함수 c #에 미리 정의되어 있지만 Java에서는 Integer

(자바 버전) 간단히 말해서 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...}

당신이 배우면 int a를 쓸 때 내 지식에 따라 자바에서; 그런 다음 Java generic에서는 다음과 같은 코드를 컴파일합니다.Integer a = new Integer() . 따라서 제네릭 Integer에 따라 사용되지 않지만 사용 int됩니다. 그와 같은 차이가 있습니다.

int 는 기본 데이터 유형입니다. 정수 는 랩퍼 클래스입니다. int 데이터를 객체로 저장할 수 있습니다.

int는 기본 데이터 유형 인 반면 Integer는 객체입니다. Integer로 객체를 만들면 Integer 클래스에서 사용할 수있는 모든 메서드에 액세스 할 수 있습니다. 그러나 int로 기본 데이터 유형을 작성하면 해당 빌드 메소드를 사용할 수 없으므로 직접 정의해야합니다. 그러나 다른 방법을 원하지 않고 프로그램의 메모리 효율성을 높이려면 객체를 만들면 메모리 소비가 증가하므로 기본 데이터 유형을 사용할 수 있습니다.