質問

読んでいた Joel のソフトウェアについての詳細 出会ったとき ジョエル・スポルスキー 特定のタイプのプログラマについて何かを言っているが、プログラマとプログラマの違いを知っている intInteger Java/C# (オブジェクト指向プログラミング言語)。

それで、違いは何ですか?

役に立ちましたか?

解決

Javaでは、 'int' 型はプリミティブですが、'Integer' 型はオブジェクトです。

C#では、 'int' 型は次と同じです System.Int32 そして 値の型 (つまり、Java の「int」に似ています)。整数は (他の値の種類と同様に) 箱入り (「ラップ」) オブジェクトに組み込まれます。


オブジェクトとプリミティブの違いは、この質問の範囲をやや超えていますが、要約すると次のようになります。

オブジェクト ポリモーフィズムの機能を提供し、参照によって渡され (より正確には、値によって参照が渡されます)、から割り当てられます。 ヒープ. 。逆に、 プリミティブ 値によって渡される不変型であり、多くの場合、 スタック.

他のヒント

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 の数少ないプリミティブの 1 つです (char などと同様)。100%確信はありませんが、Integer オブジェクトには多かれ少なかれ int プロパティと、そのプロパティと対話するための多数のメソッド (たとえば toString() メソッドなど) があるだけだと考えています。つまり、Integer は int を扱うための優れた方法です (おそらく String が char のグループを扱うための優れた方法であるのと同じです)。

Java が C ではないことはわかっていますが、C でプログラミングしたことがないので、これが答えに最も近いものです。お役に立てれば!

整数オブジェクトの Javadoc

整数オブジェクト vs.int プリミティブ比較

上記の優れた回答に加えて、ボックス化とアンボックス化、およびこれが 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# プログラミング言語の予約キーワードであり、 System.Int32 値のタイプ。

ただし、 float と Float は、 '' の正しいシステム型としては同じではありません。float'' は System.Single です。このように、タイプ名と直接一致しないように見える予約キーワードを持つタイプがいくつかあります。

C# では、'' の間に違いはありません。int'' そして ''System.Int32''、または他のペアまたはキーワード/システム タイプ (列挙型を定義する場合を除く)。列挙型を使用すると、使用するストレージ サイズを指定できます。この場合、予約されたキーワードのみを使用でき、システム ランタイム型名は使用できません。

int の値がスタック、メモリ、または参照ヒープ オブジェクトとして保存されるかどうかは、コンテキストとその使用方法によって異なります。

メソッド内でのこの宣言は次のようになります。

int i;

変数を定義します i タイプの System.Int32, 、最適化に応じて、レジスタまたはスタック上に存在します。型 (構造体またはクラス) 内の同じ宣言により、メンバー フィールドが定義されます。メソッドの引数リスト内の同じ宣言により、ローカル変数と同じ格納オプションを使用してパラメータが定義されます。(反復子メソッドをミックスに取り込み始めた場合、この段落は無効になることに注意してください。これらはまったく異なるものです)

ヒープ オブジェクトを取得するには、ボックス化を使用できます。

object o = i;

これにより、コンテンツのボックス化されたコピーが作成されます。 i 山の上に。IL ではヒープ オブジェクトのメソッドに直接アクセスできますが、C# ではそれを int にキャストして戻す必要があり、別のコピーが作成されます。したがって、新しい int 値の新しいボックス化されたコピーを作成しない限り、ヒープ上のオブジェクトを C# で簡単に変更することはできません。(うーん、この段落はそれほど読みにくいです。)

Java1.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 には 2 つの基本的な型があります。 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 ではすべてが値によって渡されます。オブジェクトの場合、渡される値はオブジェクトへの参照です。したがって、Java における int と Integer のもう 1 つの違いは、それらがメソッド呼び出しで渡される方法です。たとえば、

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

インクリメントが呼び出されると、変数への参照 (ポインタ) が渡されます。 ある. 。そしてその インクリメント 関数は変数を直接変更します ある.

オブジェクト タイプの場合は次のように動作します。

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. Null 値を保存できますが、プリミティブでは保存できません。
  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はプリミティブですが、 Integer 整数フィールドを保持するオブジェクトです。重要な違いは、プリミティブは常に値によって渡され、定義上不変であることです。

プリミティブ変数を含む操作は常に新しい値を返します。一方、オブジェクトは参照によって受け渡されます。オブジェクトへのポイント (別名参照) も値によって受け渡されますが、内容はそうではないと主張する人もいます。

以前の回答では見られないことがもう 1 つあります。Java では、Integer、Double、Float、Boolean などのプリミティブ ラッパー クラスが使用されます。と String は不変であると想定されているため、これらのクラスのインスタンスを渡すとき、呼び出されたメソッドはいかなる方法でもデータを変更できません。これは、他のほとんどのクラスとは対照的に、パブリック メソッドによって内部データが変更される可能性があります。そのため、このクラスにはコンストラクターのほかに「ゲッター」メソッドのみがあり、「セッター」はありません。

Java プログラムでは、文字列リテラルはヒープ メモリの別の部分 (リテラルのインスタンスのみ) に格納され、これらのインスタンスを再利用してメモリを節約します。

(int) は、変数に設定できるプリミティブ型の 1 つです (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 には 2 つの非常に便利な機能が含まれています。自動ボックス化と自動アンボックス化。オートボックス化/アンボックス化により、プリミティブ型をオブジェクトに、またはその逆に変換する必要があるコードが大幅に簡素化および合理化されます。

コンストラクターの例:

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

追伸ハーバート・シルトの本を参考にしました。

整数 はプリミティブなデータ型です。整数 ラッパークラスです。int データをオブジェクトとして保存できます。

int 変数は 32 ビットの符号付き整数値を保持します。Integer (大文字の I) は、(クラス) Integer 型のオブジェクト、または null への参照を保持します。

Java は 2 つの間で自動的にキャストします。Integer オブジェクトが int 演算子の引数として出現するか、int 変数に割り当てられるか、または int 値が Integer 変数に割り当てられるたびに、Integer から int に変換されます。このキャスティングをボックス化/アンボックス化と呼びます。

null を参照する整数変数が明示的または暗黙的にボックス化解除されると、NullPointerException がスローされます。

Java と C# における int と Integer は、異なるものを表すために使用される 2 つの異なる用語です。これは、正確に格納できる変数に割り当てることができるプリミティブ データ型の 1 つです。宣言された型の値を一度に 1 つずつ。

例えば:

int number = 7;

どこ int は、値 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() 等)。

C# では変数 int が参照します System.Int32.Any メモリ内の 4 バイト値は、System.Int32 のインスタンスによって操作できるプリミティブ int として解釈できます。したがって、int は次のエイリアスです。 System.Int32.When 次のような整数関連のメソッドを使用する int.Parse(), int.ToString() 等整数は FCL にコンパイルされます System.Int32 次のようなそれぞれのメソッドを呼び出す構造体 Int32.Parse(), Int32.ToString().

Javaでは、 int type はプリミティブ データ型です。 Integer type はオブジェクトです。

C# では、 int type も同じデータ型です System.Int32. 。アン integer (他の値タイプと同様に) オブジェクトにボックス化 (「ラップ」) できます。

Java では、int はプリミティブ データ型であり、Integer はヘルパー クラスであり、あるデータ型を別のデータ型に変換するために使用されます。

例えば:

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

プリミティブ データ型は、ヘルパー クラスが複雑な場合に使用可能な最速のメモリを格納し、ヒープ メモリに格納します。

「David Gassner」の Java Essential Training からの参照。

「int」はプリミティブデータ型であり、Java のラッパークラスの「Integer」です。「Integer」はオブジェクトを必要とするメソッドの引数として使用でき、「int」は整数値を必要とするメソッドの引数として使用でき、算術式に使用できます。

01.整数は null にすることもできます。ただし、int を null にすることはできません。

Integer value1 = null; //OK

int value2 = null      //Error

02.ラッパー クラスの型の値を任意のコレクション クラスに渡すことのみが可能です。

(ラッパークラス - Boolean、Character、Byte、Short、Integer、Long、Float、Double)

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コンパイラがプリミティブタイプと対応するラッパークラスの間で行う自動変換です。

次に、オートボックス化により整数値として変換します。

int はライブラリ関数C#で事前定義されていますが、Javaではオブジェクトを作成できます Integer

(Javaバージョン)単純な言葉では、Intは原始的であり、整数はintのラッパーオブジェクトです。

Integer と int を使用する例の 1 つ。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...}

あなたが学習者であれば、私の知識によると、Javaでは、 int a; と書くと、次に、Javaジェネリックでは次のようなコードをコンパイルします Integer a = new Integer()。したがって、ジェネリック医薬品に従って Integer 使用されていませんが、 int 使用されている。それほど大きな違いがあるのです。

ライセンス: CC-BY-SA帰属
所属していません StackOverflow
scroll top