ความแตกต่างระหว่าง int และ Integer ใน Java และ C # คืออะไร?

ฉันอ่านJoel เพิ่มเติมเกี่ยวกับซอฟต์แวร์เมื่อฉันเจอJoel Spolskyพูดบางอย่างเกี่ยวกับโปรแกรมเมอร์ชนิดหนึ่งที่รู้ถึงความแตกต่างระหว่างintและกับIntegerใน Java / C # (ภาษาโปรแกรมเชิงวัตถุ)

ดังนั้นความแตกต่างคืออะไร?

ใน Javaประเภท 'int' เป็นแบบดั้งเดิมในขณะที่ชนิด 'จำนวนเต็ม' เป็นวัตถุ

ใน C #ประเภท 'int' จะเหมือนกันSystem.Int32และเป็นประเภทค่า (เช่นมากกว่า java 'int') จำนวนเต็ม (เช่นเดียวกับประเภทของค่าอื่น ๆ ) สามารถบรรจุกล่อง ("ห่อ") ลงในวัตถุ

ความแตกต่างระหว่างออบเจ็กต์และดั้งเดิมนั้นค่อนข้างเกินขอบเขตของคำถามนี้ แต่เพื่อสรุป:

วัตถุที่ให้ความสะดวกแก่ polymorphism จะผ่านอ้างอิง (หรือมากกว่าถูกต้องมีการอ้างอิงผ่านค่า) และได้รับการจัดสรรจากกอง ในทางกลับกันprimitivesเป็นประเภทที่ไม่เปลี่ยนรูปซึ่งถูกส่งผ่านโดยค่าและมักถูกจัดสรรจากสแต็ก

ใน Java นั้น int เป็นพื้นฐานในขณะที่ Integer เป็นวัตถุ หมายความว่าถ้าคุณสร้าง Integer ใหม่:

Integer i = new Integer(6);

คุณสามารถเรียกวิธีการบางอย่างกับฉัน:

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 (พร้อมด้วยถ่านและอื่น ๆ ) ฉันไม่แน่ใจ 100% แต่ฉันคิดว่าจำนวนเต็มวัตถุมีคุณสมบัติ int และวิธีการโต้ตอบกับคุณสมบัตินั้น (เช่น toString () ตัวอย่าง) ทั้งหมด ดังนั้นจำนวนเต็มเป็นวิธีแฟนซีในการทำงานกับ int (เช่นเดียวกับ String เป็นวิธีแฟนซีในการทำงานกับกลุ่มตัวอักษร)

ฉันรู้ว่า Java ไม่ใช่ C แต่เนื่องจากฉันไม่เคยตั้งโปรแกรมใน C นี่จึงเป็นคำตอบที่ใกล้เคียงที่สุด หวังว่านี่จะช่วยได้!

วัตถุจำนวนเต็ม javadoc

จำนวนเต็มเปรียบเทียบ Ojbect กับการเปรียบเทียบแบบดั้งเดิม

ฉันจะเพิ่มคำตอบที่ยอดเยี่ยมที่ได้รับข้างต้นและพูดคุยเกี่ยวกับการชกมวยและ unboxing และวิธีการนี้ใช้กับ Java (แม้ว่า C # ก็มีเช่นกัน) ฉันจะใช้คำศัพท์ Java เพียงเพราะฉันเป็นau faitมากขึ้นด้วย

เป็นคำตอบที่กล่าวถึงintเป็นเพียงตัวเลข (เรียกว่าunboxedประเภท) ในขณะที่Integerเป็นวัตถุ (ซึ่งมีจำนวนจึงเป็นชนิดกล่อง ) ในแง่ของจาวานั่นหมายถึง (นอกเหนือจากที่ไม่สามารถเรียกใช้เมธอดได้int) คุณไม่สามารถจัดเก็บintหรือประเภทที่ไม่ใช่วัตถุอื่น ๆ ในคอลเลกชัน ( List,Mapฯลฯ ) ในการจัดเก็บพวกเขาคุณจะต้องทำมันด้วยกล่องที่เกี่ยวข้องก่อน

Java 5 เป็นต้นไปมีบางสิ่งที่เรียกว่าauto-boxingและauto-unboxingซึ่งช่วยให้สามารถทำการ Boxing / unboxing ได้หลังฉาก เปรียบเทียบและความคมชัด: Java 5 เวอร์ชัน:

Deque<Integer> queue;

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

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

Java 1.4 หรือรุ่นก่อนหน้า (ไม่มี generics ใด ๆ ):

Deque queue;

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

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

จะต้องมีการตั้งข้อสังเกตว่าแม้จะมีความกะทัดรัดใน Java 5 รุ่นทั้งสองรุ่นจะสร้างรหัสไบต์เหมือนกัน ดังนั้นแม้ว่า auto-Boxing และ auto-unboxing จะสะดวกมากเพราะคุณเขียนโค้ดน้อยลง แต่การดำเนินการเหล่านี้ก็ทำได้เกิดขึ้นเบื้องหลังที่มีค่าใช้จ่ายรันไทม์เดียวกันดังนั้นคุณยังจะต้องตระหนักถึงการดำรงอยู่ของพวกเขา

หวังว่านี่จะช่วยได้!

ฉันจะโพสต์ที่นี่เนื่องจากโพสต์อื่น ๆ มีความผิดพลาดเล็กน้อยเกี่ยวกับ C #

ที่ถูกต้อง: เป็นนามแฝงสำหรับint ผิด:ไม่ใช่นามแฝงสำหรับแต่เพื่อSystem.Int32
floatSystem.FloatSystem.Single

โดยทั่วไป int เป็นคำหลักที่สงวนไว้ในภาษาการเขียนโปรแกรม C # และเป็นชื่อแทนสำหรับSystem.Int32ประเภทค่า

float และ Float ไม่เหมือนกันอย่างไรก็ตามเป็นประเภทระบบที่เหมาะสมสำหรับ ''float '' คือ System.Single มีบางประเภทเช่นนี้ที่จองคำหลักที่ดูเหมือนจะไม่ตรงกับชื่อประเภทโดยตรง

ใน C # ไม่มีความแตกต่างระหว่าง '' int'' และ ''System.Int32 '' หรือคู่อื่น ๆ หรือคำหลัก / ประเภทระบบยกเว้นเมื่อกำหนด enums ด้วย enums คุณสามารถระบุขนาดหน่วยเก็บข้อมูลที่จะใช้และในกรณีนี้คุณสามารถใช้คีย์เวิร์ดที่สงวนไว้เท่านั้นและไม่ใช่ชื่อประเภทรันไทม์ของระบบ

หากค่าใน int จะถูกเก็บไว้ในสแต็กในหน่วยความจำหรือเป็นวัตถุฮีปที่อ้างอิงขึ้นอยู่กับบริบทและวิธีการใช้งานของคุณ

ประกาศนี้ในวิธีการ:

int i;

กำหนดตัวแปรiประเภทSystem.Int32อยู่ในรีจิสเตอร์หรือบนสแต็กขึ้นอยู่กับการปรับให้เหมาะสม การประกาศเดียวกันในประเภท (struct หรือคลาส) กำหนดเขตข้อมูลสมาชิก การประกาศเดียวกันในรายการอาร์กิวเมนต์เมธอดกำหนดพารามิเตอร์โดยมีตัวเลือกหน่วยเก็บข้อมูลเดียวกันสำหรับตัวแปรโลคัล (โปรดทราบว่าย่อหน้านี้ไม่ถูกต้องหากคุณเริ่มดึงวิธีการวนซ้ำในการผสมสัตว์เหล่านี้ต่างกันโดยสิ้นเชิง)

รับวัตถุกองคุณสามารถใช้มวย:

object o = i;

สิ่งนี้จะสร้างสำเนาของเนื้อหาของiบนกองที่บรรจุอยู่ในกล่อง ใน IL คุณสามารถเข้าถึงวิธีการบนวัตถุฮีปโดยตรง แต่ใน C # คุณต้องแปลงกลับไปเป็น int ซึ่งจะสร้างสำเนาอีกชุด ดังนั้นวัตถุบนฮีปจะไม่สามารถเปลี่ยนแปลงได้อย่างง่ายดายใน C # โดยไม่ต้องสร้างสำเนาของกล่องใหม่ของค่า int ใหม่ (อ๊ะย่อหน้านี้ไม่ได้อ่านทุกเรื่องง่าย)

เกี่ยวกับ Java 1.5 และautoboxingมี "การเล่นโวหาร" ที่สำคัญที่มาเล่นเมื่อเปรียบเทียบวัตถุจำนวนเต็ม

ใน Java วัตถุจำนวนเต็มที่มีค่า -128 ถึง 127 จะไม่เปลี่ยนรูป (นั่นคือสำหรับค่าจำนวนเต็มหนึ่งค่าโดยบอกว่า 23 วัตถุจำนวนเต็มทั้งหมดของอินสแตนซ์ผ่านโปรแกรมของคุณด้วยค่า 23 คะแนนไปยังวัตถุเดียวกันที่แน่นอน )

ตัวอย่างนี้คืนค่าจริง:

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.equals () เสมอเมื่อเปรียบเทียบวัตถุจำนวนเต็ม

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

ข้อมูลเพิ่มเติมที่java.netตัวอย่างที่bexhuff.com

ใน Java มีสองประเภทพื้นฐานในJVM JVM1) ประเภทดั้งเดิมและ 2) ประเภทอ้างอิง int เป็นชนิดดั้งเดิมและจำนวนเต็มเป็นประเภทคลาส (ซึ่งเป็นประเภทอ้างอิง)

ค่าดั้งเดิมไม่แบ่งปันสถานะกับค่าดั้งเดิมอื่น ๆ ตัวแปรที่มีชนิดเป็นชนิดดั้งเดิมจะมีค่าดั้งเดิมของประเภทนั้นเสมอ

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 ทุกอย่างถูกส่งผ่านโดยค่า ด้วยวัตถุค่าที่ส่งผ่านคือการอ้างอิงไปยังวัตถุ ดังนั้นความแตกต่างระหว่าง int และ Integer ใน java คือวิธีการส่งผ่านในการเรียกใช้เมธอด ยกตัวอย่างเช่น

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: Pass โดยการอ้างอิงจะทำงานได้เช่น:

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, etc. เพราะพวกเขาไม่ต้องการusing System;คำสั่ง :) เหตุผลที่โง่เขลาฉันรู้ ...

มีหลายเหตุผลที่จะใช้คลาส wrapper:

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 a = new Integer();

ในแพลตฟอร์มเช่น Java นั้นints เป็นพื้นฐานในขณะที่Integerเป็นวัตถุที่เก็บฟิลด์จำนวนเต็ม ความแตกต่างที่สำคัญคือดั้งเดิมจะถูกส่งผ่านไปรอบ ๆ ตามค่าและโดยนิยามไม่เปลี่ยนรูป

การดำเนินการใด ๆ ที่เกี่ยวข้องกับตัวแปรดั้งเดิมจะส่งคืนค่าใหม่เสมอ ในทางกลับกันวัตถุจะถูกส่งผ่านโดยอ้างอิง หนึ่งอาจโต้แย้งว่าจุดไปยังวัตถุ (การอ้างอิง AKA) ก็ถูกส่งไปตามค่า แต่เนื้อหาไม่ได้

อีกสิ่งหนึ่งที่ฉันไม่เห็นในคำตอบก่อนหน้านี้: ใน Java คลาส wrappers ดั้งเดิมเช่น Integer, Double, Float, Boolean ... และ String ถูกแทนที่ให้คงที่ดังนั้นเมื่อคุณผ่านอินสแตนซ์ของคลาสที่ถูกเรียก วิธีการไม่สามารถแก้ไขข้อมูลของคุณในทางใดทางหนึ่งในopositiónกับคลาสอื่น ๆ ส่วนใหญ่ซึ่งข้อมูลภายในสามารถเปลี่ยนแปลงได้โดยวิธีสาธารณะ เพื่อให้คลาสนี้มีเมธอด 'getter' เท่านั้นไม่มี 'setters' นอกจากตัวสร้าง

ในโปรแกรมจาวาสตริงตัวอักษรจะถูกเก็บไว้ในส่วนที่แยกต่างหากของหน่วยความจำฮีปเฉพาะอินสแตนซ์สำหรับตัวอักษรเพื่อบันทึกหน่วยความจำที่ใช้ซ้ำอินสแตนซ์เหล่านั้น

คุณเคยตั้งโปรแกรมมาก่อนแล้ว (int) เป็นหนึ่งในประเภทดั้งเดิมที่คุณสามารถตั้งค่าให้กับตัวแปรของคุณ (เช่น char, float, ... )

แต่ Integer เป็นคลาส wrapper ที่คุณสามารถใช้เพื่อทำบางฟังก์ชั่นในตัวแปร int (เช่นแปลงเป็น string หรือ vise ในทางกลับกัน, ... ) แต่ให้จำไว้ว่าเมธอดในคลาส wrapper คงที่เพื่อให้คุณสามารถใช้งานได้ ทุกเวลาโดยไม่ต้องสร้างอินสแตนซ์ของคลาส Integer เป็นบทสรุป:

int x;
Integer y; 

x และ y เป็นทั้งตัวแปรชนิด int แต่ y ถูกห่อด้วยคลาส Integer และมีวิธีการหลายอย่างที่คุณใช้ แต่ในกรณีที่คุณต้องเรียกใช้ฟังก์ชันบางอย่างของคลาส wrapper ของ Integer ที่คุณสามารถทำได้

Integer.toString(x);

แต่ระวังให้ดีว่าทั้ง x และ y นั้นถูกต้อง แต่ถ้าคุณต้องการใช้มันในรูปแบบดั้งเดิมให้ใช้รูปแบบง่าย ๆ (ใช้เพื่อกำหนด x)

Java:

int, double, long, byte, float, double, short, boolean, char- วิทยาการ ใช้เพื่อเก็บประเภทข้อมูลพื้นฐานที่รองรับโดยภาษา ประเภทดั้งเดิมไม่ได้เป็นส่วนหนึ่งของลำดับชั้นวัตถุและพวกเขาไม่ได้รับมรดกวัตถุ Thet can'be ผ่านการอ้างอิงถึงวิธีการ

Double, Float, Long, Integer, Short, Byte, CharacterและBooleanเป็นพิมพ์ห่อบรรจุในjava.langเป็นพิมพ์ห่อบรรจุในตัวห่อชนิดตัวเลขทั้งหมดกำหนดตัวสร้างที่อนุญาตให้วัตถุถูกสร้างจากค่าที่กำหนดหรือการแทนค่าสตริงของค่านั้น การใช้วัตถุสามารถเพิ่มโอเวอร์เฮดให้กับการคำนวณที่ง่ายที่สุด

เริ่มต้นด้วย JDK 5, Java ได้รวมสองคุณสมบัติที่เป็นประโยชน์มาก: autoboxing และ autounboxing Autoboxing / unboxing ช่วยลดความยุ่งยากและเพิ่มความคล่องตัวของรหัสที่ต้องแปลงประเภทดั้งเดิมเป็นวัตถุและในทางกลับกัน

ตัวอย่างของการก่อสร้าง:

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

ตัวอย่างของ autoboxing / autounboxing:

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 (ที่มี capital I) ถือการอ้างอิงไปยัง object ของ (class) type Integer หรือ null

Java ปลดเปลื้องโดยอัตโนมัติระหว่างสอง; จากจำนวนเต็มถึง int ทุกครั้งที่วัตถุจำนวนเต็มเกิดขึ้นเป็นอาร์กิวเมนต์ให้กับตัวดำเนินการ int หรือถูกกำหนดให้กับตัวแปร int หรือค่า int ถูกกำหนดให้กับตัวแปร Integer การคัดเลือกนักแสดงนี้เรียกว่า Boxing / unboxing

ถ้าตัวแปรอ้างอิงจำนวนเต็มเป็นโมฆะไม่มีการบอกกล่าวอย่างชัดเจนหรือโดยปริยาย NullPointerException จะถูกโยนทิ้ง

int และ Integer ใน Java และ C # เป็นคำศัพท์สองคำที่ใช้แทนสิ่งต่าง ๆ เป็นหนึ่งในชนิดข้อมูลดั้งเดิมที่สามารถกำหนดให้กับตัวแปรที่สามารถจัดเก็บอย่างแน่นอน หนึ่งค่าของชนิดที่ประกาศในแต่ละครั้ง

ตัวอย่างเช่น:

int number = 7;

ที่ไหน intเป็นประเภทข้อมูลที่ได้รับมอบหมายจำนวนตัวแปรที่เก็บค่าเจ็ด ดังนั้นการintเป็นแบบดั้งเดิมไม่ใช่วัตถุ

ในขณะที่ Integerเป็นคลาส wrapper สำหรับชนิดข้อมูลดั้งเดิมซึ่งมีวิธีการคงที่ ที่สามารถใช้เป็นข้อโต้แย้งไปยังวิธีการที่ต้องใช้วัตถุที่เป็น int สามารถใช้เป็นข้อโต้แย้งกับวิธีการที่ต้องใช้ค่าจำนวนเต็มที่สามารถใช้สำหรับการแสดงออกทางคณิตศาสตร์

ตัวอย่างเช่น:

Integer number = new Integer(5);

ในทั้งสองภาษา (Java และ C #) intเป็นจำนวนเต็มแบบ 4 ไบต์

แตกต่างจาก Java, C # ให้ทั้งค่าจำนวนเต็มเซ็นชื่อและไม่ได้ลงนาม เนื่องจาก Java และ C # เป็นวัตถุเชิงวัตถุการดำเนินการบางอย่างในภาษาเหล่านี้จึงไม่ได้แมปลงบนคำแนะนำโดยตรงจากเวลาทำงานดังนั้นจึงจำเป็นต้องกำหนดเป็นส่วนหนึ่งของวัตถุบางประเภท

C # ให้System.Int32ซึ่งเป็นประเภทค่าโดยใช้ส่วนหนึ่งของหน่วยความจำที่เป็นของประเภทอ้างอิงในกอง

Java ให้ซึ่งเป็นรูปแบบการดำเนินงานในการอ้างอิงjava.lang.Integer intวิธีการในการIntegerไม่สามารถรวบรวมโดยตรงกับเวลาทำงานเรา instructions.So กล่องค่า int แปลงเป็นตัวอย่างของจำนวนเต็มและใช้วิธีการที่คาดว่าตัวอย่างของบางประเภท (เช่นtoString(), parseInt(), valueOf()ฯลฯ )

ใน C # ตัวแปร int หมายถึงSystem.Int32.Anyค่า 4 ไบต์ในหน่วยความจำสามารถตีความว่าเป็น int ดั้งเดิมที่สามารถจัดการโดยตัวอย่างของ System.Int32.So int เป็นนามแฝงสำหรับSystem.Int32.Whenการใช้วิธีการที่เกี่ยวข้องกับจำนวนเต็มชอบint.Parse(), int.ToString()ฯลฯ จำนวนเต็มเรียบเรียง โครงสร้าง FCL System.Int32เรียกวิธีการที่เกี่ยวข้องเช่นInt32.Parse(), Int32.ToString().

ใน Java intประเภทนี้เป็นชนิดข้อมูลดั้งเดิมโดยที่Integerประเภทเป็นวัตถุ

ใน C # ที่ประเภทยังเป็นชนิดข้อมูลเช่นเดียวกับint (เช่นเดียวกับค่าประเภทอื่น ๆ ) สามารถบรรจุกล่อง ( "ห่อ") เป็นวัตถุSystem.Int32integer

ใน 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" เป็นชนิดข้อมูลดั้งเดิมและ "จำนวนเต็ม" ใน Wrapper Class ใน Java "จำนวนเต็ม" สามารถใช้เป็นอาร์กิวเมนต์สำหรับวิธีการที่ต้องใช้วัตถุโดยที่ "int" สามารถใช้เป็นอาร์กิวเมนต์สำหรับวิธีการที่ต้องการค่าจำนวนเต็มซึ่งสามารถใช้สำหรับนิพจน์ทางคณิตศาสตร์ได้

01. จำนวนเต็มอาจเป็นโมฆะ แต่ int ไม่สามารถเป็นค่าว่างได้

Integer value1 = null; //OK

int value2 = null      //Error

02. สามารถส่งค่าประเภทของ Wrapper Classes ไปยังคลาสคอลเลคชันใดก็ได้

(คลาส Wrapper - บูลีน, ตัวละคร, 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.

Autoboxing เป็นการแปลงอัตโนมัติที่คอมไพเลอร์ java สร้างขึ้นระหว่างชนิดดั้งเดิมและคลาส wrapper ที่สอดคล้องกัน

จากนั้น 5 แปลงเป็นค่าจำนวนเต็มโดยการล็อกอัตโนมัติ

int ถูกกำหนดไว้ล่วงหน้าในฟังก์ชั่นห้องสมุด c # แต่ในจาวาเราสามารถสร้างวัตถุ Integer

(เวอร์ชัน Java) ใน Simple words int เป็นพื้นฐานและ Integer เป็น wrapper วัตถุสำหรับ int

ตัวอย่างหนึ่งที่จะใช้ Integer vs 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; แล้วใน java Integer a = new Integer()ทั่วไปก็จะรวบรวมรหัสเช่น ดังนั้นตาม generics Integerไม่ได้ใช้ แต่intใช้ ดังนั้นจึงมีความแตกต่างเช่นนั้น

intเป็นชนิดข้อมูลดั้งเดิม จำนวนเต็มเป็นคลาส wrapper มันสามารถเก็บข้อมูล int เป็นวัตถุ

int เป็นประเภทข้อมูลดั้งเดิมในขณะที่จำนวนเต็มเป็นวัตถุ การสร้างออบเจ็กต์ด้วย Integer จะช่วยให้คุณสามารถเข้าถึงวิธีการทั้งหมดที่มีอยู่ในคลาส Integer แต่ถ้าคุณสร้างชนิดข้อมูลดั้งเดิมด้วย int คุณจะไม่สามารถใช้วิธีการแบบบิวด์อินเหล่านั้นและคุณต้องกำหนดด้วยตัวเอง แต่ถ้าคุณไม่ต้องการวิธีอื่นใดและต้องการทำให้โปรแกรมมีประสิทธิภาพมากขึ้นคุณสามารถใช้ชนิดข้อมูลดั้งเดิมได้เพราะการสร้างวัตถุจะเพิ่มปริมาณการใช้หน่วยความจำ